深度学习（三）2.利用pytorch实现线性回归

标签：tensor grad self torch pytorch 深度线性梯度 data

一、基础概念

1.线性层

线性层（Linear Layer）是神经网络中的一种基本层，也称为全连接层（Fully Connected Layer）。
它的工作方式类似于简单的线性方程：y = Wx + b，其中 W 是权重矩阵，x 是输入，b 是偏置项，y 是输出。
线性层的主要任务是将输入的数据通过权重和偏置进行线性变换，从而生成输出。

2. 正向传播

正向传播（Forward Propagation）是神经网络计算输出的过程。
它从输入层开始，通过各个隐藏层，最后到达输出层，每一层的输出都是下一层的输入。
这个过程相当于逐层传递和处理信息。

3.反向传播

反向传播是一种计算梯度的算法，用于神经网络的训练过程。
它通过计算每个参数对损失函数的影响来更新网络的权重和偏置。
具体来说，它是通过链式法则来计算损失函数相对于每个参数的梯度，然后使用这些梯度来更新参数。

原文链接：https://blog.csdn.net/kljyrx/article/details/140269155

4.优化器

在深度学习中，优化器（optimizer）是一种用于调整神经网络模型参数以最小化损失函数的算法。优化器的目标是根据输入数据和期望的输出标签来调整模型的权重和偏置，使得模型能够更好地拟合训练数据并在未见过的数据上表现良好。

我们下面在四中用到的优化器就是SGD(随机梯度下降)

(1)SGD(随机梯度下降)

用于优化模型参数，通过更新参数以最小化损失函数。

公式：θ = θ - learning_rate * ∇J(θ)

其中，θ表示模型参数，learning_rate表示学习率，∇J(θ)表示损失函数J关于θ的梯度。

用法：常用于深度学习中的优化过程，每次迭代更新参数时仅使用一个样本或一小批样本。

主要参数：learning_rate（学习率）

优点：易于实现和理解，适用于大规模数据集。

缺点：可能陷入局部最小值，参数更新的震荡。

其他的优化器可以参考下面这篇文章。

原文链接：https://blog.csdn.net/AI_dataloads/article/details/133146550

二、利用顺序结构实现

在每次迭代中，首先计算预测值y_predict。
然后计算损失函数，这里使用的是均方误差（MSE）。
接下来，检查w和b的梯度是否存在（虽然在这个例子中它们总是存在的，因为我们在循环之前设置了requires_grad=True），并清零梯度。这是因为在PyTorch中，梯度会累积，所以每次迭代前需要清零。
调用loss.backward()来计算损失函数关于w和b的梯度。
最后，使用梯度下降法更新w和b的值。

'''y=wx+b'''

import torch
import matplotlib.pyplot as plt

#利用pytorch顺序实现线性回归

#1.准备数据集，真实房产数据
x_data=torch.tensor([[0.18],[0.1],[0.16],[0.08],[0.09],[0.11],[0.12],[0.17],[0.15],[0.14],[0.13]])
y_data=torch.tensor([[0.18],[0.1],[0.16],[0.08],[0.09],[0.11],[0.12],[0.17],[0.15],[0.14],[0.13]])

#2.定义参数
w=torch.tensor([[10]],requires_grad=True,dtype=torch.float32)   
b=torch.tensor([0],requires_grad=True,dtype=torch.float32)        #w 和 b 是模型的参数，分别表示权重和偏置。它们被初始化为张量，并设置了requires_grad=True，这样PyTorch就可以自动计算它们的梯度。
learning_rate=0.5    #定义学习率
epoch=5000     #迭代次数，表示整个数据集将被遍历多少次来更新参数。

#3.（训练模型）通过循环迭代逼近w与b真实值，也就是更新w，b参数，导数通过反向传播求导得到
for i in range(epoch):
    y_predict=torch.matmul(x_data,w)+b     #正向传播
    loss=(y_data-y_predict).pow(2).mean()  #计算均方差/损失函数
    
#梯度清零，在PyTorch中，梯度会累积，所以每次迭代前需要清零。
    if w.grad is not None:
        w.grad.data.zero_()
    if b.grad is not None:
        b.grad.data.zero_()

    loss.backward()      #反向传播
    w.data=w.data-learning_rate*w.grad
    b.data=b.data-learning_rate*b.grad
    print("w,b,loss",w.item(),b.item(),loss.item(),i)

plt.figure()
plt.scatter(x_data,y_data,20,'r')
y_predict=torch.matmul(x_data,w)+b
plt.plot(x_data,y_predict.detach().numpy())
plt.show()

在PyTorch中，.pow() 是一个张量（Tensor）方法，用于对张量中的元素进行幂运算。当你调用 .pow(n) 时，它会将张量中的每个元素都提升到 n 次幂。不过，在大多数情况下，特别是在计算损失函数如均方误差（MSE）时，n 通常是一个标量值，比如2。

在PyTorch中，.mean() 是一个张量（Tensor）方法，用于计算张量中所有元素的平均值，或者如果指定了维度（dimension），则计算该维度上元素的平均值。
y_true = torch.tensor([3.0, -0.5, 2.0, 7.0])
y_pred = torch.tensor([2.5, 0.0, 2.0, 8.0])
error = y_true - y_pred
mse_loss = error.pow(2).mean()
print(mse_loss)

三、封装类实现

import torch
import matplotlib.pyplot as plt

