PyTorch学习


阅读数: 次   
× 文章目录
  1. 1. 一、PyTorch介绍
    1. 1.1. 1、说明
    2. 1.2. 2、安装PyTorch
  2. 2. 二、基础知识
    1. 2.1. 1、和Numpy相似之处
      1. 2.1.1. (1) 数据转换
      2. 2.1.2. (2) Torch中的运算
    2. 2.2. 2、变量Variable
      1. 2.2.1. (1) 说明
      2. 2.2.2. (2) 使用
      3. 2.2.3. (3) 计算梯度
      4. 2.2.4. (4) Variable里面的数据
    3. 2.3. 3、Torch 中的激励函数
  3. 3. 三、建立基础的神经网络
    1. 3.1. 1、回归问题
      1. 3.1.1. (1) 准备工作
      2. 3.1.2. (2) 建立神经网络
      3. 3.1.3. (3) 训练网络
    2. 3.2. 2、分类问题
      1. 3.2.1. (1) 准备工作
      2. 3.2.2. (2) 建立网络
      3. 3.2.3. (3) 训练网络
    3. 3.3. 3、快速搭建神经网络
    4. 3.4. 4、保存和提取
      1. 3.4.1. (1) 保存（两种方法）
      2. 3.4.2. (2) 提取（也是两种方法）
    5. 3.5. 5、批训练SGD
      1. 3.5.1. (1) DataLoader
    6. 3.6. 6、优化器 optimizer
  4. 4. 四、高级神经网络
    1. 4.1. 1、卷积神经网络 CNN
  5. 5. Reference

一、PyTorch介绍

1、说明

  • PyTorch 是 Torch 在 Python 上的衍生（Torch 是一个使用 Lua 语言的神经网络库）
  • 和tensorflow比较
    • PyTorch建立的神经网络是动态的
    • Tensorflow是建立静态图
    • Tensorflow 的高度工业化, 它的底层代码是很难看懂的.
    • PyTorch 好那么一点点, 如果你深入 API, 你至少能比看 Tensorflow 多看懂一点点 PyTorch 的底层在干嘛.

2、安装PyTorch

  • 官网：http://pytorch.org/
  • 进入官网之后可以选择对应的安装选项
    • 目前只支持Linux和MacOS版本（2017-05-06）
    • 执行下面对应的安装命令即可
      安装
  • 安装 PyTorch 会安装两个模块
    • 一个是 torch, 一个 torchvision, torch 是主模块, 用来搭建神经网络的,
    • torchvision 是辅模块,有数据库,还有一些已经训练好的神经网络等着你直接用, 比如 (VGG, AlexNet, ResNet).
  • 上面在ubuntu14下自带的python2.7安装没有问题，在CentOS6.5下的python3.5中安装可能报错
    • 安装python3.5时的配置：
1
2
3
./configure --enable-shared \
            --prefix=/usr/local/python3.5 \
            LDFLAGS="-Wl,--rpath=/usr/local/lib"
  • 然后运行python可能报loading shared libraries: libpython3.5m.so.1.0: cannot open shared object file: No such file or directory的错误，拷贝一份libpython3.5m.so.1.0到/usr/lib64目录下即可
1
cp /home/Python/Python-3.5.3/libpython3.5m.so.1.0 /usr/lib64

二、基础知识

1、和Numpy相似之处

(1) 数据转换

  • 导入包：import torch
  • 将numpy数据转为torch数据
1
2
np_data = np.arange(6).reshape((2, 3))
torch_data = torch.from_numpy(np_data)
  • 将torch数据转为numpy数据
1
tensor2array = torch_data.numpy()

(2) Torch中的运算

  • API：http://pytorch.org/docs/torch.html#math-operations
  • torch 中 tensor 的运算和 numpy array运算很相似，比如
    • np.abs() --> torch.abs()
    • np.sin() --> torch.sin()等
  • 矩阵相乘：
    • data = [[1,2], [3,4]]
    • tensor = torch.FloatTensor(data) # 转换成32位浮点 tensor
    • torch.mm(tensor, tensor)

      2、变量Variable

      (1) 说明

  • Variable 就是一个存放会变化的值的位置
  • 这里变化的值就是tensor数据

    (2) 使用

  • 导入包

    1
    2
    import torch
    from torch.autograd import Variable # torch 中 Variable 模块

  • 定义tensor: tensor = torch.FloatTensor([[1,2],[3,4]])

  • 将tensor放入Variable: variable = Variable(tensor, requires_grad=True)
    • requires_grad 是参不参与误差反向传播, 要不要计算梯度
    • print(variable) 会输出，(多出Variable containing:，表明是Variable)
1
2
3
4
Variable containing:
 1  2
 3  4
[torch.FloatTensor of size 2x2]

