5. 线性回归-pytorch实现

1.  本篇博客参照第四篇的步骤，使用pytorch实现的：

import numpy as np
import torch
import torch.utils.data as Data
from torch import nn
import torch.nn.init as init
# 数据集生成

num_inputs = 2
num_samples = 1000
true_weight = torch.tensor([[2],[-3.4]])
true_bais = torch.tensor([[4.2]])

features = torch.randn(num_samples,num_inputs,dtype=torch.float)
labels = torch.mm(features,true_weight)+true_bais
labels += torch.tensor(np.random.normal(0,0.01,size=labels.size()),dtype=torch.float)
# 数据读取
batch_size = 100
train_data =Data.TensorDataset(features,labels)
dataiter = Data.DataLoader(train_data,batch_size,shuffle=True)
#for x,y in dataiter:
    #print(y)
# 定义模型
class LineNet(nn.Module):
    def __init__(self,n_features):
        super(LineNet, self).__init__()
        self.linear = nn.Linear(n_features,1)

    def forward(self,x):
        return self.linear(x)

net = nn.Sequential(
         nn.Linear(num_inputs,1)
        )
print(net[0])
#for params in net[0].parameters():
    #print(params)
# 初始化模型参数
w = init.normal_(net[0].weight,mean=0,std=0.01,)
b = init.constant_(net[0].bias,val=0)
#定义损失函数
loss = nn.MSELoss()
#定义算法优化
optimzer = torch.optim.SGD(net[0].parameters(),lr=0.3)
#训练模型
def train_module(data_iter,epoches):
    for epoch in range(epoches):
        sum_loss,n = 0.0,0
        for x, y in data_iter:
            y_hat = net(x)
            l = loss(y_hat,y.view(-1,1))

            optimzer.zero_grad()
            l.backward()
            optimzer.step()
            n += y.shape[0]
            sum_loss += l.sum().item()
        print('epoch: %d,sum_loss %.4f '%(epoch, sum_loss/n))
        print(net[0].weight,net[0].bias)

train_module(dataiter,10)

 2. 相关知识补充：

• 从上一节从零开始的实现中，我们需要定义模型参数，并使用他们一步步描述模型是怎样计算的。当模型结果变得复杂时，这些步骤变得更加繁琐。其实pytorch提供了大量的预定义的层，这使我， 只需要关注使用哪些层来构造模型。下面介绍pytorch更加简洁的定义线性回归。

• 首先导入torch.nn 模块，实际上，nn是neural network的缩写。该模块定义了大量神经网络的层，之前使用过的autograd,而nn就是利用autograd来定义模型。

• nn的核心数据结构是Module，它是一个抽象概念，既可以表示神经网络中的某个层，也可以表示包含很多层的神经网络。

• 在实际使用中，通过会继承torch.Module，撰写自己的网络/层。一个nn.Module实例应该包含一些曾以及返回输出的前向传播(forward)方法.

# 定义模型
class LineNet(nn.Module):
    def __init__(self,n_features):
        super(LineNet, self).__init__()
        self.linear = nn.Linear(n_features,1)

    def forward(self,x):
        return self.linear(x)

 ######重点：

还可以用nn.Sequential来更加方便的搭建网络，Sequential是一个有序的容器，网络层将按照在传入的Sequential的顺序依次被添加到计算图中：

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


# 写法3

from collections import OrderedDict

net = nn.Sequential(
OrderedDict([
    ('linear',nn.Linear(num_inputs,1))
    # 其他的层
    
])
)

print(net)
print(net[0])

Sequential(
  (linear): Linear(in_features=2, out_features=1, bias=True)
)
Linear(in_features=2, out_features=1, bias=True)
 for param in net.parameters():
        print(param)
Parameter containing:
tensor([[-0.4229, -0.0282]], requires_grad=True)
Parameter containing:
tensor([0.0852], requires_grad=True)

#####上述写法：我一开始想访问每次2迭代后访问参数，用的net = LinearNet(num_inputs),没有想出来怎么访问，才使用的后面的这种方式，至于为什么这种方式可以，我也不知到，希望在后续的学习中可以了解到