class LModel():
    def __init__(self,learning_rate):
        self.w=torch.tensor([[10]],requires_grad=True,dtype=torch.float32)
        self.b = torch.tensor([0], requires_grad=True, dtype=torch.float32)#self.w和self.b：分别初始化模型的权重和偏置。这里权重w初始化为[[10]]，偏置b初始化为[0]，都设置为需要梯度（requires_grad=True），以便进行反向传播。
        self.learning_rate=learning_rate   #设置学习率，用于梯度下降时的参数更新。
        self.loss=None   #用于存储每次前向传播计算的损失值。

    def forward(self,x,y):
        y_pred=torch.matmul(x,self.w)+self.b      #接收输入x和真实值y，计算预测值y_pred。
        self.loss=(y-y_pred).pow(2).mean()        #使用均方误差（MSE）作为损失函数，计算预测值和真实值之间的损失。
        return y_pred                            #返回预测值y_pred。


    def backward(self):
        if self.w.grad is not None:
            self.w.grad.data.zero_()
        if self.b.grad is not None:                  #如果权重w和偏置b的梯度已存在，则将其清零（避免梯度累加）。
            self.b.grad.data.zero_()
        self.loss.backward()        #调用self.loss.backward()计算损失函数对w和b的梯度。
        self.w.data=self.w.data-self.learning_rate*self.w.grad
        self.b.data = self.b.data - self.learning_rate * self.b.grad     #使用梯度下降更新权重w和偏置b的值。

        print("最终的：w,b,loss",self.w.item(),self.loss.item())

#准备数据
x_data=torch.tensor([[0.18],[0.1],[0.16],[0.08],[0.09],[0.11],[0.12],[0.17],[0.15],[0.14],[0.13]])
y_data=torch.tensor([[0.18],[0.1],[0.16],[0.08],[0.09],[0.11],[0.12],[0.17],[0.15],[0.14],[0.13]])

#训练模型
epoch=5000
model=LModel(learning_rate=0.5)    #实例化LModel类，并传入学习率0.5

for i in range(epoch):
    model.forward(x_data,y_data)
    model.backward()


plt.figure()
plt.scatter(x_data,y_data,20,"r")
y_predict=model.forward(x_data,y_data)
plt.plot(x_data,y_predict.detach().numpy())
plt.show()

四、继承类实现

1.torch.nn.Linear

torch.nn.Linear，这是一个非常重要的线性层（也称为全连接层或密集层），它执行的是线性变换，其数学表达式为 y = xA^T + b，其中 x 是输入数据，A 是层的权重矩阵（在 PyTorch 中由 weight 参数表示），b 是偏置项（在 PyTorch 中由 bias 参数表示），y 是输出。

torch.nn.Linear 层是神经网络中最基本的构建块之一，它通常用于从输入特征中提取线性关系。这个层在多层感知器（MLP）、循环神经网络（RNN）和卷积神经网络（CNN）中的全连接层等模型中都有广泛应用。

import torch
import torch.nn as nn

# 定义一个线性层，输入特征数为10，输出特征数为5
linear_layer = nn.Linear(in_features=10, out_features=5)

# 创建一个随机的输入张量，形状为 (batch_size, in_features)
# 这里我们假设 batch_size 为 3
input_tensor = torch.randn(3, 10)

# 通过线性层传递输入张量
output_tensor = linear_layer(input_tensor)

# 输出张量的形状为 (batch_size, out_features)
# 在这个例子中，形状应该是 (3, 5)
print(output_tensor.shape)

继承类实现代码

import torch
import matplotlib.pyplot as plt

class LinearModel(torch.nn.Module):         #LinearModel类继承自torch.nn.Module，这是构建所有神经网络模型的基类。
    def __init__(self):
        super(LinearModel,self).__init__()       #在__init__方法中，通过super()调用父类的构造函数进行初始化
        self.Linear=torch.nn.Linear(1,1) #self.Linear定义了一个线性层（全连接层），输入特征数和输出特征数均为1。

    #正向传播/前向传播
    def forward(self,x):
        y_pred=self.Linear(x)   #输入x通过线性层self.Linear（或self.linear，如果按建议修改）得到预测值y_pred。
        return y_pred
#数据准备
x_data=torch.tensor([[0.18],[0.1],[0.16],[0.08],[0.09],[0.11],[0.12],[0.17],[0.15],[0.14],[0.13]])
y_data=torch.tensor([[0.18],[0.1],[0.16],[0.08],[0.09],[0.11],[0.12],[0.17],[0.15],[0.14],[0.13]])

#初始化模型、损失函数和优化器
model=LinearModel()
criterion=torch.nn.MSELoss(size_average=False)#在PyTorch的新版本中，size_average参数已被弃用，应使用reduction='sum'或reduction='mean'。
# 但由于y_data和y_pred的形状相同且为(11, 1)，使用默认的reduction='mean'也是可行的，它会计算所有元素的平均损失。
optimizer=torch.optim.SGD(model.parameters(),lr=0.05)

for epoch in range(5000):
    y_pred=model(x_data)#在每次迭代中，通过模型得到预测值y_pred
    loss=criterion(y_pred,y_data)#计算损失函数
    optimizer.zero_grad()#清空梯度
    loss.backward()#反向传播计算梯度。
    optimizer.step()#更新模型参数。
    print(loss)

#打印线性层的权重和偏置项。
print('w=',model.Linear.weight.item())
print('b=',model.Linear.bias.item())   #item()方法用于从只包含一个元素的张量中提取其Python数值。

#测试模型
x_test=torch.tensor([[4.0]])
y_test=model(x_test)
print('y_pred=',y_test.data)

plt.figure()
plt.scatter(x_data,y_data,20,'r')
y_predict=model(x_data)
plt.plot(x_data,y_predict.detach().numpy())
plt.show()

关于类，对象，继承的内容后续会在python学习中完善。

标签：tensor,grad,self,torch,pytorch,深度,线性,梯度,data
From： https://blog.csdn.net/2301_79712009/article/details/143633320