三、Pytouch 线性回归

雨点打透心脏的1/2处 2023-05-29 03:43 47阅读 0赞

**目录**

1、线性回归

2、示例一

3、示例二

（1）自编写代码方式

（2）PyTorch内置函数实现线性回归

4、示例三

5、示例四

--------------------

## 1、线性回归 ##

1.  神经网络处理的主要两大类事物便是回归与分类。以一维线性回归问题为例讲解。
2.  给定数据集 D = \{(Xl , Yl) , (X2, Y2) , (X3 , Y3) ,… ,(Xm, Ym)\}
3.  线性回归希望能够优 化出一个好的函数 f(x) ， 使得 f(xi)=ωxi + b 能够与 Yi 尽可能接近。
4.  将f(x)比作神经网络，ω、 b为网络中需要训练的参数，而损失函数的作用即为衡量该神经网络输出f(xi)与yi的拟合度，并参照损失函数修改网络参数，使得结果更加趋近yi。

## 2、示例一 ##

# encoding: utf-8
    
    import torch
    import torch.nn as nn
    import numpy as np
    import matplotlib.pyplot as plt
    
    class Net(nn.Module):
        def __init__(self):
            super(Net,self).__init__()
            # 最简单神经网络，1个全连接层，输入为x（一维）输出为y(一维）
            self.linear = nn.Linear(1,1)
    
        def forward(self, x):  #前向传递
            out = self.linear(x)
            return out
    
    
    if __name__ == '__main__':
        """构建一维线性数据集"""
        # linspace(-1,1,100)是在（-1，1）范围内平均取100个点,
        # unquseeze(1)的作用是将 x 维度（100）变成（100,1）
        # 与神经网络输入维度保持一致（也可以用x = x.reshape(-1,1)达到相同目的）
        x = torch.linspace(-1, 1, 100).unsqueeze(1)
        # y = 2 * x + （一个范围在（0，1）的随机数）
        y = 2 * x + torch.rand(x.size())
        # 打印数据
        # x与y为tensor型，需转为numpy才能被画图包plt所用
        x1 = np.array(x)
        y1 = np.array(y)
        plt.scatter(x1, y1)  # 画（x,y）的散点图
        plt.show()
        """ 构建网络模型"""
        net = Net()
        """训练数据"""
        loss_fuc = nn.MSELoss()  # 损失函数
        # 学习效率为0.02的RMSprop优化器
        optimizer = torch.optim.RMSprop(net.parameters(), lr=0.02) 
        epochs = 1000  # 训练上述数据1000轮
        for epoch in range(epochs):
            # forward
            out = net(x)  # 输出预测值
            loss = loss_fuc(out, y)  # 预测值与真实值损失函数，参数位置不能颠倒
            # backward
            optimizer.zero_grad()  # 优化前使前一次梯度归0
            loss.backward()  # 损失函数反向传递
            optimizer.step()  # 执行优化
            # 输出训练中损失函数值
            if epoch % 20 == 0:
                print('epoch: {} | loss: {:.3f}'.format(epoch, loss.data))
        """输出训练好的网络的预测图线"""
        plt.scatter(x, y)
        out = net(x)
        print(out)
        plt.plot(x.data.numpy(), out.data.numpy())
        plt.show()

## 3、示例二 ##

先看一张表：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70][]

表格第一列是地区，第二类是温度单位华氏度，第二列是降水量单位毫米，第四列是湿度，第五列是苹果产量，第六列是橙子产量。

下面这段代码的目的是为了预估出苹果和橙子在不同地区、不同环境中的产量。

yield_apple = w11 * temp + w12 * rainfall + w13 * humidity + b1yield_orange 
                = w21 * temp + w22 * rainfall + w23 * humidity + b2

分别给温度temp、降水量rainfall、湿度humidity加上不同的权重（w11，w12，w13），最后再加一个b1或者b2的偏差。

通过使用被称为梯度下降的优化技术，少量多次调整权重以获得更精准的预测结果。

### （1）自编写代码方式 ###

