pytorch基础：autograd, 模型定义

import os
from turtle import forward
import cv2
import torch


# 定义一个网络
import torch.nn as nn
import torch.nn.functional as F


class Net(nn.Module):
    def __init__(self):
        # super相当于是指向当前对象的父类，这样就可以用super.xxx来引用父类的成员。
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    # 在模型中必须要定义 forward 函数，backward 函数（用来计算梯度）会被autograd自动创建。 可以在 forward 函数中使用任何针对 Tensor 的操作。
    def forward(self, x):
        x = F.max_pool2d(F.relu(self.conv1(x)), 2)
        x = F.max_pool2d(self.conv2(x), 2)
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

    def num_flat_features(self, x):
        size = x.size()[1:]  # all dimensions except the batch dimension
        num_features = 1
        print('*******', num_features)
        for s in size:
            num_features *= s
            print('---', s, num_features)
        return num_features


if __name__ == "__main__":
    # autograd包为张量上的所有操作提供了自动求导。 它是一个在运行时定义的框架，意味着反向传播是根据你的代码来确定如何运行，并且每次迭代可以是不同的。
    """
    torch.Tensor是这个包的核心类。如果设置 .requires_grad 为 True，那么将会追踪所有对于该张量的操作。 当完成计算后通过调用 .backward()，自动计算所有的梯度， 这个张量的所有梯度将会自动积累到 .grad 属性。

    要阻止张量跟踪历史记录，可以调用.detach()方法将其与计算历史记录分离，并禁止跟踪它将来的计算记录。

    为了防止跟踪历史记录（和使用内存），可以将代码块包装在with torch.no_grad()：中。 在评估模型时特别有用，因为模型可能具有requires_grad = True的可训练参数，但是我们不需要梯度计算。
    """
    # 反向传播时
    # 一个纯量（scalar），out.backward() 等于out.backward(torch.tensor(1))
    # 否则需要指定tensor作为参数传入backward
    x = torch.randn(3, requires_grad=True)

    y = x * 2
    while y.data.norm() < 1000:
        y = y * 2

    print(y)
    gradients = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float)
    y.backward(gradients)

    print(x.grad)

    """
    Neural Networks
    """
    net = Net()
    print(net)

    # net.parameters()返回可被学习的参数（权重）列表和值
    input = torch.randn(1, 1, 32, 32)
    out = net(input)
    print(out)

    """
    损失函数
    """
    output = net(input)
    target = torch.randn(10)  # 随机值作为样例
    target = target.view(1, -1)  # 使target和output的shape相同
    criterion = nn.MSELoss()

    loss = criterion(output, target)
    print(loss)

    """
    反向传播
    """
    # 将所有参数的梯度缓存清零，然后进行随机梯度的的反向传播
    net.zero_grad()
    out.backward(torch.randn(1, 10))

    """
    更新权重
    """
    # 当使用神经网络是想要使用各种不同的更新规则时，比如SGD、Nesterov-SGD、Adam、RMSPROP等，PyTorch中构建了一个包torch.optim实现了所有的这些规则。
    import torch.optim as optim

    optimizer = optim.SGD(net.parameters(), lr=0.01)

    # in your training loop:
    optimizer.zero_grad()   # zero the gradient buffers
    output = net(input)
    loss = criterion(output, target)
    loss.backward()
    optimizer.step()    # Does the update