学习使用pytorch构建线性回归模型

import torch
import torch.utils.data as Data
import torch.nn as nn
import torch.optim as optim
import numpy as np
'''
nn是neural networks，定义了大量神经网络的层。核心数据结构是Module
'''
#整一个线性模型：y = w1*x1 + w2*x2 + b

#1. 生成数据集
num_inputs = 2 #输入参数的数量
num_examples = 1000 #要生成的数据个数
lr = 0.03 #学习率
batch_size = 10 #取的时候一批10个
true_w = [0.6,-0.5] #真实权值
true_b = 2.2
features = torch.tensor(np.random.normal(loc=0,scale=1,size=(num_examples,num_inputs)),dtype=torch.float) #1000行2列，均值0，标准差1
labels = true_w[0] * features[:,0] + true_w[1] * features[:,1] + true_b

#2. 分批次读取数据
dataset = Data.TensorDataset(features,labels)
data_iter = Data.DataLoader(dataset,batch_size,shuffle=True)#迭代器
# for X,y in data_iter:
#     print(X,y)

#3. 定义模型,方法一
class LinearNet(nn.Module):
    def __init__(self, n_feature):
        # super(LinearNet,self) 首先找到 LinearNet 的父类，然后把类 LinearNet 的对象转换为父类nn.Module的对象
        super(LinearNet, self).__init__() #调用Module的初始化Linear
        self.linear = nn.Linear(n_feature, 1) #n_feature个输入,1个输出
    def forword(self,x):
        y = self.linear(x)
        return y
net = LinearNet(num_inputs) #这里的和下面使用Sequential模型不一样，这里只是定义了一层，不是整个网络，所以不能用net[0]
print(net)
for param in net.parameters():  #查看课学习的参数，下面可以设置自己想要的
    print(param)
'''
#定义模型，方法二，使用Sequential
#写法1
net2 = nn.Sequential(
    nn.Linear(num_inputs,1)
    #这里还可以传入其它层
)
#写法2
net3 = nn.Sequential()
net3.add_module('linear11',nn.Linear(num_inputs,1))

#写法3
from collections import OrderedDict
net4 = nn.Sequential(OrderedDict([
    ('linear',nn.Linear(num_inputs,1))
    #……
]))
print(net2)
print(net3)
print(net4)
print(net4[0])
'''
#4. 初始化模型参数
nn.init.normal_(net.linear.weight,mean=0,std=0.01) #net为一层，赋值为正态分布
nn.init.constant_(net.linear.bias,val=0)#复制为常量
'''
用第二种的比较简单，但第一种可以操控细节
init.normal_(net[0].weight, mean=0, std=0.01)
init.constant_(net[0].bias, val=0) # 也可以直接修改bias的data
'''
for param in net.parameters():
    print(param)

#5. 定义损失函数,nn模块定义了很多损失函数
loss = nn.MSELoss()

#6. 定义优化算法
'''
    为不同的自网络设置不同的学习率
    optimizer =optim.SGD([
        # 如果对某个参数不指定学习率，就使⽤最外层的默认学习率
        {'params': net.subnet1.parameters()}, # lr=0.03
        {'params': net.subnet2.parameters(), 'lr': 0.01}
    ], lr=0.03)
    
    实时调整学习率
    for param_group in optimizer.param_groups:
        param_group['lr'] *= 0.1 # 学习率为之前的0.1倍
'''
optimizer = optim.SGD(net.parameters(),lr=lr)
print(optimizer)

#7.训练模型
num_epochs = 3 #迭代轮数
for epoch in range(1, num_epochs+1):
    for X,y in data_iter: #X是输入，y是真实值，output是预测值
        output = net.forword(X) #使用第二种模型实现方法，只需要net[0](X)
        l = loss(output, y.view(-1,1)) #把y变成和output一样的维度
        optimizer.zero_grad() #梯度清零 等于net.zero_grad()
        l.backward() #自动梯度下降（用了这个之后，每个变量就可以得到梯度x.grad）
        optimizer.step() #优化
    print('epoch %d, loss: %f' % (epoch, l.item()))

#检测模型
print(net.linear.weight)
print(net.linear.bias)
print("error ",end="")
print(torch.tensor(true_w) - net.linear.weight)
print("error ",end="")
print(torch.tensor(true_b)-net.linear.bias)