# encoding: utf-8
    
    import torch
    import numpy as np
    
    def get_data():
        inputs = np.array([[73,67,43],
                           [91,88,64],
                           [87,134,58],
                           [102,43,37],
                           [69,96,70]],dtype='float32')
        targets = np.array([[56,70],
                            [81,101],
                            [119,133],
                            [22,37],
                            [103,119]],dtype='float32')
        return inputs,targets
    
    def model(x):
        # pytorch数学运算
        # https://www.cnblogs.com/taosiyu/p/11599157.html
        return  x @ w.t() + b
    
    def mse(t1,t2):
        """平方差矩阵"""
        diff = t1 - t2
        return torch.sum(diff * diff) / diff.numel()
    
    
    if __name__ == '__main__':
        inputs, targets = get_data()
        inputs = torch.from_numpy(inputs)
        targets = torch.from_numpy(targets)
        # 定义变量和截距(偏差)
        w = torch.randn(2, 3, requires_grad=True)
        b = torch.randn(2, requires_grad=True)
        print(w)
        print(b)
        #
        for i in range(100):
            preds = model(inputs)
            loss = mse(preds,targets)
            # 计算梯度
            loss.backward()
            print("w.grad = " ,w.grad)
            with torch.no_grad():
                w -= w.grad * (10** -5)
                b -= b.grad * (10**-5)
                # 重置梯度
                w.grad.zero_()
                b.grad.zero_()
    
        print("loss = ",loss)
        print("preds = ",preds)

### （2）PyTorch内置函数实现线性回归 ###

# encoding: utf-8
    
    import torch
    import numpy as np
    import torch.nn as nn
    from torch.utils.data import TensorDataset,DataLoader
    import torch.nn.functional as F
    def get_data():
        inputs = np.array([[73,67,43],
                           [91,88,64],
                           [87,134,58],
                           [102,43,37],
                           [69,96,70]],dtype='float32')
        targets = np.array([[56,70],
                            [81,101],
                            [119,133],
                            [22,37],
                            [103,119]],dtype='float32')
        return inputs,targets
    
    def fit(train_d1,num_epochs, model, loss_fn,opt):
        # 迭代num_epochs次
        for epoch in range(num_epochs):
            # 使用分批数据进行训练
            for xb,yb in train_d1:
                #训练模型
                pred = model(xb)
                # mse损失函数
                loss = loss_fn(pred,yb)
                # 计算梯度，反向传播
                loss.backward()
                # 使用梯度更新参数
                opt.step()
                # 重置梯度为 0
                opt.zero_grad()
            if(epoch+1) % 10 == 0:
                print('Epoch [{}/{}], Loss:{:0.4f}'.format(epoch+1,num_epochs,loss.item()))
    
    
    if __name__ == '__main__':
        inputs, targets = get_data()
        inputs = torch.from_numpy(inputs)
        targets = torch.from_numpy(targets)
        # 接下来我们创建一个TensorDataset和一个DataLoader：
        # 将特征和对应标签合并在一起
        train_ds = TensorDataset(inputs,targets)
        # print(train_ds[:3])
        batch_size = 5
        train_d1 = DataLoader(train_ds,batch_size,shuffle=True)
        # 定义一个三个输入维度两个输出维度的线性函数模型,
        # 使用nn.linear自动完成初始化工作。
        model = nn.Linear(3,2)
        # print(model.weight)
        # print(model.bias)
        # print(model.parameters())
        # 用内置损失函数mse_loss
        loss_fn = F.mse_loss
        # loss = loss_fn(model(inputs),targets)
        # 优化的时候，我们可以使用优化器optim.SGD，不用手动操作模型的权重和偏差。
        opt = torch.optim.SGD(model.parameters(), lr=10**-5)
        # 训练模型
        fit(train_d1,100,model,loss_fn,opt)
        preds = model(inputs)
        print(preds)

## 4、示例三 ##

一元回归模型

