PyTorch 1.0 系列学习教程（1）： Tensors

这是我的pytorch学习记录的开篇.
在这个tutorial中，通过自带的examples介绍PyTorch的基本概念.
作为它的核心，PyTorch有2个主要的特征：

• 一个n维Tensor，其类似与numpy但可以运行在GPUs上
• 为构建和训练神经网络提供自动微分

本文将使用一个全连接的ReLU网络作为示例. 其仅有一个隐含层，训练时使用梯度下降法来拟合随机数据（随机生成的样本）：最小化网络的预测值与真实值之间的欧式距离（Euclidean distance）.

• 提示
  示例代码可以到我的github仓库上获取

TENSORS

Warm-up: numpy

再介绍PyTorch之前，首先用numpy实现该网络.
Numpy提供了一个n维数组对象，同时提供了许多操作用于操作这些数组的函数. Numpy 是一个通用的科学计算框架，它并不知道什么是计算图，深度学习或者梯度. 但是我们可以很容易的用numpy实现一个2层的网络去拟合训练样本，这个过程需要我们使用numpy的各种操作，手工实现网络的前向和反向传播.

# -*- coding: utf-8 -*-
import numpy as np

# N is batch size; D_in is input dimension;
# H is hidden dimension; D_out is output dimension.
N, D_in, H, D_out = 64, 1000, 100, 10

# Create random input and output data
x = np.random.randn(N, D_in)
y = np.random.randn(N, D_out)

# Randomly initialize weights
w1 = np.random.randn(D_in, H)
w2 = np.random.randn(H, D_out)

learning_rate = 1e-6
for t in range(500):
    # Forward pass: compute predicted y
    h = x.dot(w1)
    h_relu = np.maximum(h, 0)
    y_pred = h_relu.dot(w2)

    # Compute and print loss
    loss = np.square(y_pred - y).sum()
    print(t, loss)

    # Backprop to compute gradients of w1 and w2 with respect to loss
    grad_y_pred = 2.0 * (y_pred - y)
    grad_w2 = h_relu.T.dot(grad_y_pred)
    grad_h_relu = grad_y_pred.dot(w2.T)
    grad_h = grad_h_relu.copy()
    grad_h[h < 0] = 0
    grad_w1 = x.T.dot(grad_h)

    # Update weights
    w1 -= learning_rate * grad_w1
    w2 -= learning_rate * grad_w2

PyTorch:Tensors

Numpy是一个非常棒的框架，但是它不能使用GPUs来加速数值计算. 对现代深度神经网络来说，GPUs通常可以提供50倍以上的加速比，所以，很不幸运，对现在深度学习来说，仅依赖numpy 是不够的.
接下来，本文将介绍PyTorch最基础的概念：Tensor. 一个PyTorch Tensor在概念上与numpy 数组完全一致：一个Tensor就是一个n维的数组，同时，PyTorch 提供了许多操作这些Tensors的函数. 在幕后，张量可以跟踪计算图（computational graph）和梯度（gradients）,但他们也可作为一个有用的科学计算通用工具.
与numpy不同的是，PyTorch能使用GPUs来加速数值计算，你只需要把它投射到一个新的数据类型.
这里我们使用PyTorch张量实现一个两层的网络来拟合随机数据. 像上面numpy的例子，我们需要手动实现前向和反向传播网络.

# -*- coding: utf-8 -*-

import torch


dtype = torch.float
device = torch.device("cpu")
# device = torch.device("cuda:0") # Uncomment this to run on GPU

# N is batch size; D_in is input dimension;
# H is hidden dimension; D_out is output dimension.
N, D_in, H, D_out = 64, 1000, 100, 10

# Create random input and output data
x = torch.randn(N, D_in, device=device, dtype=dtype)
y = torch.randn(N, D_out, device=device, dtype=dtype)

# Randomly initialize weights
w1 = torch.randn(D_in, H, device=device, dtype=dtype)
w2 = torch.randn(H, D_out, device=device, dtype=dtype)

learning_rate = 1e-6
for t in range(500):
    # Forward pass: compute predicted y
    h = x.mm(w1)
    h_relu = h.clamp(min=0)
    y_pred = h_relu.mm(w2)

    # Compute and print loss
    loss = (y_pred - y).pow(2).sum().item()
    print(t, loss)

    # Backprop to compute gradients of w1 and w2 with respect to loss
    grad_y_pred = 2.0 * (y_pred - y)
    grad_w2 = h_relu.t().mm(grad_y_pred)
    grad_h_relu = grad_y_pred.mm(w2.t())
    grad_h = grad_h_relu.clone()
    grad_h[h < 0] = 0
    grad_w1 = x.t().mm(grad_h)

    # Update weights using gradient descent
    w1 -= learning_rate * grad_w1
    w2 -= learning_rate * grad_w2

参考

[1] pytorch官方网站