pytorch深度学习入门（17）之-实现演示神经网络分类过程代码

最新推荐文章于 2024-05-21 08:26:54 发布

码农呆呆

最新推荐文章于 2024-05-21 08:26:54 发布

阅读量536

点赞数 15

分类专栏：深度学习文章标签：深度学习 pytorch 神经网络人工智能 python

本文链接：https://blog.csdn.net/ajunbin859/article/details/134708727

版权

深度学习专栏收录该内容

17 篇文章 5 订阅

订阅专栏

概述

笔者使用pytorch框架构建神经网络，使用matplotlib显示网络分类过程，生动的演示了网络拟合过程

先看效果图：
在这里插入图片描述

最终训练300次后拟合效果：

在这里插入图片描述

代码流程

1.环境导入

import matplotlib.pyplot as plt
import numpy as np
import os
import torch
os.environ['KMP_DUPLICATE_LIB_OK']='True'	#设置环境变量，避免出现库错误的问题

2.生成数据

batch_size = 20
data_len = 2
max = 80    #数据最大值为80
x1 = np.random.randint(0,max,(batch_size,data_len)) / max   #随机生成0~80的数据，并且除以最大值，进行归一化
y1 = np.ones((batch_size,1))								#标签值为1
data1 = np.concatenate((x1,y1),axis=1)                      #合并数据，将标签与数据合并一起，方面后面随机打乱

x2 = np.random.randint(0,max,(batch_size,data_len)) / max   #随机生成0~80的数据，并且除以最大值，进行归一化
y2 = np.zeros((batch_size,1))								#标签值为0
data2 = np.concatenate((x2,y2),axis=1)                      #合并数据，将标签与数据合并一起，方面后面随机打乱

data = np.concatenate((data1,data2))
np.random.shuffle(data)                                     #将数据打乱

xb = data[:,0:data_len]
xb = torch.tensor(xb,dtype=torch.float)

yb = data[:,data_len:data_len+1]
yb = torch.tensor(yb,dtype=torch.long).reshape(batch_size * 2)  #将标签值转成pytorch张量

"""生成测试数据，即生成（80 * 80）的数据，包含所有的数据组合"""
test_data = np.array([0,0]).reshape(1,2)
for x in range(max):
    for y in range(max):        
            xy = np.array([x,y]).reshape(1,2)
            test_data = np.append(test_data,xy,axis=0)              #合并数据，不使用concatenate，加快速度

test_data = test_data / max
test_data = torch.tensor(test_data,dtype=torch.float)

print(data1)
print(data2)

3.构建网络

定义网络：
因为是二维平面的演示，因此数据维度是2，数据分别对应x坐标，y坐标
因此网络输入维度为（batch_size,2）

class LinearModel(torch.nn.Module):
    def __init__(self):
        super(LinearModel, self).__init__()
        self.nInput = 2
 
        self.fc = torch.nn.Sequential(
            torch.nn.Linear(self.nInput, 50),
            torch.nn.ReLU(inplace=True),
            torch.nn.Linear(50, 50),
            torch.nn.ReLU(inplace=True),
            torch.nn.Linear(50, 2)
        )
 
    def forward(self, x):
        x = x.view(x.size(0), -1)   # 在进入全连接层之前需要把数据拉直Flatten
        x = self.fc(x)
        return x

定义网络：


model = LinearModel()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(),lr=0.01)
model.train(mode=True)

4.显示拟合过程

训练过程中，使用matplotlib显示拟合过程

plt.ion()											#启动交互模式
for epochs in range(400):
    optimizer.zero_grad()                           #梯度清除
    outputs = model(xb)                             #训练
    loss = criterion(outputs, yb)                   #求损失
    loss.backward()                                      #求导
    optimizer.step()                                #反向传播，参数更新


    # correct = 0
    # total = 0
    # model.eval()
    # with torch.no_grad():                                   # 下面的代码就不会再计算梯度
    #     outputs = model(xb)
    #     loss = criterion(outputs, yb)                   #求损失
    #     _, predicted = torch.max(outputs.data, dim=1)   # _为每一行的最大值，predicted表示每一行最大值的下标
    #     total += yb.size(0)
    #     correct += (predicted == yb).sum().item()
    #         # if(100 * correct / total == 100):
    #         #     print('--Accuracy on test set:%0.2f %%，loss=%f' % (100 * correct / total,loss))
    # acc = (100 * correct / total)

    # print('epoch=%d, total=%d, correct=%d, last loss=%f, Accuracy:%0.2f %%' % (epochs,total,correct,loss,acc))

    print("epoch:",epochs,"loss",loss.item())
    outputs = model(test_data)
    _, predicted = torch.max(outputs.data, dim=1)   # _为每一行的最大值，predicted表示每一行最大值的下标

    plt.cla()										#清除显示，避免数据累加，每次画越来越多的数据，加快速度

    boolIndex = (predicted == 1)					#创建bool索引，方便提取出标签值为1的对应数据
    plt.scatter(test_data[boolIndex][:,0],test_data[boolIndex][:,1],color='red')

    boolIndex = (predicted == 0)
    plt.scatter(test_data[boolIndex][:,0],test_data[boolIndex][:,1],color='blue')

    plt.scatter(x1[:,0],x1[:,1],color = 'black')
    plt.scatter(x2[:,0],x2[:,1],color = 'yellow')

    plt.pause(0.001)

