在b站看了一下沐神的视频以及看了一下他的动手深度学习系列)
学到了许多，将自己练习的一下代码放在这里,，和原版的区别应该就是多了一些注释吧。这里就不多加说明一些基本的理论，主要是放代码。

一，线性回归的从零开始实现

主要包括以下几步： 生成数据集 读取数据集 初始化模型参数 定义模型（假设函数） 定义损失函数 定义优化算法 训练

1 数据的生成和读取

  1. #其实第一步应该是按照这些包的，但是这么简单的事情直接去看文档或者视频吧
  2. %matplotlib inline
  3. import random
  4. import torch
  5. from d2l import torch as d2l
  1. #构造一个数据集,w[2,-3.4]T,b=4.2，噪声随机
  2. def synthetic_data(w,b,num_examples):
  3.     """生成y=Xw+b+噪声"""
  4.     x=torch.normal(0,1,(num_examples,len(w)))#均值为0，方差为1的随机数，大小为n个样本，列数为len(w)
  5.     y=torch.matmul(x,w)+b #matmul是pytorch的乘法
  6.     y+=torch.normal(0,0.01,y.shape)
  7.     return x,y.reshape((-1,1)) #返回一个列向量
  1. true_w=torch.tensor([2,-3.4])
  2. true_b=4.2
  3. features,labels=synthetic_data(true_w,true_b,1000)
  1. print('features',features[0],'\nlabels:',labels[0]) #查看一下第一行的数字

image.png

  1. d2l.set_figsize()
  2. d2l.plt.scatter(features[:,(1)].detach().numpy(),labels.detach().numpy(),1);
  3. #绘图查看一下两者之间的关系，其中detach这个函数是将数字从计算图中取下来然后可以转换为numpy

image.png

  1. ##定义一个data_iter函数，该函数接收批量大小，特征矩阵，标签向量作为输入，生成batch_size大小批量
  2. def data_iter(batch_size,features,labels):
  3.     num_examples=len(features)
  4.     indices=list(range(num_examples))#从0到len(features)-1这么长的数字的一个列表
  6.     random.shuffle(indices)#随机读取样本，不按照特定顺序,这一步直接是混淆了上一步的indices，如果直接查看random((shuffle)前后indices会发现两者的结果完全不同
  7.     #print(indices)
  8.     for i in range(0,num_examples,batch_size): #range(start, stop[, step])
  9.         batch_indices=torch.tensor(indices[i:min(i+batch_size,num_examples)]) #生成一定长度的向量矩阵的索引位置，比如下面设置的10
  10.         yield features[batch_indices],labels[batch_indices] #带yield的函数是一个生成器，
  11.         #虽然和print或者return会很像，但是返回的是迭代对象，不会执行任何代码，data_iter也就变成了一个不会产生正常输出的对象，需要for循环或者使用next()
  12.         #方法进行读取
  13. batch_size=10
  15. for x,y in data_iter(batch_size,features,labels):
  16.     print(x,'\n',y)
  17.     break

2,初始化模型,损失函数，优化算法,训练

  1. # num_examples=len(features)
  2. # indices=list(range(num_examples))
  3. # random.shuffle(indices)
  4. #定义初始化模型函数
  5. w=torch.normal(0,0.01,size=(2,1),requires_grad=True) #均值为，方差为0.01的，2，1的矩阵
  6. b=torch.zeros(1,requires_grad=True) #初始值为0
  1. # 定义模型
  2. def linreg(x,w,b):
  3.     """线性回归模型"""
  4.     return torch.matmul(x,w)+b #toch.matmul是tensor的乘法
  1. #定义损失函数
  2. def squared_loss(y_hat,y):
  3.     """均方损失"""
  4.     return(y_hat-y.reshape(y_hat.shape))**2/2#因为y_hat的维度可能比较高，所以需要将y转换为和它一样的维度才能计算
  5. #这个是原本的计算公式
  1. #定义优化算法
  2. def sgd(params,lr,batch_size):
  3.     """小批量随机梯度下降"""
  4.     with torch.no_grad():
  5.         for param in params: #修改参数列表中的参数，lr是学习率
  6.             param-=lr*param.grad/batch_size #除以批量的大小，其实应该是在上面的loss那里除的，这样就可以计算每个样本的损失，但是这样是等价的
  7.             param.grad.zero_() #将梯度设置为0，这样就只有新的参数而不是带有旧的梯度，在更新的时候新参数就和旧的梯度无关
  1. #训练
  2. lr=0.03
  3. num_epochs=10
  4. net=linreg #模型，这里面指线性模型，以后可以修改
  5. loss=squared_loss
  7. for epoch in range(num_epochs):
  8.     for x,y in data_iter(batch_size,features,labels):
  9.         l=loss(net(x,w,b),y) #计算x和y的小批量损失,，先看上面的定义的函数，也就是先做假设函数，然后再计算损失
  10.         l.sum().backward()
  11.         sgd([w,b],lr,batch_size) #使用参数的梯度来更新参数
  12.     with torch.no_grad():
  13.         train_l=loss(net(features,w,b),labels)
  14.         print(f'epoch:{epoch+1},loss:{float(train_l.mean()):f}')
  1. print(f'w的估计误差;{true_w-w.reshape(true_w.shape)}')
  2. print(f'b的估计误差;{true_b-b}')

二，线性回归的简洁实现

  1. ##线性回归的简洁实现,也就是使用框架
  2. import numpy as np
  3. import torch
  4. from torch.utils import data #这里面会有一些处理数据的模块
  5. from d2l import torch as d2l

2.1 数据的获取

  1. true_w=torch.tensor([2,-3.4])
  2. true_b=4.2
  3. num_examples=len(features)
  4. features,labels=d2l.synthetic_data(true_w,true_b,num_examples) #数据生成
  1.  #批量分割
  2. def load_array(data_arrays,batch_size,is_train=True):
  3.     """构造一个pytorch迭代器"""
  4.     dataset=data.TensorDataset(*data_arrays)
  5.     return data.DataLoader(dataset,batch_size,shuffle=is_train) #Dataloader函数是随机调取
  6. batch_size=10
  7. data_iter=load_array((features,labels),batch_size)
  8. next(iter(data_iter))
  1. #使用框架的预定义好的层
  2. from torch import nn #nn是指神经网络
  3. net=nn.Sequential(nn.Linear(2,1))#只需要指定输入的维度是多少，把一些层按照顺序放在一起（sequntial的意思）
  4. #初始化模型参数
  5. net[0].weight.data.normal_(0,0.1)#使用均值为0，方差为0.01的正太分布替换data的值
  6. net[0].bias.data.fill_(0)#设置偏差为0
  7. #相当于我们之前手动实现的w，b
  1. #计算均方误差,使用的是MSELoss类，也被称为平方L2范数
  2. loss=nn.MSELoss()
  1. #优化算法，SGD实例化
  2. trainer=torch.optim.SGD(net.parameters(),lr=0.02) #传入所有的参数以及学习率
  1. num_epochs=5
  2. for epoch in range(num_epochs):
  3.     for x,y in data_iter: #一次一次将总数据中的一部分拿出来
  4.         l=loss(net(x),y) #首先计算损失函数，和之前不同的是模型自带参数，因此不需要进一步输入参数
  5.         trainer.zero_grad() #优化器先去除掉梯度
  6.         l.backward() #然后反向传播，也就是sum
  7.         trainer.step() #优化器对模型进行更新
  8.     d=loss(net(features),labels) #搞完之后对模型进行误差评估
  9.     print(f'epoch is {epoch+1},loss is {d:f}')