前言

理论知识对于 AI 算法工程师极其重要。敲代码只是思路的一个实现过程。这里的「算法」和计算机 CS 的「算法」还不太一样，AI 算法是偏数学推导的，所以数学底子还是需要点的，学的越深，要求越高。面试的时候，很少让手写代码，90% 都是在问模型抠算法细节。

快速入门教程

https://morvanzhou.github.io/tutorials/machine-learning/torch/

Tensor

张量是对矢量和矩阵向潜在的更高维度的泛化,表示为基本数据类型的 n 维数组。

张量中的每个元素都具有相同的数据类型，且该数据类型一定是已知的。形状，即张量的维数和每个维度的大小，可能只有部分已知。

具体特点

使用方法

Note

（1）任何以“_”结尾的操作都会用结果替换原变量

例如: x.copy_(y), x.t_(), 都会改变 x.

（2）Torch Tensor与NumPy数组共享底层内存地址，修改一个会导致另一个的变化。

（3）所有的 Tensor 类型默认都是基于CPU， CharTensor 类型不支持到
NumPy 的转换.

（4）Tensor 和 Function互相连接并生成一个非循环图，它表示和存储了完整的计算历史。
每个张量都有一个.grad_fn属性，这个属性引用了一个创建了Tensor的Function（除非这个张量是用户手动创建的，即，这个张量的grad_fn是None）

如果需要计算导数，你可以在Tensor上调用.backward()。
如果Tensor是一个标量（即它包含一个元素数据）则不需要为backward()指定任何参数，
但是如果它有更多的元素，你需要指定一个gradient 参数来匹配张量的形状。

（5）torch.nn 只支持小批量输入。整个 torch.nn包都只支持小批量样本，而不支持单个样本。例如，nn.Conv2d 接受一个4维的张量，每一维分别是sSamples nChannels Height Width（样本数通道数高宽）如果你有单个样本，只需使用 `input.unsqueeze(0) 来添加其它的维数

（6）output为网络的输出，target为实际值

（7）torch.view()与 np.reshape()的区别：

效果一样，reshape（）操作nparray，view（）操作tensor

view（）只能操作contiguous的tensor，且view后的tensor和原tensor共享存储，reshape（）对于是否contiuous的tensor都可以操作。

（8）

1 2	import matplotlib.pyplot as plt plt.imshow(np.transpose(npimg, (1, 2, 0)))

img的格式为（channels,imagesize,imagesize），plt.imshow在现实的时候输入的是（imagesize,imagesize,channels）因此由np.transpose函数进行转换

np.transpose函数理解常用于图片翻转

（9）在张量创建时，通过设置 requires_grad 标识为Ture来告诉Pytorch需要对该张量进行自动求导，PyTorch会记录该张量的每一步操作历史并自动计算

机器学习知识点快速回顾

神经网络快速回顾

卷积神经网络快速回顾其中GoogLeNet (Inception) 、ResNet（跳连接）仔细看看

（10）MNIST数据集手写数字识别

import torch
import torch.nn as nn
import torch.nn.functional  as F
import torch.optim as optim
from torchvision import datasets, transforms
torch.__version__

BATCH_SIZE = 512
EPOCHS = 20
DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")

train_loader = torch.utils.data.DataLoader(
    datasets.MNIST(
        'data',
        train=True,
        download=True,
        transform=transforms.Compose([
            transforms.ToTensor(),
            transforms.Normalize((0.1307,), (0.3081,))
        ])), batch_size=BATCH_SIZE, shuffle=True)

test_loader = torch.utils.data.DataLoader(
    datasets.MNIST(
    'data',
    train=False,
    transform =  transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,))
    ])), batch_size=BATCH_SIZE, shuffle=True)

class ConvNet(nn.Module):
    def __init__(self):
        super().__init__()
        # 1,28x28
        self.conv1=nn.Conv2d(1, 10, 5) # 10, 24x24
        self.conv2=nn.Conv2d(10, 20, 3) # 128, 10x10
        self.fc1 = nn.Linear(20*10*10, 500)
        self.fc2 = nn.Linear(500, 10)
    def forward(self, x):
        in_size = x.size(0)
        out = self.conv1(x) #24
        out = F.relu(out)
        out = F.max_pool2d(out, 2, 2)  #12
        out = self.conv2(out) #10
        out = F.relu(out)
        out = out.view(in_size, -1)
        out = self.fc1(out)
        out = F.relu(out)
        out = self.fc2(out)
        out = F.log_softmax(out, dim=1)
        return out

model = ConvNet().to(DEVICE)
optimizer = optim.Adam(model.parameters())

def train(model, device, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        if(batch_idx+1)%30 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader), loss.item()))


def test(model, device, test_loader):
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            test_loss += F.nll_loss(output, target, reduction='sum').item() 
            # 将一批的损失相加
            pred = output.max(1, keepdim=True)[1] # 找到概率最大的下标
            correct += pred.eq(target.view_as(pred)).sum().item()

    test_loss /= len(test_loader.dataset)
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))

for epoch in range(1, EPOCHS + 1):
    train(model, DEVICE, train_loader, optimizer, epoch)
    test(model, DEVICE, test_loader)