动手学深度学习：线性回归简洁实现

线性回归简洁实现

%matplotlib inline
import torch
from IPython import display
from matplotlib import pyplot as plt
import numpy as np
import random
num_inputs = 2
num_examples = 1000
true_w = [2, -3.4]
true_b = 4.2
features = torch.tensor(np.random.normal(0, 1, (num_examples, num_inputs)), dtype=torch.float)
labels = true_w[0] * features[:, 0] + true_w[1] * features[:, 1] + true_b
labels += torch.tensor(np.random.normal(0, 0.01, size=labels.size()), dtype=torch.float)

引入包data
import torch.utils.data as Data
#我们将随机读取包含10个数据样本的小批量。

batch_size=10
#将训练数据的特征和标签组合
dataset=Data.TensorDataset(features,labels)
#随机读取小批量
data_iter=Data.DataLoader(dataset,batch_size,shuffle=True)

X为特征，y为标签
for X, y in data_iter:
    print(X, y)
    break

显示十组样本
tensor([[-1.8260e-02, -1.8539e+00],
[ 2.7153e+00, -8.0274e-01],
[ 1.1816e+00, -1.6339e+00],
[ 6.7064e-01, 5.4746e-02],
[-2.3032e-03, -3.0165e-01],
[-1.4742e+00, -7.6091e-01],
[-8.5933e-02, -8.7749e-01],
[-1.1166e+00, -2.9864e-01],
[-1.1381e+00, -1.7337e+00],
[ 5.2272e-01, 3.4782e-01]]) tensor([10.4590, 12.3635, 12.1245, 5.3490, 5.2047, 3.8285, 7.0125, 3.0020,
7.8430, 4.0502])
#定义模型
#nn包就是利用autograd来定义模型
#nn的核心数据结构是Module，既可以表示神经网络中的某个层（layer），也可以表示一个包含很多层的神经网络。
#在实际使用中，最常见的做法是继承nn.Module，撰写自己的网络/层。一个nn.Module实例应该包含一些层以及返回输出的前向传播（forward）方法
###########
super（）函数用法
super可以代指父类。
可以使用super关键字调用init方法，
语法格式：super(子类，self).init(参数1，参数2，…)
效果等同于：父类名称.init(self,参数1，参数2，…)
此时调用父类，是为了使用nn的方法

#Linear()方法
a=nn.Linear(in,out)相当于定义了一个叫a的网络结构：y=x*w+b，w的size是（out,in）,b的size是(out)
    #in_features：前一层网络神经元的个数输入为x1，x2两个特征
    #out_features： 该网络层神经元的个数，输出为y
    作为一个单层神经网络，线性回归输出层中的神经元和输入层中各个输入完全连接。因此，线性回归的输出层又叫全连接层。

class LinearNet(torch.nn.Module):
    def __init__(self,n_feature):
     self.linear=nn.Linear(n_feature,1)
    #前向传播
    def forward(self,x):
        y=self.linear(x)
        return y
net=LinearNet(num_inputs)



#######写法二
# net = nn.Sequential(
#     nn.Linear(num_inputs, 1)
#     # 此处还可以传入其他层
#     )


########写法三
# Sequential()函数，是个容器，把网络添加进去
# net = nn.Sequential()
# net.add_module('linear', nn.Linear(num_inputs, 1))

print(net)#打印网络结构

nn.Module子类对象调用陪你过Module构造函数的方法net.parameters():
查看权重w及偏差b

#查看可学习参数，函数返回一个生成器
for param in net.parameters():
    print(param)

init模块初始化模型参数:
net.linear.weight,通过子类属性调用w,b
init.constant_:用val值填充输入张量或变量。
init.normal_：用正态分布N(均值，std)N(均值，std)来填充输入张量或变量。

#初始化模型参数
from torch.nn import init
init.normal_(net.linear.weight,mean=0,std=0.01)#w正态分布
init.constant_(net.linear.bias,val=0)#b偏差为零
#定义损失函数
loss = nn.MSELoss()#nn.Module子类，MSELoss以均方误差损失作为模型的损失函数

SGD梯度下降
optim模块， nn.Module方法.parameters(),修改超参数

#定义优化函数
import torch.optim as optim
#指定学习率为0.03的小批量随机梯度下降（SGD）为优化算法
#SGD是个字典
optimizer = optim.SGD(net.parameters(), lr=0.03)
print(optimizer)
#修改学习率
for param_group in optimizer.param_groups:
    param_group['lr'] *= 5 # 学习率为之前的0.1倍

SGD (
Parameter Group 0
dampening: 0
lr: 0.03
momentum: 0
nesterov: False
weight_decay: 0
)

##############
#训练模型
#为什么loss.backward()要放在optimizer.step()前面
#loss.backward（）是对w，b求导
#在计算模型中所有张量的梯度（loss.backward()）后,调用optimizer.step()会使优化器迭代它应该更新的所有参数(张量),
#并使用它们内部存储的grad来更新它们的值.
#顺序不可颠倒，没求梯度谈何更新
#注意每次迭代梯度更新

num_epochs = 3
for epoch in range(1, num_epochs + 1):
    #X为特征，y为label
    for X, y in data_iter:
        #net相当于神经网络，就是线性回归的模型
        optimizer.zero_grad() 
        output = net(X)
        l = loss(output, y.view(-1, 1))
       # 梯度清零，等价于net.zero_grad()，grad是累加的，每次迭代并不需要梯度累计
        l.backward()#小批量的损失对模型参数求梯度，对w，b求导
        #更新所有参数，更新模型[w,b]
        optimizer.step()
        #pytorch中的.item()用于将一个零维张量转换成浮点数
    print('epoch %d, loss: %f' % (epoch, l.item()))