码迷,mamicode.com
首页 > 其他好文 > 详细

Pytorch(一)

时间:2018-04-30 23:54:24      阅读:313      评论:0      收藏:0      [点我收藏+]

标签:ret   height   self   它的   .text   记录   att   导出   lock   

一、Pytorch介绍

Pytorch 是Torch在Python上的衍生物

和Tensorflow相比:

Pytorch建立的神经网络是动态的,而Tensorflow建立的神经网络是静态的

Tensorflow的高度工业化,它的底层代码很难看懂

官网:http://pytorch.org/

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)
)
"""



Pytorch(一)

标签:ret   height   self   它的   .text   记录   att   导出   lock   

原文地址:https://www.cnblogs.com/yifdu25/p/8975250.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!