# encoding: utf-8
    
    """
    @author: sunxianpeng
    @file: 1_a_yuan_linear_demo.py
    @time: 2019/11/22 14:22
    """
    
    import torch
    import numpy as np
    from torch.autograd import Variable
    import matplotlib.pyplot as plt
    
    def getData():
        x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168],
                            [9.779], [6.182], [7.59], [2.167], [7.042],
                            [10.791], [5.313], [7.997], [3.1]], dtype=np.float32)
    
        y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573],
                            [3.366], [2.596], [2.53], [1.221], [2.827],
                            [3.465], [1.65], [2.904], [1.3]], dtype=np.float32)
        # 转换成 tensor
        x_train = torch.from_numpy(x_train)
        # 转换成 tensor
        y_train = torch.from_numpy(y_train)
        return x_train,y_train
    
    def plt_data(x, y, color='bo', label=None):
        plt.plot(x.data.numpy(),y.data.numpy(),color,label=label)
        plt.show()
    
    def plt_data2(x,y,pred):
        plt.plot(x.data.numpy(), pred.data.numpy(), 'bo', label='real')
        plt.plot(x.data.numpy(), y.data.numpy(), 'ro', label='estimated')
        plt.legend()
        plt.show()
    
    
    def linear_model(x,w,b):
        return x * w + b
    
    def getLoss(pred,y):
        return torch.mean((pred - y) ** 2)
    
    
    if __name__ == '__main__':
        epochs = 100
        learning_rate = 0.001
    
        torch.manual_seed(2019)
        x_train,y_train = getData()
        # plt_data(x_train,y_train)
    
        # 定义参数
        w = torch.randn(1,requires_grad=True)# 随机初始化
        b = torch.zeros(1,requires_grad=True)# 使用0进行初始化
        print("w = {}\nw.shape = {}\nb = {}\nb.shape = {}".format(w,w.shape,b,b.shape))
    
        for epoch in range(epochs):
            pred = linear_model(x_train,w,b)
            loss = getLoss(pred,y_train)
    
    
            loss.backward()
    
            w.data = w.data -  learning_rate * w.grad.data
            b.data = b.data - learning_rate * b.grad.data
            if epoch % 1 == 0:
                print('epoch = {},loss = {}'.format(epoch,loss.item()))
            w.grad.data.zero_()
            b.grad.data.zero_()
    
        pred = linear_model(x_train,w,b)
        plt_data2(x_train, y_train, pred)

## 5、示例四 ##

多元回归模型

# encoding: utf-8
    
    """
    @author: sunxianpeng
    @file: 1_a_yuan_linear_demo.py
    @time: 2019/11/22 14:22
    """
    
    import torch
    import numpy as np
    from torch.autograd import Variable
    import matplotlib.pyplot as plt
    
    def getData():
        # test_func()#测试多项式模型
        w_target = np.array([0.5, 3, 2.4])  #
        b_target = np.array([0.9])  #
        x_sample = np.arange(-3, 3.1, 0.1)
        y_sample = b_target[0] + w_target[0] * x_sample + w_target[1] * x_sample ** 2 + w_target[2] + x_sample ** 3
    
        x_train = np.stack([x_sample ** i for i in range(1,4)],axis=1)# n * 3
        y_train = torch.from_numpy(y_sample).double().unsqueeze(1)
        x_train = torch.from_numpy(x_train).float()
        return x_train,y_train,y_sample
    
    def test_func():
        w_target = np.array([0.5, 3, 2.4])  #
        b_target = np.array([0.9])  # ਧԎ݇හ
        f_des = 'y	=	{:.2f}	+	{:.2f}	*	x	+	{:.2f}	*	x^2	+	{:.2f}	*	x^3'.format(
            b_target[0], w_target[0], w_target[1], w_target[2])  # 打印函数公式
        print(f_des)
    
        x_sample = np.arange(-3, 3.1, 0.1)
        y_sample = b_target[0] + w_target[0] * x_sample + w_target[1] * x_sample ** 2 + w_target[2] + x_sample ** 3
        plt_data(x_sample, y_sample)
    
    def plt_data(x_train, y,pred):
        plt.plot(x_train.data.numpy()[:,0],pred.data.numpy(),label='fitting curve',color='r')
        plt.plot(x_train.data.numpy()[:,0],y,label='real curve',color='b')
        plt.legend()
        plt.show()
    
    def multi_linear(x,w,b):
        return torch.mm(x,w) + b
    
    def getLoss(pred,y):
        return torch.mean((pred - y) ** 2)
    
    if __name__ == '__main__':
        torch.manual_seed(2019)
        epochs = 100
        learning_rate = 0.001
    
        x_train,y_train,y_sample = getData()
    
        w = torch.randn(3,1,requires_grad=True).float()
        b = torch.zeros(1,requires_grad=True).float()
        print("w = {}\nw.shape = {}\nb = {}\nb.shape = {}".format(w,w.shape,b,b.shape))
    
        for epoch in  range(epochs):
            pred = multi_linear(x_train,w,b)
            loss = getLoss(pred,y_train)
    
    
            loss.backward()
    
            w.data = w.data - learning_rate * w.grad.data
            b.data = b.data - learning_rate * b.grad.data
            w.grad.data.zero_()
            b.grad.data.zero_()
            if epoch % 10 ==0:
                print("w = {}\nw.shape = {}\nb = {}\nb.shape = {}".format(w, w.shape, b, b.shape))
    
        pred = multi_linear(x_train,w,b)
        plt_data(x_train,y_sample,pred)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191104011242479.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3MyOTQ4NzgzMDQ=,size_16,color_FFFFFF,t_70