使用pytorch实现线性回归（很基础模型搭建详解）

使用pytorch实现线性回归

步骤：

1.prepare dataset

2.design model using Class 目的是为了前向传播forward，即计算y hat（预测值）

3.Construct loss and optimizer (using pytorch API) 其中计算loss是为了进行反向传播，optimizer是为了更新梯度

4.Train Cycle

import torch

x_data = torch.Tensor([[1.0],[2.0],[3.0]])
y_data = torch.Tensor([[2.0],[4.0],[6.0]])

1.nn.Module: 是所有神经网络单元（neural network modules）的基类

nn：neural network

2.构造函数__init__()：是用来初始化对象的时候默认调用的函数

3.class torch.nn.Linear(in_features,out_features,bias=True) y = Ax+b

in_features : size of each input sample

out_features : size of each output sample

# 实例化模型
class LinearModel(torch.nn.Module):
    def __init__(self):
        super(LinearModel, self).__init__() # 调用父类的构造
        self.linear = torch.nn.Linear(1,1) # 实例化类，构造对象，包含了权重和偏置
        # Linear也是继承自module的，也能进行反向传播
        # nn：neural network
    def forward(self,x):
        y_pred = self.linear(x)
        return y_pred
    
model = LinearModel()

1.class torch.nn.MSELoss(size_average=True, reduce=True)

size_average：是否计算损失均值

reduce：

2.class torch.optim.SGD(model.parameters(),lr=<object object》,momentum=0,dampening=0,weight_decay=0,nesterov=False)

model.parameters(): 告诉优化器对哪些Tensor进行优化，检查所有成员

lr:learning rate 学习率

3.torch.nn.MSELoss也跟torch.nn.Module有关，参与计算图的构建，torch.optim.SGD与torch.nn.Module无关，不参与构建计算图。

# 定义损失函数
criterion = torch.nn.MSELoss(size_average=False)
# 定义优化器
optimizer = torch.optim.SGD(model.parameters(), lr = 0.01)

# 训练
for epoch in range(100):
    y_pred = model(x_data) # 计算y hat
    loss = criterion(y_pred,y_data) # 计算loss
    print(epoch,loss.item())
    
    # optimizer.zero_grad() # 梯度归零
    loss.backward() # 反向传播，计算梯度
    optimizer.step() # update 参数，即更新w和b的值
    optimizer.zero_grad() # 梯度归零

print('w=',model.linear.weight.item())
print('b=',model.linear.bias.item())

x_test = torch.Tensor([[4.0]])
y_test = model(x_test)
print('y_pred',y_test.data)

1.第三行直接使用对象调用函数（可调用对象）y_pred = model(x_data)：¶

Module实现了魔法函数__call__(),call()里面有一条语句是要调用forward()，因此新写类中需要重写forward()覆盖父类的forward()

call() 函数的作用四可以直接在对象后面加(),例如实例化的model对象，和实例化的linear对象

调用此方法：super(LinearModel, self).init() 实例化了父类中所有方法

2.每一次epoch的训练过程，总结就是

①前向传播，求y hat （输入的预测值）

②根据y_hat和y_label(y_data)计算loss

③反向传播 backward (计算梯度)

④根据梯度，更新参数

⑤梯度清零

3.optimizer.zero_grad()

因为grad在 反向传播 的过程中是累加的，也就是说上一次反向传播的结果会对下一次的反向传播的结果造成影响，则意味着每一次运行反向传播，梯度都会累加之前的梯度，所以一般在反向传播之前需要把梯度清零。

本次代码实现的是批量处理数据