pytorch实现回归和分类

ゞ浴缸里的玫瑰 2023-05-28 03:51 16阅读 0赞

# pytorch实现回归和分类 #

### pytorch实现回归和分类 ###

*  pytorch实现回归和分类
 *   *  1.构建数据
     *   *  （1）回归数据
         *  （2）分类数据
     *  2.设置模型
     *  3.设置超参数和训练
     *   *  （1）回归
         *  （2）分类

在pytorch进行回归和分类时，中间模型设定部分和训练部分变化不大，主要变化的是输入输出数据的维度以及在进行loss计算时的损失函数。

首先导入必要的包

import torch
    import torch.nn as nn
    import matplotlib.pyplot as plt

## 1.构建数据 ##

### （1）回归数据 ###

# 随机创建一些训练数据
    x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)  # x 的shape=(100, 1)
    y = x.pow(2) + 0.2*torch.rand(x.size())  # y=x的平方（其中加入随机扰动项，即一些噪声）
    plt.scatter(x.data.numpy(), y.data.numpy())
    plt.show()
    d_in,h,d_out=1,10,1

初始数据的图像![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY5ODM4OQ_size_16_color_FFFFFF_t_70]

### （2）分类数据 ###

# 假数据（此时进行2分类）
    n_data = torch.ones(100, 2)         # 数据的基本形态 (100,2)
    x0 = torch.normal(2*n_data, 1)      # 设置均值为2的数据
    y0 = torch.zeros(100)               # 设置类型
    x1 = torch.normal(-2*n_data, 1)    # 设置均值为-2的数据
    y1 = torch.ones(100)               # 设置类型
    # 用torch.cat 合并数据，合并数据需要按照以下格式
    x = torch.cat((x0, x1),).type(torch.FloatTensor)   # x按照dim=0合并，竖直合并（默认为dim=0）
    y = torch.cat((y0, y1), ).type(torch.LongTensor)
    plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c="red", s=100, lw=0, cmap='RdYlGn')
    plt.show()
    d_in,h,d_out=2,10,2

初始数据的图像  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY5ODM4OQ_size_16_color_FFFFFF_t_70 1]

## 2.设置模型 ##

此处回归和分类的模型设置差不多，可以用相同的函数。

# 设置模型
    class Net(nn.Module):
        def __init__(self,d_in,h,d_out):
            super(Net,self).__init__()
            self.Linear1=nn.Linear(d_in,h)
            self.Relu=nn.ReLU()
            self.Linear2=nn.Linear(h,d_out)
        def forward(self,x):
            x=self.Relu(self.Linear1(x))
            y_pre=self.Linear2(x)
            return (y_pre)
    model=Net(d_in,h,d_out)

## 3.设置超参数和训练 ##

### （1）回归 ###

# 设置超参数
    lr=0.2
    optimizer=torch.optim.SGD(model.parameters(),lr=lr)
    loss_function=nn.MSELoss()
    
    # 进行训练
    for t in range(300):
        y_predict=model(x)
        loss=loss_function(y_predict,y)
        print(t,loss.item())
        optimizer.zero_grad()
        plt.ion()  # 画图
        plt.show()
        loss.backward()
        optimizer.step()
        if t % 5 == 0:
            # plot and show learning process
            plt.cla()
            plt.scatter(x.data.numpy(), y.data.numpy())
            plt.plot(x.data.numpy(), y_predict.data.numpy(), 'r-', lw=5)
            plt.text(0.5, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 20, 'color':  'red'})
            plt.pause(0.1)

结果图像：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY5ODM4OQ_size_16_color_FFFFFF_t_70 2]

### （2）分类 ###

# 设置超参数
    lr=0.02
    optimizer=torch.optim.SGD(model.parameters(),lr=lr)
    # 此时不为一维数据，为计算交叉熵损失
    loss_function=nn.CrossEntropyLoss()
    
    # 进行训练
    for t in range(100):
        correct=0.
        y_predict=model(x)
        loss=loss_function(y_predict,y)
        print(t,loss.item())
        optimizer.zero_grad()
        plt.ion()  # 画图
        plt.show()
        loss.backward()
        optimizer.step()
        if t % 2 == 0:
            plt.cla()
            # 过了一道 softmax 的激励函数后的最大概率才是预测值
            pred = y_predict.argmax(dim=1)  # batch_size*1
            correct += pred.eq(y.view_as(pred)).sum().item()
            target_y = y.data.numpy()
            plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=pred, s=100, lw=0, cmap='RdYlGn')
            accuracy = correct / 200.  # 预测中有多少和真实值一样
            plt.text(1.5, -4, 'Accuracy=%.2f' % accuracy, fontdict={'size': 20, 'color': 'red'})
            plt.pause(0.1)

结果图像：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY5ODM4OQ_size_16_color_FFFFFF_t_70 3]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY5ODM4OQ_size_16_color_FFFFFF_t_70]: /images/20230528/060fded3e8f649979a55bc9224f7156a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY5ODM4OQ_size_16_color_FFFFFF_t_70 1]: /images/20230528/b5b88728bea446c586a925fd9ef9aae4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY5ODM4OQ_size_16_color_FFFFFF_t_70 2]: /images/20230528/5d3ac27578d6406683ad4e7a222014bf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY5ODM4OQ_size_16_color_FFFFFF_t_70 3]: /images/20230528/095f5d65bacb4786b8508a19fb91295f.png