plt.pause(0.001)
plt.ioff()
plt.show()#显示最后拟合结果
plt.close()

最终效果图

在这里插入图片描述
附上完整代码，可以拷贝直接运行

import matplotlib.pyplot as plt
import numpy as np
import os
import torch

os.environ['KMP_DUPLICATE_LIB_OK']='True'

class LinearModel(torch.nn.Module):
    def __init__(self):#输入图片的宽高
        super(LinearModel, self).__init__()
        self.nInput = 2
 
        self.fc = torch.nn.Sequential(
            torch.nn.Linear(self.nInput, 50),
            torch.nn.ReLU(inplace=True),
            torch.nn.Linear(50, 50),
            torch.nn.ReLU(inplace=True),
            torch.nn.Linear(50, 2)
        )
 
    def forward(self, x):
        x = x.view(x.size(0), -1)   # 在进入全连接层之前需要把数据拉直Flatten
        x = self.fc(x)
        return x

batch_size = 20
data_len = 2
max = 80    #数据最大值为80
x1 = np.random.randint(0,max,(batch_size,data_len)) / max   #随机生成0~80的数据，并且除以最大值，进行归一化
y1 = np.ones((batch_size,1))
data1 = np.concatenate((x1,y1),axis=1)                      #合并数据，将标签与数据合并一起，方面后面随机打乱

x2 = np.random.randint(0,max,(batch_size,data_len)) / max   #随机生成0~80的数据，并且除以最大值，进行归一化
y2 = np.zeros((batch_size,1))
data2 = np.concatenate((x2,y2),axis=1)                      #合并数据，将标签与数据合并一起，方面后面随机打乱

data = np.concatenate((data1,data2))
np.random.shuffle(data)                                     #将数据打乱

xb = data[:,0:data_len]
xb = torch.tensor(xb,dtype=torch.float)

yb = data[:,data_len:data_len+1]
yb = torch.tensor(yb,dtype=torch.long).reshape(batch_size * 2)  #将标签值转成pytorch张量

"""生成测试数据，即生成（80 * 80）的数据，包含所有的数据组合"""
test_data = np.array([0,0]).reshape(1,2)
for x in range(max):
    for y in range(max):        
            xy = np.array([x,y]).reshape(1,2)
            test_data = np.append(test_data,xy,axis=0)              #合并数据，不使用concatenate，加快速度

test_data = test_data / max
test_data = torch.tensor(test_data,dtype=torch.float)

print(data1)
print(data2)

plt.ion()

model = LinearModel()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(),lr=0.01)
model.train(mode=True)

for epochs in range(400):
    optimizer.zero_grad()                           #梯度清除
    outputs = model(xb)                             #训练
    loss = criterion(outputs, yb)                   #求损失
    loss.backward()                                      #求导
    optimizer.step()                                #反向传播，参数更新


    # correct = 0
    # total = 0
    # model.eval()
    # with torch.no_grad():                                   # 下面的代码就不会再计算梯度
    #     outputs = model(xb)
    #     loss = criterion(outputs, yb)                   #求损失
    #     _, predicted = torch.max(outputs.data, dim=1)   # _为每一行的最大值，predicted表示每一行最大值的下标
    #     total += yb.size(0)
    #     correct += (predicted == yb).sum().item()
    #         # if(100 * correct / total == 100):
    #         #     print('--Accuracy on test set:%0.2f %%，loss=%f' % (100 * correct / total,loss))
    # acc = (100 * correct / total)

    # print('epoch=%d, total=%d, correct=%d, last loss=%f, Accuracy:%0.2f %%' % (epochs,total,correct,loss,acc))

    print("epoch:",epochs,"loss",loss.item())
    outputs = model(test_data)
    _, predicted = torch.max(outputs.data, dim=1)   # _为每一行的最大值，predicted表示每一行最大值的下标

    plt.cla()

    boolIndex = (predicted == 1)
    plt.scatter(test_data[boolIndex][:,0],test_data[boolIndex][:,1],color='red')

    boolIndex = (predicted == 0)
    plt.scatter(test_data[boolIndex][:,0],test_data[boolIndex][:,1],color='blue')

    plt.scatter(x1[:,0],x1[:,1],color = 'black')
    plt.scatter(x2[:,0],x2[:,1],color = 'yellow')

    plt.pause(0.001)

plt.pause(0.0001)
plt.ioff()
plt.show()
plt.close()

喜欢点个关注吧！

码农呆呆

关注

15
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
0
评论
pytorch深度学习入门（17）之-实现演示神经网络分类过程代码

笔者使用pytorch框架构建神经网络，使用matplotlib显示网络分类过程，生动的演示了网络拟合过程先看效果图：最终训练300次后拟合效果：2.生成数据3.构建网络定义网络：因为是二维平面的演示，因此数据维度是2，数据分别对应x坐标，y坐标因此网络输入维度为（batch_size,2）定义网络：4.显示拟合过程训练过程中，使用matplotlib显示拟合过程最终效果图附上完整代码，可以拷贝直接运行喜欢点个关注吧！
复制链接

扫一扫