PyTorch 提示和技巧：从张量到神经网络

# 使用Tensor对象创建了一个 3x3 形状的未初始化张量。
import torch
tensor_uninitialized = torch.Tensor(3, 3)
tensor_uninitialized
"""
tensor([[1.7676e-35, 0.0000e+00, 3.9236e-44],
        [0.0000e+00,        nan, 0.0000e+00],
        [1.3733e-14, 1.2102e+25, 1.6992e-07]])
"""

# 我们还可以创建用零、一或随机值填充的张量。
tensor_rand = torch.rand(3, 3)
tensor_rand
"""
tensor([[0.6398, 0.3471, 0.6329],
        [0.4517, 0.2253, 0.8022],
        [0.9537, 0.1698, 0.5718]])
"""

# 数学运算
x = torch.Tensor([[1, 2, 3],
                  [4, 5, 6]])
tensor_add = torch.add(x, x)
"""
tensor([[ 2.,  4.,  6.],
        [ 8., 10., 12.]])
"""

# 01. 默认情况下，张量没有关联的梯度。
tensor= torch.Tensor([[1, 2, 3],
                      [4, 5, 6]])
tensor.requires_grad
"""
False
"""
# 02. 可以通过调用requires_grad_函数在张量上启用跟踪历史记录。
tensor.requires_grad_()
"""
tensor([[1., 2., 3.],
        [4., 5., 6.]], requires_grad=True)
"""
# 03. 但是目前该 Tensor 还没有梯度
print(tensor.grad)
"""
None
"""
# 04. 现在，让我们创建一个等于前一个张量中元素均值的新张量，以计算张量相对于新张量的梯度。
mean_tensor = tensor.mean()
mean_tensor
"""
tensor(3.5000, grad_fn=<MeanBackward0>)
"""
# 05. 要计算梯度，我们需要显式执行调用backward()函数的反向传播。
mean_tensor.backward()
print(tensor.grad)
"""
tensor([[0.1667, 0.1667, 0.1667],
        [0.1667, 0.1667, 0.1667]])
"""

import torch
from torch import nn
import torch.nn.functional as F
import numpy as np

# CNN 由 2 个卷积层组成，后面是一个全局平均池化层。最后，我们有 2 个全连接层和一个softmax来获得最终的输出概率。

class My_CNN(nn.Module):
   def __init__(self):
       super(My_CNN, self).__init__()
       self.conv1 = nn.Conv2d(1, 64, kernel_size=(3, 3), padding=1)
       self.conv2 = nn.Conv2d(64, 64, kernel_size=(3, 3), padding=1)
       self.avg_pool = nn.AvgPool2d(28)
       self.fc1 = nn.Linear(64, 64)
       self.fc2 = nn.Linear(64, 10)
   def forward(self, x):
       x = F.relu(self.conv1(x))
       x = F.relu(self.conv2(x))
       x = self.avg_pool(x)
       x = x.view(-1, 64)
       x = F.relu(self.fc1(x))
       x = self.fc2(x)
       x = F.softmax(x)
       
       return x

from torchvision.datasets import MNIST
from torch.utils.data import DataLoader
from torch.utils.data.sampler import SubsetRandomSampler
mnist = MNIST("data", download=True, train=True)
## create training and validation split
split = int(0.8 * len(mnist))
index_list = list(range(len(mnist)))
train_idx, valid_idx = index_list[:split], index_list[split:]
## create sampler objects using SubsetRandomSampler
train = SubsetRandomSampler(train_idx)
valid = SubsetRandomSampler(valid_idx)

# 使用DataLoader创建迭代器对象，它提供了使用多处理 worker 并行批处理、随机播放和加载数据的能力。
train_loader = DataLoader(mnist, batch_size=256, sampler=train)
valid_loader = DataLoader(mnist, batch_size=256, sampler=valid)

model = My_CNN()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
loss_function = nn.CrossEntropyLoss()

epochs = 10
for epoch in range(epochs):
  train_loss, valid_loss = [], []
  for data, target in train_loader:
    
    # forward propagation  
    outputs = model(data)
    # loss calculation
    loss = loss_function(outputs, target)
    # backward propagation
    optimizer.zero_grad()
    loss.backward()
    # weights optimization
    optimizer.step()
    train_loss.append(loss.item())
  for data, target in valid_loader:
    outputs = model(data)
    loss = los_function(outputs, target)
    valid_loss.append(loss.item())
  print('Epoch: {}, training loss: {}, validation loss: {}'
        .format(epoch, np.mean(train_loss), np.mean(valid_loss)))

with torch.no_grad():
  correct = 0
  total = 0
  for data, target in valid_loader:
    outputs = model(images)
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum().item()
print('Validation set Accuracy: {} %'.format(100 * correct / total))