一、Pytorch介绍
Pytorch 是Torch在Python上的衍生物
和Tensorflow相比：
Pytorch建立的神经网络是动态的，而Tensorflow建立的神经网络是静态的
Tensorflow的高度工业化，它的底层代码很难看懂
Pytorch主要有两个模块：
一个是torch,一个是torchvision,torch是主模块，用来搭建神经网络。torchvision是辅模块，有数据库，还有一些已经训练好的神经网络等着你直接用比如（VGG,AlexNet,ResNet）
二、基础知识
1.与Numpy交互
（1）数据转换
import torch import numpy as np # 创建一个np array a = np.array([[1,2], [3,4]]) b = torch.from_numpy(a) # 根据np array创建torch 张量 c = b.numpy() # 根据张量, 导出np array
(2)数据运算
torch中tensor的运算与numpy array运算相似，比如
np.abs()--->torch.abs()
np.sin()---->torch.sin()等
2.变量Variable
(1)Variable组成
在Torch中Variable由三部分组成：data部分是Torch的Tensor,grad部分是这个变量的梯度缓存区，creator部分是这个Variable的创造节点，如果用一个Variable进行计算，那返回的也是同类型的Variable
(2)使用
导入
import torch
from torch.autograd import Variable
定义Variable的同时有一项requires_grad是关于参不参与误差反向传播，要不要计算梯度
注意Variable 和Tensor的区别：
Variable计算时，它在后台默默地搭建着一个庞大地系统，叫做计算图。computional graph将所有地计算步骤（节点）都连接起来，最后进行误差反向传递地时候，一次性将所有Variable里面地修改梯度都计算出来，而tensor只是一个数据结构。
构建计算图
y = w * x + b # y = 2 * x + 3
（3）计算梯度
# 对y求梯度 y.backward() # 打印一下各个变量的梯度 print(x.grad) # y对x的梯度: x.grad = 2 print(w.grad) # y对w的梯度: w.grad = 1 print(b.grad) # y对b的梯度: b.grad = 1
（4）Variable里面地数据
直接print(variable)只会输出Variable形式地数据，在很多时候是用不了地（比如想要用plt绘图），所以我们要转换一下，将它变成tensor形式
获取tensor数据：Print（variable.data）,也可以将其转为numpy形式：print(variable.data.numpy())
3.Pytorch中的激活函数
导入包：import torch.nn.functional as F
平时常用的：relu、sigmoid,tanh,softplus
激活函数：激活函数的输入与输出都是variable
4.Pytorch中的数据加载器和batch
(1)生成数据生成并构建Dataset子集
import torch import torch.utils.data as Data torch.manual_seed(1) BATCH_SIZE = 5 x = torch.linspace(1, 10, 10) # 输入数据 y = torch.linspace(10, 1, 10) # 输出数据 # 打包成TensorDataset对象,成为标准数据集 torch_dataset = Data.TensorDataset(data_tensor=x, target_tensor=y)
（2）生成batch数据
PyTorch用类torch.utils.data.DataLoader加载数据，并对数据进行采样，生成batch迭代器
# 创建数据加载器
loader = Data.DataLoader(
dataset=torch_dataset, # TensorDataset类型数据集
batch_size=BATCH_SIZE, # mini batch size
shuffle=True, # 设置随机洗牌
num_workers=2, # 加载数据的进程个数
)
for epoch in range(3): # 训练3轮
for step, (batch_x, batch_y) in enumerate(loader): # 每一步
# 在这里写训练代码...
print(‘Epoch: ‘, epoch, ‘| Step: ‘, step, ‘| batch x: ‘, batch_x.numpy(), ‘| batch y: ‘, batch_y.numpy())
6.GPU运算
Pytorch中使用GPU计算简单，通过调用.cuda()方法，很容易实现GPU支持
torch.cuda会记录当前选择的GPU，并且分配的所有CUDA张量将在上面创建
可以使用torch.cuda.device上下文管理器更改所选设备
7.加载预训练模型
import torchvision
# 下载并加载resnet.
resnet = torchvision.models.resnet18(pretrained=True)
# 如果你只想要finetune模型最顶层的参数
for param in resnet.parameters():
# 将resent的参数设置成不更新
param.requires_grad = False
# 把resnet的全连接层fc 替换成自己设置的线性层nn.Linear
# 比如说,输入维度是resnet.fc.in_features, 输出是100维
resnet.fc = nn.Linear(resnet.fc.in_features, 100)
# 测试一下
images = Variable(torch.randn(10, 3, 256, 256))
outputs = resnet(images)
print (outputs.size()) # (10, 100)
8.简单回归
import torch
from torch.autograd import Variable
import matplotlib.pyplot as plt
torch.manual_seed(1)
x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1) # 张量 x: (100, 1)
y = x.pow(2) + 0.2*torch.rand(x.size()) # 加入噪声的张量 y: (100, 1)
# 将张量转为 Variable
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_feature, n_hidden, n_output):
super(Net, self).__init__()
self.hidden = torch.nn.Linear(n_feature, n_hidden) # 隐层
self.relu = torch.nn.ReLU() # 选择激活层
self.predict = torch.nn.Linear(n_hidden, n_output) # 输出层
def forward(self, x):
x = self.hidden(x) # 计算隐层
x = self.relu(x) # 计算激活层
x = self.predict(x) # 输出层
return x
net = Net(n_feature=1, n_hidden=10, n_output=1) # 定义网络
print(net)
#打印网络结构
# 选择损失函数和优化方法
loss_func = torch.nn.MSELoss()
optimizer = torch.optim.SGD(net.parameters(), lr=0.2)
plt.ion() # hold住图
for t in range(100):
prediction = net(x) # 用网络预测一下
loss = loss_func(prediction, 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(), prediction.data.numpy(), ‘r-‘, lw=5)
plt.text(0.5, 0, ‘Loss=%.4f‘ % loss.data[0], fontdict={‘size‘: 20, ‘color‘: ‘red‘})
plt.pause(1)
print(t)
plt.ioff()
plt.show()
9.快速构建序列网络
torch.nn.Sequential是一个Sequential容器，模块将按照构造函数中传递的顺序添加到模块中。另外 ，也可以传入一个有序模块。
# Sequential使用实例
model = nn.Sequential(
nn.Conv2d(1,20,5),
nn.ReLU(),
nn.Conv2d(20,64,5),
nn.ReLU()
)
# Sequential with OrderedDict使用实例
model = nn.Sequential(OrderedDict([
(‘conv1‘, nn.Conv2d(1,20,5)),
(‘relu1‘, nn.ReLU()),
(‘conv2‘, nn.Conv2d(20,64,5)),
(‘relu2‘, nn.ReLU())
]))
为了方便比较，我们先用普通方法搭建一个神经网络。
import torch
# 继承方式实现, 能够自定义forward
class ModuleNet(torch.nn.Module):
def __init__(self, n_feature, n_hidden, n_output):
super(ModuleNet, self).__init__()
self.hidden = torch.nn.Linear(n_feature, n_hidden) # 隐层
self.relu = torch.nn.ReLU() # 选择激活层
self.predict = torch.nn.Linear(n_hidden, n_output) # 输出层
def forward(self, x):
x = self.hidden(x) # 计算隐层
x = self.relu(x) # 计算激活层
x = self.predict(x) # 输出层
return x
module_net = ModuleNet(1, 10, 1)
上面ModuleNet继承了一个torch.nn.Module中的神经网络结构, 然后对其进行了修改；接下来我们来使用torch.nn.Sequential来快速搭建一个神经网络。
#用序列化工具, 给予Pytorch 内部集成的网络层 快速搭建
seq_net = torch.nn.Sequential(
torch.nn.Linear(1, 10),
torch.nn.ReLU(),
torch.nn.Linear(10, 1)
)
我们来打印一下2个神经网络的数据，查看区别:
print(module_net) # 打印网络结构 """ ModuleNet ( (hidden): Linear (1 -> 10) (relu): ReLU () (predict): Linear (10 -> 1) ) """ print(seq_net) # 打印网络结构 """ Sequential ( (0): Linear (1 -> 10) (1): ReLU () (2): Linear (10 -> 1) ) """
原文地址：https://www.cnblogs.com/yifdu25/p/8975250.html