本文介绍了pytorch上搭建简单神经网络实现回归和分类的示例,分享给大家,具体如下:
一、pytorch入门
1. 安装方法
登录pytorch官网,http://pytorch.org,可以看到以下界面:
按上图的选项选择后即可得到linux下conda指令:
1
|
conda install pytorch torchvision - c soumith
|
目前pytorch仅支持macos和linux,暂不支持windows。安装 pytorch 会安装两个模块,一个是torch,一个 torchvision, torch 是主模块,用来搭建神经网络的,torchvision 是辅模块,有数据库,还有一些已经训练好的神经网络等着你直接用,比如 (vgg, alexnet, resnet)。
2. numpy与torch
torch_data = torch.from_numpy(np_data)可以将numpy(array)格式转换为torch(tensor)格式;torch_data.numpy()又可以将torch的tensor格式转换为numpy的array格式。注意torch的tensor和numpy的array会共享他们的存储空间,修改一个会导致另外的一个也被修改。
对于1维(1-d)的数据,numpy是以行向量的形式打印输出,而torch是以列向量的形式打印输出的。
其他例如sin, cos, abs,mean等numpy中的函数在torch中用法相同。需要注意的是,numpy中np.matmul(data, data)和data.dot(data)矩阵相乘会得到相同结果;torch中torch.mm(tensor, tensor)是矩阵相乘的方法,得到一个矩阵,tensor.dot(tensor)会把tensor转换为1维的tensor,然后逐元素相乘后求和,得到与一个实数。
相关代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
import torch
import numpy as np
np_data = np.arange( 6 ).reshape(( 2 , 3 ))
torch_data = torch.from_numpy(np_data) # 将numpy(array)格式转换为torch(tensor)格式
tensor2array = torch_data.numpy()
print (
'\nnumpy array:\n' , np_data,
'\ntorch tensor:' , torch_data,
'\ntensor to array:\n' , tensor2array,
) # torch数据格式在print的时候前后自动添加换行符
# abs
data = [ - 1 , - 2 , 2 , 2 ]
tensor = torch.floattensor(data)
print (
'\nabs' ,
'\nnumpy: \n' , np. abs (data),
'\ntorch: ' , torch. abs (tensor)
) # 1维的数据,numpy是行向量形式显示,torch是列向量形式显示
# sin
print (
'\nsin' ,
'\nnumpy: \n' , np.sin(data),
'\ntorch: ' , torch.sin(tensor)
)
# mean
print (
'\nmean' ,
'\nnumpy: ' , np.mean(data),
'\ntorch: ' , torch.mean(tensor)
)
# 矩阵相乘
data = [[ 1 , 2 ], [ 3 , 4 ]]
tensor = torch.floattensor(data)
print (
'\nmatrix multiplication (matmul)' ,
'\nnumpy: \n' , np.matmul(data, data),
'\ntorch: ' , torch.mm(tensor, tensor)
)
data = np.array(data)
print (
'\nmatrix multiplication (dot)' ,
'\nnumpy: \n' , data.dot(data),
'\ntorch: ' , tensor.dot(tensor)
)
|
3. variable
pytorch中的神经网络来自于autograd包,autograd包提供了tensor所有操作的自动求导方法。
autograd.variable这是这个包中最核心的类。可以将variable理解为一个装有tensor的容器,它包装了一个tensor,并且几乎支持所有的定义在其上的操作。一旦完成运算,便可以调用 .backward()来自动计算出所有的梯度。也就是说只有把tensor置于variable中,才能在神经网络中实现反向传递、自动求导等运算。
可以通过属性 .data 来访问原始的tensor,而关于这一variable的梯度则可通过 .grad属性查看。
相关代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
import torch
from torch.autograd import variable
tensor = torch.floattensor([[ 1 , 2 ],[ 3 , 4 ]])
variable = variable(tensor, requires_grad = true)
# 打印展示variable类型
print (tensor)
print (variable)
t_out = torch.mean(tensor * tensor) # 每个元素的^ 2
v_out = torch.mean(variable * variable)
print (t_out)
print (v_out)
v_out.backward() # variable的误差反向传递
# 比较variable的原型和grad属性、data属性及相应的numpy形式
print ( 'variable:\n' , variable)
# v_out = 1/4 * sum(variable*variable) 这是计算图中的 v_out 计算步骤
# 针对于 v_out 的梯度就是, d(v_out)/d(variable) = 1/4*2*variable = variable/2
print ( 'variable.grad:\n' , variable.grad) # variable的梯度
print ( 'variable.data:\n' , variable.data) # variable的数据
print (variable.data.numpy()) #variable的数据的numpy形式
|
部分输出结果:
variable:
variable containing:
1 2
3 4
[torch.floattensor of size 2x2]
variable.grad:
variable containing:
0.5000 1.0000
1.5000 2.0000
[torch.floattensor of size 2x2]
variable.data:
1 2
3 4
[torch.floattensor of size 2x2]
[[ 1. 2.]
[ 3. 4.]]
4. 激励函数activationfunction
torch的激励函数都在torch.nn.functional中,relu,sigmoid, tanh, softplus都是常用的激励函数。
相关代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
import torch
import torch.nn.functional as f
from torch.autograd import variable
import matplotlib.pyplot as plt
x = torch.linspace( - 5 , 5 , 200 )
x_variable = variable(x) #将x放入variable
x_np = x_variable.data.numpy()
# 经过4种不同的激励函数得到的numpy形式的数据结果
y_relu = f.relu(x_variable).data.numpy()
y_sigmoid = f.sigmoid(x_variable).data.numpy()
y_tanh = f.tanh(x_variable).data.numpy()
y_softplus = f.softplus(x_variable).data.numpy()
plt.figure( 1 , figsize = ( 8 , 6 ))
plt.subplot( 221 )
plt.plot(x_np, y_relu, c = 'red' , label = 'relu' )
plt.ylim(( - 1 , 5 ))
plt.legend(loc = 'best' )
plt.subplot( 222 )
plt.plot(x_np, y_sigmoid, c = 'red' , label = 'sigmoid' )
plt.ylim(( - 0.2 , 1.2 ))
plt.legend(loc = 'best' )
plt.subplot( 223 )
plt.plot(x_np, y_tanh, c = 'red' , label = 'tanh' )
plt.ylim(( - 1.2 , 1.2 ))
plt.legend(loc = 'best' )
plt.subplot( 224 )
plt.plot(x_np, y_softplus, c = 'red' , label = 'softplus' )
plt.ylim(( - 0.2 , 6 ))
plt.legend(loc = 'best' )
plt.show()
|
二、pytorch实现回归
先看完整代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
import torch
from torch.autograd import variable
import torch.nn.functional as f
import matplotlib.pyplot as plt
x = torch.unsqueeze(torch.linspace( - 1 , 1 , 100 ), dim = 1 ) # 将1维的数据转换为2维数据
y = x. pow ( 2 ) + 0.2 * torch.rand(x.size())
# 将tensor置入variable中
x, y = variable(x), variable(y)
#plt.scatter(x.data.numpy(), y.data.numpy())
#plt.show()
# 定义一个构建神经网络的类
class net(torch.nn.module): # 继承torch.nn.module类
def __init__( self , n_feature, n_hidden, n_output):
super (net, self ).__init__() # 获得net类的超类(父类)的构造方法
# 定义神经网络的每层结构形式
# 各个层的信息都是net类对象的属性
self .hidden = torch.nn.linear(n_feature, n_hidden) # 隐藏层线性输出
self .predict = torch.nn.linear(n_hidden, n_output) # 输出层线性输出
# 将各层的神经元搭建成完整的神经网络的前向通路
def forward( self , x):
x = f.relu( self .hidden(x)) # 对隐藏层的输出进行relu激活
x = self .predict(x)
return x
# 定义神经网络
net = net( 1 , 10 , 1 )
print (net) # 打印输出net的结构
# 定义优化器和损失函数
optimizer = torch.optim.sgd(net.parameters(), lr = 0.5 ) # 传入网络参数和学习率
loss_function = torch.nn.mseloss() # 最小均方误差
# 神经网络训练过程
plt.ion() # 动态学习过程展示
plt.show()
for t in range ( 300 ):
prediction = net(x) # 把数据x喂给net,输出预测值
loss = loss_function(prediction, y) # 计算两者的误差,要注意两个参数的顺序
optimizer.zero_grad() # 清空上一步的更新参数值
loss.backward() # 误差反相传播,计算新的更新参数值
optimizer.step() # 将计算得到的更新值赋给net.parameters()
# 可视化训练过程
if (t + 1 ) % 10 = = 0 :
plt.cla()
plt.scatter(x.data.numpy(), y.data.numpy())
plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-' , lw = 5 )
plt.text( 0.5 , 0 , 'l=%.4f' % loss.data[ 0 ], fontdict = { 'size' : 20 , 'color' : 'red' })
plt.pause( 0.1 )
|
首先创建一组带噪声的二次函数拟合数据,置于variable中。定义一个构建神经网络的类net,继承torch.nn.module类。net类的构造方法中定义输入神经元、隐藏层神经元、输出神经元数量的参数,通过super()方法获得net父类的构造方法,以属性的方式定义net的各个层的结构形式;定义net的forward()方法将各层的神经元搭建成完整的神经网络前向通路。
定义好net类后,定义神经网络实例,net类实例可以直接print打印输出神经网络的结构信息。接着定义神经网络的优化器和损失函数。定义好这些后就可以进行训练了。optimizer.zero_grad()、loss.backward()、optimizer.step()分别是清空上一步的更新参数值、进行误差的反向传播并计算新的更新参数值、将计算得到的更新值赋给net.parameters()。循环迭代训练过程。
运行结果:
net (
(hidden): linear (1 -> 10)
(predict): linear (10 -> 1)
)
三、pytorch实现简单分类
完整代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
import torch
from torch.autograd import variable
import torch.nn.functional as f
import matplotlib.pyplot as plt
# 生成数据
# 分别生成2组各100个数据点,增加正态噪声,后标记以y0=0 y1=1两类标签,最后cat连接到一起
n_data = torch.ones( 100 , 2 )
# torch.normal(means, std=1.0, out=none)
x0 = torch.normal( 2 * n_data, 1 ) # 以tensor的形式给出输出tensor各元素的均值,共享标准差
y0 = torch.zeros( 100 )
x1 = torch.normal( - 2 * n_data, 1 )
y1 = torch.ones( 100 )
x = torch.cat((x0, x1), 0 ). type (torch.floattensor) # 组装(连接)
y = torch.cat((y0, y1), 0 ). type (torch.longtensor)
# 置入variable中
x, y = variable(x), variable(y)
class net(torch.nn.module):
def __init__( self , n_feature, n_hidden, n_output):
super (net, self ).__init__()
self .hidden = torch.nn.linear(n_feature, n_hidden)
self .out = torch.nn.linear(n_hidden, n_output)
def forward( self , x):
x = f.relu( self .hidden(x))
x = self .out(x)
return x
net = net(n_feature = 2 , n_hidden = 10 , n_output = 2 )
print (net)
optimizer = torch.optim.sgd(net.parameters(), lr = 0.012 )
loss_func = torch.nn.crossentropyloss()
plt.ion()
plt.show()
for t in range ( 100 ):
out = net(x)
loss = loss_func(out, y) # loss是定义为神经网络的输出与样本标签y的差别,故取softmax前的值
optimizer.zero_grad()
loss.backward()
optimizer.step()
if t % 2 = = 0 :
plt.cla()
# 过了一道 softmax 的激励函数后的最大概率才是预测值
# torch.max既返回某个维度上的最大值,同时返回该最大值的索引值
prediction = torch. max (f.softmax(out), 1 )[ 1 ] # 在第1维度取最大值并返回索引值
pred_y = prediction.data.numpy().squeeze()
target_y = y.data.numpy()
plt.scatter(x.data.numpy()[:, 0 ], x.data.numpy()[:, 1 ], c = pred_y, s = 100 , lw = 0 , cmap = 'rdylgn' )
accuracy = sum (pred_y = = target_y) / 200 # 预测中有多少和真实值一样
plt.text( 1.5 , - 4 , 'accu=%.2f' % accuracy, fontdict = { 'size' : 20 , 'color' : 'red' })
plt.pause( 0.1 )
plt.ioff()
plt.show()
|
神经网络结构部分的net类与前文的回归部分的结构相同。
需要注意的是,在循环迭代训练部分,out定义为神经网络的输出结果,计算误差loss时不是使用one-hot形式的,loss是定义在out与y上的torch.nn.crossentropyloss(),而预测值prediction定义为out经过softmax后(将结果转化为概率值)的结果。
运行结果:
net (
(hidden): linear (2 -> 10)
(out):linear (10 -> 2)
)
四、补充知识
1. super()函数
在定义net类的构造方法的时候,使用了super(net,self).__init__()语句,当前的类和对象作为super函数的参数使用,这条语句的功能是使net类的构造方法获得其超类(父类)的构造方法,不影响对net类单独定义构造方法,且不必关注net类的父类到底是什么,若需要修改net类的父类时只需修改class语句中的内容即可。
2. torch.normal()
torch.normal()可分为三种情况:(1)torch.normal(means,std, out=none)中means和std都是tensor,两者的形状可以不必相同,但tensor内的元素数量必须相同,一一对应的元素作为输出的各元素的均值和标准差;(2)torch.normal(mean=0.0, std, out=none)中mean是一个可定义的float,各个元素共享该均值;(3)torch.normal(means,std=1.0, out=none)中std是一个可定义的float,各个元素共享该标准差。
3. torch.cat(seq, dim=0)
torch.cat可以将若干个tensor组装连接起来,dim指定在哪个维度上进行组装。
4. torch.max()
(1)torch.max(input)→ float
input是tensor,返回input中的最大值float。
(2)torch.max(input,dim, keepdim=true, max=none, max_indices=none) -> (tensor, longtensor)
同时返回指定维度=dim上的最大值和该最大值在该维度上的索引值。
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持服务器之家。
原文链接:https://blog.csdn.net/marsjhao/article/details/71743150