(3) 计算梯度

  • v_out = torch.mean(variable*variable) # x^2
  • v_out.backward() # 模拟 v_out 的误差反向传递
  • print(variable.grad) # 显示 Variable 的梯度
    • 输出结果如下
    • 因为torch.mean(variable*variable)是1/4*x^2，导数就是1/2x
      1
      2
      0.5000  1.0000
      1.5000  2.0000

(4) Variable里面的数据

  • 直接print(variable)只会输出 Variable 形式的数据, 在很多时候是用不了的(比如想要用 plt 画图), 所以我们要转换一下, 将它变成 tensor 形式.
  • 获取 tensor 数据：print(variable.data) # tensor 形式
    • 然后也可以转而numpy数据：print(variable.data.numpy()) # numpy 形式

      3、Torch 中的激励函数

  • 导入包：import torch.nn.functional as F # 激励函数都在这
  • 平时要用到的就这几个. relu, sigmoid, tanh, softplus
  • 激励函数
    • x是Variable数据，F.relu(x)也是返回Variable数据，然后.data获取 tensor 数据
      1
      2
      3
      4
      # 做一些假数据来观看图像
      x = torch.linspace(-5, 5, 200)  # x data (tensor), shape=(100, 1)
      x = Variable(x)
      x_np = x.data.numpy()   # 换成 numpy array, 出图时用
1
2
3
4
5
y_relu = F.relu(x).data.numpy()
y_sigmoid = F.sigmoid(x).data.numpy()
y_tanh = F.tanh(x).data.numpy()
y_softplus = F.softplus(x).data.numpy()
# y_softmax = F.softmax(x)  softmax 比较特殊, 不能直接显示, 不过他是关于概率的, 用于分类
  • softplus的公式为：f(x)=ln(1+ex)

三、建立基础的神经网络

1、回归问题

(1) 准备工作

  • 导入包
1
2
3
4
import torch
from torch.autograd import Variable
import torch.nn.functional as F 
import matplotlib.pyplot as plt

  • 制造假数据

    • torch.unsqueeze是转成2维的数据[[]],加上一个假的维度
      1
      2
      x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)  # x data (tensor), shape=(100, 1)
      y = x.pow(2) + 0.2*torch.rand(x.size())                 # noisy y data (tensor), shape=(100, 1)

  • 定义Variable: x, y = torch.autograd.Variable(x), Variable(y)

    (2) 建立神经网络

  • 使用类的方式class

    • 继承torch.nn.Module
    • 这里只包含一个隐层，__init__只是定义了几个层
    • forward进行传播，也就是整个网络的搭建，因为是预测，最后一层不需要激励函数
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      class Net(torch.nn.Module):  # 继承 torch 的 Module
          def __init__(self, n_feature, n_hidden, n_output):
              super(Net, self).__init__()     # 继承 __init__ 功能
              # 定义每层用什么样的形式
              self.hidden = torch.nn.Linear(n_feature, n_hidden)   # 隐藏层线性输出
              self.predict = torch.nn.Linear(n_hidden, n_output)   # 输出层线性输出
          def forward(self, x):   # 这同时也是 Module 中的 forward 功能
              # 正向传播输入值, 神经网络分析出输出值
              x = F.relu(self.hidden(x))      # 激励函数(隐藏层的线性值)
              x = self.predict(x)             # 输出值
              return x

  • 使用：net = Net(n_feature=1, n_hidden=10, n_output=1)

  • 输出：print(net)，结果为
1
2
3
4
Net (
  (hidden): Linear (1 -> 10)
  (predict): Linear (10 -> 1)
)

(3) 训练网络

  • 定义优化器：optimizer = torch.optim.SGD(net.parameters(), lr=0.5) # 传入 net 的所有参数, 学习率lr
  • 定义损失函数：loss_func = torch.nn.MSELoss() # 预测值和真实值的误差计算公式 (均方差)
  • 训练
1
2
3
4
5
6
7
8
for t in range(100):
    prediction = net(x)     # 喂给 net 训练数据 x, 输出预测值
    loss = loss_func(prediction, y)     # 计算两者的误差
    optimizer.zero_grad()   # 清空上一步的残余更新参数值
    loss.backward()         # 误差反向传播, 计算参数更新值
    optimizer.step()        # 将参数更新值施加到 net 的 parameters 上

2、分类问题

(1) 准备工作

  • 导入包
