PyTorch学习

1.PyTorch的数据结构

torch用张量来保存数据，张量与numpy的数组可以相互转化。

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(
    '\nnumpy:',np_data,
    '\ntorch:',torch_data,
    '\ntensor2array:',tensor2array,
)

numpy: [[0 1 2]
 [3 4 5]] 
torch: tensor([[0, 1, 2],
        [3, 4, 5]], dtype=torch.int32) 
tensor2array: [[0 1 2]
 [3 4 5]]

FloatTensor方法可以获得浮点型的tensor数据，abs方法可以获得tensor的绝对值。

tensor=torch.FloatTensor(np_data)
torch.abs(tensor)

tensor还支持矩阵乘法

tensor=torch.FloatTensor([[1,2],[3,4]])
torch.mm(tensor,tensor)

tensor([[ 7., 10.],
        [15., 22.]])

torch支持常用的激励函数，如relu，sigmoid，tanh，softplus，softmax等等

import torch.nn.functional as F

x=torch.linspace(-5,5,200)
x_np=x.numpy()

y_relu=F.relu(x).numpy()
y_sigmoid=F.sigmoid(x).numpy()
y_tanh=torch.tanh(x).numpy()
y_softplus=F.softplus(x).numpy()

2.PyTorch回归分析

造一点伪数据

%matplotlib inline
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())#干扰

plt.scatter(x.numpy(),y.numpy())

构造神经网络：
其中Net类必须继承它的父类，并且要传入输入层，隐藏层，输出层的神经元数目，前向传播采用relu作为激活函数。
前向传播为对输入加权求和，再经过一个非线性激活函数。
即 ，再经过

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.predict=torch.nn.Linear(n_hidden,n_output)
    
    def forward(self,x):
        x=F.relu(self.hidden(x))
        x=self.predict(x)
        return x

net=Net(1,10,1)
print(net)

Net(
  (hidden): Linear(in_features=1, out_features=10, bias=True)
  (predict): Linear(in_features=10, out_features=1, bias=True)
)

使用SGD（随机梯度下降）作为优化器，进行一百次循环，使用MSE作为损失函数，每次循环进行反向传播计算梯度，但是每次循环过后要将梯度清零。
优化算法的功能，是通过改善训练方式，来最小化(或最大化)损失函数E(x)。

optimizer=torch.optim.SGD(net.parameters(),lr=0.5)
loss_func=torch.nn.MSELoss()
for i in range(100):
    prediction=net(x)
    
    loss=loss_func(prediction,y)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

plt.scatter(x.numpy(),y.numpy())
plt.plot(x.numpy(),prediction.detach().numpy(),'r-',lw=5)
plt.show()