PyTorch 1

PyTorch (2021.09.10)

1. 基本概念

1.1 Tensor(张量)

操作与Numpy类似

#
x=torch.Tensor(5,3)
x=torch.rand(5,3)
y=x.numpy() #可以和numpy相互转化
z=torch.from_numpy(y)

#torch.tensor() 可以同时对array和numpy格式的数据进行处理
s = np.array([1,2,3,4])
a = [1,2,3,4]
torch.tensor([s,a])
#

1.2 Variable(变量)
**将Tensor转换成Variable可以将计算从CPU转移到GPU上 ** 这句话存在疑问，等我弄懂了再来更新。

Variable是Tensor的封装，每个Variable都有三个属性。
Varibale的Tensor本身的 .data ，对应Tensor的梯度 .grad，以及这个Variable是通过什么方式得到的 .grad_fn。

import torch
from torch.autograd import Variable #导入variable

x = torch.rand(4)
x = variable(x,requires_grad = True)
y = x * 3
grad_variables = torch.Tensor([1,2,3,4])
y.backward(grad_variables)                   
x.grad

Backward函数

关于梯度变量和backward函数的具体意义可以参考

Pytorch中的自动求导函数backward()所需参数含义

对于y.backward()函数 即 下一步计算对于 y 的梯度，其中grad_Variables可以看作是对于求得梯度的 雅可比矩阵的一个加权。

x.grad()则即为计算对于上一个调用backward函数的变量求梯度。

总结
对于一个用pytorch计算的网络，首先需要通过向前传播，计算loss是否符合停止要求，否则将对于output的误差进行反向传播，output.backward()，此时任意步骤上的变量对于output求梯度函数为x.grad，并使用梯度下降使得误差降低，这也是一般神经网络的结构。

 
 
 

通过Pytorch实现一个两层的bp神经网络

通过对于iris数据集进行bp神经网络拟合

#导入相关包
import torch
import matplotlib.pyplot as plt
import torch.nn.functional as F

from sklearn.datasets import load_iris
from torch.autograd import Variable
from torch.optim import SGD
from sklearn.model_selection import train_test_split   #导入

#判断GPU是否可用
use_cuda = torch.cuda.is_available()
print("use_cuda:",use_cuda)

#导入数据集
iris = load_iris()
iris.keys()

#划分实验测试集
X_train,X_test,y_train,y_test = train_test_split(iris.data,iris.target,test_size = 0.3,random_state = 0)

X_train,X_test,y_train,y_test = torch.FloatTensor(X_train),torch.FloatTensor(X_test),torch.LongTensor(y_train),torch.LongTensor(y_test)
X_train,X_test,y_train,y_test = Variable(X_train),Variable(X_test),Variable(y_train),Variable(y_test)

#forward
#继承Module，并重写forward过程
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.sigmoid(self.hidden(x))
        x = self.predict(x)
        out = F.log_softmax(x,dim = 1)
        return out

net = Net(4,5,4)

optimizer = SGD(net.parameters(),lr = 0.5)

for i in range(1000):
    prediction = net(X_train)
    loss = F.nll_loss(prediction,y_train)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()     #优化器更新