1
2
3
4
import torch
from torch.autograd import Variable
import torch.nn.functional as F     # 激励函数都在这
import matplotlib.pyplot as plt

  • 制造假数据

    • x0是一个类别的x1,x2
    • y0就是对应这个类别的 label，这里是0
    • 然后将x0,x1，y0,y1合并在一起
      1
      2
      3
      4
      5
      6
      7
      8
      9
      # 假数据
      n_data = torch.ones(100, 2)         # 数据的基本形态
      x0 = torch.normal(2*n_data, 1)      # 类型0 x data (tensor), shape=(100, 2)
      y0 = torch.zeros(100)               # 类型0 y data (tensor), shape=(100, 1)
      x1 = torch.normal(-2*n_data, 1)     # 类型1 x data (tensor), shape=(100, 1)
      y1 = torch.ones(100)                # 类型1 y data (tensor), shape=(100, 1)
      # 注意 x, y 数据的数据形式是一定要像下面一样 (torch.cat 是在合并数据)
      x = torch.cat((x0, x1), 0).type(torch.FloatTensor)  # FloatTensor = 32-bit floating
      y = torch.cat((y0, y1), ).type(torch.LongTensor)    # LongTensor = 64-bit integer

  • 定义Variable: x, y = Variable(x), Variable(y)

(2) 建立网络

  • 与上面回归的例子类似

    • 使用relu激励函数
    • 这里最后一层并没有使用激励函数或是softmax，因为下面使用了CrossEntropyLoss，这个里面默认会调用log_softmax函数(nll_loss(log_softmax(input), target, weight, size_average))
    • 当然这里也可以最后返回F.softmax(x), 那么下面的损失函数就是loss = F.nll_loss(out, y)
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      class Net(torch.nn.Module):     # 继承 torch 的 Module
          def __init__(self, n_feature, n_hidden, n_output):
              super(Net, self).__init__()     # 继承 __init__ 功能
              self.hidden = torch.nn.Linear(n_feature, n_hidden)   # 隐藏层线性输出
              self.out = torch.nn.Linear(n_hidden, n_output)       # 输出层线性输出
          def forward(self, x):
              # 正向传播输入值, 神经网络分析出输出值
              x = F.relu(self.hidden(x))      # 激励函数(隐藏层的线性值)
              x = self.out(x)                 # 输出值, 但是这个不是预测值, 预测值还需要再另外计算
              return x

  • 建立网络：net = Net(n_feature=2, n_hidden=10, n_output=2) # 几个类别就几个 output

    (3) 训练网络

  • 优化器：optimizer = torch.optim.SGD(net.parameters(), lr=0.02) # 传入 net 的所有参数, 学习率
  • 损失函数：loss_func = torch.nn.CrossEntropyLoss()
  • 训练：
1
2
3
4
5
6
7
8
for t in range(100):
    out = net(x)     # 喂给 net 训练数据 x, 输出分析值
    loss = loss_func(out, y)     # 计算两者的误差
    optimizer.zero_grad()   # 清空上一步的残余更新参数值
    loss.backward()         # 误差反向传播, 计算参数更新值
    optimizer.step()        # 将参数更新值施加到 net 的 parameters 上
  • 预测：
    • 输出至最大的那个（概率最大的）坐标
      1
      2
      # 过了一道 softmax 的激励函数后的最大概率才是预测值
              prediction = torch.max(F.softmax(out), 1)[1]

3、快速搭建神经网络

  • 使用torch.nn.Sequential
1
2
3
4
5
net2 = torch.nn.Sequential(
    torch.nn.Linear(1, 10),
    torch.nn.ReLU(),
    torch.nn.Linear(10, 1)
)
  • 输出：print(net2)
    • 相比我们之前自己定义的类，激励函数也显示出来了
      1
      2
      3
      4
      5
      Sequential (
        (0): Linear (1 -> 10)
        (1): ReLU ()
        (2): Linear (10 -> 1)
      )

4、保存和提取

(1) 保存（两种方法）

  • 保存整个网络
    • torch.save(net1, 'net.pkl') # 保存整个网络，net1 就是定义的网络
  • 只保存网络中的参数
    • torch.save(net1.state_dict(), 'net_params.pkl') # 只保存网络中的参数 (速度快, 占内存少)

      (2) 提取（也是两种方法）

  • 提取整个网络：
    • net2 = torch.load('net.pkl')
    • prediction = net2(x)
  • 只提取网络参数
    • 首先需要定义一样的神经网络
    • net3.load_state_dict(torch.load('net_params.pkl'))
    • prediction = net3(x)

      5、批训练SGD

  • 上面我们虽然是torch.optim.SGD进行优化，但是还是将所有数据放进去训练

    (1) DataLoader

  • 是 torch 用来包装你的数据(tensor)的工具
  • 导入包： import torch.utils.data as Data

  • 将tensor数据转为torch能识别的Dataset

    1
    torch_dataset = Data.TensorDataset(data_tensor=x, target_tensor=y)

  • 把 dataset 放入 DataLoader

    • BATCH_SIZE是我们定义的batch大小
      1
      2
      3
      4
      5
      6
      loader = Data.DataLoader(
          dataset=torch_dataset,      # torch TensorDataset format
          batch_size=BATCH_SIZE,      # mini batch size
          shuffle=True,               # 要不要打乱数据 (打乱比较好)
          num_workers=2,              # 多线程来读数据
      )

  • 就可以得到batch数据了

    1
    2
    3
    4
    5
    6
    7
    8
    for epoch in range(3):   # 训练所有!整套!数据 3 次
        for step, (batch_x, batch_y) in enumerate(loader):  # 每一步 loader 释放一小批数据用来学习
            # 假设这里就是你训练的地方...
            # 打出来一些数据
            print('Epoch: ', epoch, '| Step: ', step, '| batch x: ',
                  batch_x.numpy(), '| batch y: ', batch_y.numpy())

  • 这里还是tensor数据，真正训练时还要放到Variable中

