python神经网络分类_Pytorch实现神经网络的分类方式

本文用于利用Pytorch实现神经网络的分类！！！

1.训练神经网络分类模型

import torch

from torch.autograd import Variable

import matplotlib.pyplot as plt

import torch.nn.functional as F

import torch.utils.data as Data

torch.manual_seed(1)#设置随机种子，使得每次生成的随机数是确定的

BATCH_SIZE = 5#设置batch size

#1.制作两类数据

n_data = torch.ones( 1000,2 )

x0 = torch.normal( 1.5*n_data, 1 )#均值为2 标准差为1

y0 = torch.zeros( 1000 )

x1 = torch.normal( -1.5*n_data,1 )#均值为-2 标准差为1

y1 = torch.ones( 1000 )

print("数据集维度：",x0.size(),y0.size())

#合并训练数据集,并转化数据类型为浮点型或整型

x = torch.cat( (x0,x1),0 ).type( torch.FloatTensor )

y = torch.cat( (y0,y1) ).type( torch.LongTensor )

print( "合并后的数据集维度：",x.data.size(), y.data.size() )

#当不使用batch size训练数据时，将Tensor放入Variable中

# x,y = Variable(x), Variable(y)

#绘制训练数据

# plt.scatter( x.data.numpy()[:,0], x.data.numpy()[:,1], c=y.data.numpy())

# plt.show()

#当使用batch size训练数据时，首先将tensor转化为Dataset格式

torch_dataset = Data.TensorDataset(x, y)

#将dataset放入DataLoader中

loader = Data.DataLoader(

dataset=torch_dataset,

batch_size = BATCH_SIZE,#设置batch size

shuffle=True,#打乱数据

num_workers=2#多线程读取数据

)

#2.前向传播过程

class Net(torch.nn.Module):#继承基类Module的属性和方法

def __init__(self, input, hidden, output):

super(Net, self).__init__()#继承__init__功能

self.hidden = torch.nn.Linear(input, hidden)#隐层的线性输出

self.out = torch.nn.Linear(hidden, output)#输出层线性输出

def forward(self, x):

x = F.relu(self.hidden(x))

x = self.out(x)

return x

# 训练模型的同时保存网络模型参数

def save():

#3.利用自定义的前向传播过程设计网络，设置各层神经元数量

# net = Net(input=2, hidden=10, output=2)

# print("神经网络结构：",net)

#3.快速搭建神经网络模型

net = torch.nn.Sequential(

torch.nn.Linear(2,10),#指定输入层和隐层结点，获得隐层线性输出

torch.nn.ReLU(),#隐层非线性化

torch.nn.Linear(10,2)#指定隐层和输出层结点，获得输出层线性输出

)

#4.设置优化算法、学习率

# optimizer = torch.optim.SGD( net.parameters(), lr=0.2 )

# optimizer = torch.optim.SGD( net.parameters(), lr=0.2, momentum=0.8 )

# optimizer = torch.optim.RMSprop( net.parameters(), lr=0.2, alpha=0.9 )

optimizer = torch.optim.Adam( net.parameters(), lr=0.2, betas=(0.9,0.99) )

#5.设置损失函数

loss_func = torch.nn.CrossEntropyLoss()

plt.ion()#打开画布，可视化更新过程

#6.迭代训练

for epoch in range(2):

for step, (batch_x, batch_y) in enumerate(loader):

out = net(batch_x)#输入训练集，获得当前迭代输出值

loss = loss_func(out, batch_y)#获得当前迭代的损失

optimizer.zero_grad()#清除上次迭代的更新梯度

loss.backward()#反向传播

optimizer.step()#更新权重

if step%200==0:

plt.cla()#清空之前画布上的内容

entire_out = net(x)#测试整个训练集

#获得当前softmax层最大概率对应的索引值

pred = torch.max(F.softmax(entire_out), 1)[1]

#将二维压缩为一维

pred_y = pred.data.numpy().squeeze()

label_y = y.data.numpy()

plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=pred_y, cmap='RdYlGn')

accuracy = sum(pred_y == label_y)/y.size()

print("第 %d 个epoch，第 %d 次迭代，准确率为 %.2f"%(epoch+1, step/200+1, accuracy))

#在指定位置添加文本

plt.text(1.5, -4, 'Accuracy=%.2f' % accuracy, fontdict={'size': 15, 'color': 'red'})

plt.pause(2)#图像显示时间

#7.保存模型结构和参数

torch.save(net, 'net.pkl')

#7.只保存模型参数

# torch.save(net.state_dict(), 'net_param.pkl')

plt.ioff()#关闭画布

plt.show()

if __name__ == '__main__':

save()

2. 读取已训练好的模型测试数据

import torch

from torch.autograd import Variable

import matplotlib.pyplot as plt

import torch.nn.functional as F

#制作数据

n_data = torch.ones( 100,2 )

x0 = torch.normal( 1.5*n_data, 1 )#均值为2 标准差为1

y0 = torch.zeros( 100 )

x1 = torch.normal( -1.5*n_data,1 )#均值为-2 标准差为1

y1 = torch.ones( 100 )

print("数据集维度：",x0.size(),y0.size())

#合并训练数据集,并转化数据类型为浮点型或整型

x = torch.cat( (x0,x1),0 ).type( torch.FloatTensor )

y = torch.cat( (y0,y1) ).type( torch.LongTensor )

print( "合并后的数据集维度：",x.data.size(), y.data.size() )

#将Tensor放入Variable中

x,y = Variable(x), Variable(y)

#载入模型和参数

def restore_net():

net = torch.load('net.pkl')

#获得载入模型的预测输出

pred = net(x)

# 获得当前softmax层最大概率对应的索引值

pred = torch.max(F.softmax(pred), 1)[1]

# 将二维压缩为一维

pred_y = pred.data.numpy().squeeze()

label_y = y.data.numpy()

accuracy = sum(pred_y == label_y) / y.size()

print("准确率为：",accuracy)

plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=pred_y, cmap='RdYlGn')

plt.show()

#仅载入模型参数,需要先创建网络模型

def restore_param():

net = torch.nn.Sequential(

torch.nn.Linear(2,10),#指定输入层和隐层结点，获得隐层线性输出

torch.nn.ReLU(),#隐层非线性化

torch.nn.Linear(10,2)#指定隐层和输出层结点，获得输出层线性输出

)

net.load_state_dict( torch.load('net_param.pkl') )

#获得载入模型的预测输出

pred = net(x)

# 获得当前softmax层最大概率对应的索引值

pred = torch.max(F.softmax(pred), 1)[1]

# 将二维压缩为一维

pred_y = pred.data.numpy().squeeze()

label_y = y.data.numpy()

accuracy = sum(pred_y == label_y) / y.size()

print("准确率为：",accuracy)

plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=pred_y, cmap='RdYlGn')

plt.show()

if __name__ =='__main__':

# restore_net()

restore_param()

以上这篇Pytorch实现神经网络的分类方式就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。