zoukankan html css js c++ java

PyTorch学习（2）

　　1 Numpy与Torch的区别与联系

　　　1.1 numpy的array与Torch的tensor转换

　　　1.2 Torch中的variable

　　2 激励函数（Activation Function）

　　3 Regression回归（关系拟合回归）

　　4 Classification（分类）

　　5 Torch网络

　　　5.1 快速搭建torch网络

　　　5.2 保存和提取网络与参数

　　　5.3 批处理

　　　5.3 优化器optimizer加速神经网络

　　6 神经网络分类

这里是根据莫凡pytorch学习的，与pytorch学习（1）可能有所重叠，但是大部分不太一样，可以结合着一起看。

1 Numpy与Torch的区别与联系

1.1 numpy的array与Torch的tensor转换

1）数据类型转换

注：torch只处理二维数据

import torch
import numpy as np

np_data = np.arange(6).reshape((2, 3))
torch_data = torch.from_numpy(np_data)
tensor2array = torch_data.numpy()

print('
np_data', np_data,
     '
torch_data', torch_data,
     '
tensor2array', tensor2array, )

#结果显示
np_data [[0 1 2]
[3 4 5]]
torch_data tensor([[0, 1, 2],
      [3, 4, 5]], dtype=torch.int32)
tensor2array [[0 1 2]
[3 4 5]]

2）矩阵乘法

data = [[1, 2], [2, 3]]
tensor = torch.FloatTensor(data)
print('
numpy', np.matmul(data, data),
     '
torch', torch.matmul(tensor, tensor))

#结果显示
numpy [[ 5  8]
[ 8 13]]
torch tensor([[ 5.,  8.],
      [ 8., 13.]])
注意的是torch中默认的tensor是float形式的

1.2 Torch中的variable

import torch
from torch.autograd import Variable

tensor = torch.FloatTensor([[1, 2], [3, 4]])
variable = Variable(tensor, requires_grad=True)

t_out = torch.mean(tensor*tensor)
v_out = torch.mean(variable*variable)
print('tensor', tensor)
print('variable', variable)
print('t_out', t_out)
print('v_out', v_out)

v_out.backward()  # 反向传播
print('grad', variable.grad)  # variable的梯度
print(variable.data.numpy())

#结果显示
tensor tensor([[1., 2.],
      [3., 4.]])
variable tensor([[1., 2.],
      [3., 4.]], requires_grad=True)
t_out tensor(7.5000)
v_out tensor(7.5000, grad_fn=<MeanBackward0>)
grad tensor([[0.5000, 1.0000],
      [1.5000, 2.0000]])
[[1. 2.]
[3. 4.]]

2 激励函数（Activation Function）

对于多层神经网络，激励函数的选择有一定窍门

推荐网络与激活函数的对应：

CNN-relu
RNN-relu/tanh

有三种常用激活函数：(这里说的是线图)

relu、sigmoid、tanh

import torch
from torch.autograd import Variable
import matplotlib.pyplot as plt

x = torch.linspace(-5, 5, 200)  # 从-5~5分成200段
x = Variable(x)
x_np = x.data.numpy()

y_relu = torch.relu(x).data.numpy()
y_sigmoid = torch.sigmoid(x).data.numpy()
y_tanh = torch.tanh(x).data.numpy()

plt.figure(1, figsize=(8, 6))
plt.subplot(311)
plt.plot(x_np, y_relu, c='r', label='relu')
plt.ylim((-1, 5))
plt.legend(loc='best')

plt.subplot(312)
plt.plot(x_np, y_sigmoid, c='g', label='sigmoid')
plt.ylim((-0.2, 1.5))
plt.legend(loc='best')

plt.subplot(313)
plt.plot(x_np, y_tanh, c='b', label='tanh')
plt.ylim((-1.2, 1.5))
plt.legend(loc='best')
plt.show()

#结果显示

3 Regression回归（关系拟合回归）

一般分为两种：

回归问题：一堆数据出一条线
分类问题：一堆数据进行分类

我们讲的是回归问题：

import torch
from torch.autograd import Variable
import matplotlib.pyplot as plt

x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)  # 一维变二维
y = x.pow(2) + 0.2*torch.rand(x.size())

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

# plt.scatter(x.data.numpy(), y.data.numpy())
# plt.show()

# 搭建网络
class Net(torch.nn.Module):
   def __init__(self, n_features, n_hidden , n_output):
       super(Net, self).__init__()
       # 以上为固定的初始化
       self.hidden = torch.nn.Linear(n_features, n_hidden)
       self.predict = torch.nn.Linear(n_hidden, n_output)

   def forward(self, x):
       x = torch.relu(self.hidden(x))
       x = self.predict(x)
       return x

net = Net(1, 10, 1)  # 1个输入点，10个隐藏层的节点，1个输出
print(net)

plt.ion()  # 可视化
plt.show()

optimizer = torch.optim.SGD(net.parameters(), lr=0.5)
loss_function = torch.nn.MSELoss()  # 回归问题用均方误差，分类问题用其他的误差损失函数

for t in range(100):
   out = net(x)
   loss = loss_function(out, y)  # 预测值在前真实值在后
   optimizer.zero_grad()
   loss.backward()
   optimizer.step()
   if t % 5 == 0:
       plt.cla()
       plt.scatter(x.data.numpy(), y.data.numpy())
       plt.plot(x.data.numpy(), out.data.numpy(), 'r-', lw=5)
       plt.text(0.5, 0, 'Loss=%.4f' % loss.item(), fontdict={'size': 20, 'color': 'red'})
       plt.pause(0.1)

plt.ioff()
plt.show()

#结果显示
Net(
(hidden): Linear(in_features=1, out_features=10, bias=True)
(predict): Linear(in_features=10, out_features=1, bias=True)
)

最终输出的结果图：