1
2
b_x = Variable(batch_x)  # 务必要用 Variable 包一下
b_y = Variable(batch_y)

6、优化器 optimizer

  • SGD
    • 就是随机梯度下降
  • momentum
    • 动量加速
    • 在SGD函数里指定momentum的值即可
  • RMSprop
    • 指定参数alpha
  • Adam
    • 参数betas=(0.9, 0.99)
      1
      2
      3
      4
      opt_SGD         = torch.optim.SGD(net_SGD.parameters(), lr=LR)
      opt_Momentum    = torch.optim.SGD(net_Momentum.parameters(), lr=LR, momentum=0.8)
      opt_RMSprop     = torch.optim.RMSprop(net_RMSprop.parameters(), lr=LR, alpha=0.9)
      opt_Adam        = torch.optim.Adam(net_Adam.parameters(), lr=LR, betas=(0.9, 0.99))

四、高级神经网络

1、卷积神经网络 CNN

  • 使用mnist数据集
  • 导入包
1
2
3
4
5
import torch
from torch.autograd import Variable
import torch.utils.data as Data
import torchvision
from matplotlib import pyplot as plt
  • 下载数据集
1
2
3
4
5
6
7
8
9
EPOCH = 10
BATCH_SIZE = 50
LR = 0.001
train_data = torchvision.datasets.MNIST(root='./mnist', 
                                        transform=torchvision.transforms.ToTensor(),
                                        download=False)  # first set True, then set False
print(train_data.train_data.size())
test_data = torchvision.datasets.MNIST(root='./mnist', train=False)

  • 处理数据

    • 使用 DataLoader 进行batch训练
    • 将测试数据放到Variable里，并加上一个维度（在第二维位置dim=1），因为下面训练时是(batch_size, 1, 28, 28)
      1
      2
      3
      4
      5
      train_loader = Data.DataLoader(dataset=train_data, batch_size=128, shuffle=True)
      # shape from (total_size, 28, 28) to (total_size, 1, 28, 28)
      test_x = Variable(torch.unsqueeze(test_data.test_data, dim=1), volatile=True).type(torch.FloatTensor)/255.0
      test_y = test_data.test_labels

  • 建立计算图模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class CNN(torch.nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = torch.nn.Sequential( # input shape (1, 28, 28)
            torch.nn.Conv2d(in_channels=1,
                            out_channels=16,
                            kernel_size=5,
                            stride=1, 
                            padding=2),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(kernel_size=2) 
        )   # output shape (16, 14, 14)
        self.conv2 = torch.nn.Sequential(
            torch.nn.Conv2d(16, 32, 5, 1, 2),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2)
        )  # output shape (32, 7, 7)
        self.out = torch.nn.Linear(in_features=32*7*7, out_features=10)
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0), -1) # 展平多维的卷积图成 (batch_size, 32 * 7 * 7)
        output = self.out(x)
        return output
cnn = CNN()
  • 定义优化器optimizer和损失
1
2
optimizer = torch.optim.Adam(cnn.parameters(), lr=LR)
loss_func = torch.nn.CrossEntropyLoss()
  • 进行batch训练
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
for epoch in range(EPOCH):
    for i, (x, y) in enumerate(train_loader):
        batch_x = Variable(x)
        batch_y = Variable(y)
        output = cnn(batch_x)
        loss = loss_func(output, batch_y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        if i % 50 == 0:
            # 用 test 数据来验证准确率
            test_output = cnn(test_x)
            pred_y = torch.max(test_output, 1)[1].data.squeeze()
            accuracy = sum(pred_y == test_y) / float(test_y.size(0))
            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data[0], '| test accuracy: %.2f' % accuracy)

Reference

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码
本站总访问量次 总访客数人次

tag:

    缺失模块。
    1、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    2、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: true
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

程序猿👨🏻‍💻