前言

目前一些模型API尚未迁移到TF20中。 eg: CRF，Seq2Seq等
如果退回TF10，有些伤。
倒不如转至Torch。
Pytorch的大部分思想和TF20大致相似。

至于安装，GPU我前面说过TF20。这里不赘述。
官档安装：https://pytorch.org/get-started/locally/#start-locally

注意

本文几乎通篇以代码案例 和 注释标注 的方式解释API。(模型的训练效果不做考虑。只看语法)
你如果懂Tensorflow2.0（Stable），那么你看本文一定不费劲。
Torch和TF20 很像！！！
因此一些地方，我会列出 TF20 与 Torch的细节对比。

开门案例1-MNIST

模块导入

import torch
from torch import nn, optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

数据预处理

data_preprocess = transforms.Compose([  # 顶预定数据处理函数，类似map()里的函数句柄
    transforms.Resize(28,28),           # 变形
    transforms.ToTensor(),              # numpy 转 Tensor
])

trian_dataset = datasets.MNIST(         # TF20在keras.datasets中,未归一化（0-255）
    '.',                                # 下载至当前目录， （图片0-1，已经被归一化了）
    train=True,                         # train=True， 代表直接给你切出 训练集
    download=True,                      # True，若未下载，则先下载
    transform=data_preprocess,          # 指定数据预处理函数。第一行我们指定的
)

test_dataset = datasets.MNIST(
    '.', 
    train=False, # False代表测试集       # 就说下这里， False代表 给你切出测试集
    download=True,
    transform=data_preprocess,
)

train = DataLoader(     # 对应TF20中的 tf.data.Dataset对数据二次预处理（分批，乱序）
    trian_dataset,      # 把上面第一次预处理的数据集 加载进来
    batch_size=16,      # mini-batch
    shuffle=True,       # 乱序，增强模型泛化能力
)

test = DataLoader(
    test_dataset,
    batch_size=16,
    shuffle=True,
)

MNIST模型（定义-训练代码）

# 模型定义部分
class MyModel(nn.Module):             # TF20是 tk.models.Model
    def __init__(self):               # TF20 也是 __init__()
        super().__init__()

        self.model = nn.Sequential(   # tk.models.Sequential , 并且 TF里面 需要加一个 []
            nn.Linear(28*28, 256),    # tk.layers.Dense(256)
            nn.ReLU(),                # tk.layers.Relu()

            nn.Linear(256, 128),      # tk.layers.Dense(128)
            nn.ReLU(),               

            nn.Linear(128, 10),       # tk.layers.Dense(10)            
        ) 
    def forward(self, x):  # TF20是 __call__()
        x = x.view( x.size(0), 28*28 )      # x.view ==> tf.reshape   x.size ==> x.shape[0]
        y_predict = self.model(x)

        return y_predict
# -------------------------------华丽分割线---------------------------------     
# 模型训练部分
def main():
    vis = visdom.Visdom()
    model = MyModel()
    loss_ = nn.CrossEntropyLoss()     # 会将 y_predict自动加一层 softmax
    optimizer = optim.Adam(model.parameters())     # TF20: model.trainable_variables
    
    # visdom可视化
    # 这步是初始化坐标点，下面loss会用这个直接更新
    vis.line(
        [0],                    # x坐标
        [0],                    # y坐标
        win='loss',             # 窗口名称
        opts={'title': 'loss'}, # 窗口标题
    )
    
    for epoch in range(10):   # epochs
        for step, (x, y_true) in enumerate(train):
            y_predict = model(x)
            loss = loss_(y_predict, y_true)
            optimizer.zero_grad()           #  优化器清零 
            loss.backward()                 #  梯度计算
            optimizer.step()                #  梯度下降更新 tp.gradient(loss, variables)。 
            
            # 在上面的定义的基础上更新追加画点-连成线
            vis.line(
                [loss.item()],
                [step],
                win='loss',
                update='append', # 追加画点，而不是更新覆盖
            )
        print(loss.item())                  #  .item()  => 相当于 tensorflow 的 numpy()
        
        if epoch % 2 == 0:
            total_correct_samples = 0       # 用于记录（预测正确的样本的 总数量）
            total_samples = 0               # 用于记录（样本的 总数量）

            for x_test, y_test in test:
                y_pred = model(x_test)
                y_final_pred = y_pred.argmax(dim=1)     # TF20的坐标轴参数是 axis
                
                 # 每一批是 batch_size=16，我们要把它们都加在一起
                total_correct_samples += torch.eq(y_final_pred, y_test).float().sum().item()
                
                # 这里提一下 eq() 和 equal() 的返回值的区别， 自己看，我们通常用 eq
                # print( torch.equal( torch.Tensor([[1,2,3]]), torch.Tensor([[4,5,6]] ) ) ) 
                #结果:  False
                # print( torch.eq( torch.Tensor([[1,2,3]]), torch.Tensor([[4,5,6]] ) ) ) 
                #结果:  tensor([[0, 0, 0]], dtype=torch.uint8)

                per_sample = x_test.size(0)   # 再说一次， size(0) 相当于TF xx.shape[0]
                # 获取每批次样本数量, 虽然我们知道是 16
                # 但是最后一个batch_size 可能不是16，所以要准确获取。
                total_samples += per_sample

            acc = total_correct_samples / total_samples
            print(f'epoch: {epoch}, loss: {loss}, acc: {acc}')   
            
            # 测试部分
            vis.line(
                [acc],
                [step],
                win='acc',
                update='append', # 追加画点，而不是更新覆盖
            )

            x, label = iter(test).next()
            target_predict = model(x).argmax(dim=1)
            
            # 画出测试集图片
            viz.images(x, nrow=16, win="test_x", opts={'title': "test_x"}) 
            vis.text(    # 显示预测标签文本
                str(target_predict.detach().numpy() ),
                win = 'target_predict',
                opts = {"title": target_predict}
            )
            vis.text(    # 显示真值文本
                str(label.detach().numpy() ),
                win = 'target_true',
                opts = {"target_true": target_predict}
            )
main()

模型可视化（visdom)

安装 和 运行 和 使用

安装
    pip install visdom
运行
    python -m visdom.server  （第一次可能会有点慢）
    
# 语法和Tensorboard很像

使用
    import visdom
    见上代码 vis.xxxxx

案例2-CIFAR10+CNN

说明

模块导入和数据预处理部分和案例1的 MNIST一模一样。
只要稍稍修改 datasets.MNIST ==> datasets.CIFAR10 即可， 简单的不忍直视~~

代码如下：

模型定义部分：

class MyModel(nn.Module):        # 温馨提示， 这是 Mmodule, 不是model
    def __init__(self):
        """
            先注明一下： 
                TF中输入图片形状为       (样本数, 高，宽，图片通道)
                PyTorch中输入图片形状为  (样本数, 图片通道，高，宽)
        """

        super().__init__()
        self.conv = nn.Sequential( # 再强调一遍，没有 []
            nn.Conv2d(
                in_channels=3,    # 对应TF  图片通道数（或者上一层通道）
                out_channels=8,   # 对应TF  filters, 卷积核数量
                kernel_size=3,    # 卷积核大小
                stride=1,         # 步长, TF 是 strides，  特别注意
                padding=0,        # no padding, 默认
            ),
            nn.ReLU(),
            nn.MaxPool2d(
                kernel_size=3,    # 滑动窗口大小
                stride=None,      # 默认为None， 意为和 kernel_size相同大小
            ),

            nn.Conv2d(
                in_channels=8,    # 对应TF  图片通道数（或者上一层通道）
                out_channels=16,   # 对应TF  filters, 卷积核数量
                kernel_size=3,    # 卷积核大小
                stride=1,         # 步长, TF 是 strides，  特别注意
                padding=0,        # no padding, 默认
            ),
            nn.ReLU(),
            nn.MaxPool2d(
                kernel_size=2,    # 滑动窗口大小
                stride=None,      # 默认为None， 意为和 kernel_size相同大小
            ),
        )
        self.dense = nn.Sequential(
            nn.Linear(16*4*4, 128),    # 对应TF Dense
            nn.Linear(128, 64),
            nn.Linear(64, 10),
        )
    def forward(self, x):
        conv_output = self.conv(x)
        # (16, 16, 4.4)
        conv_output_reshape = conv_output.view(-1, 16*4*4)
        dense_output = self.dense(conv_output_reshape)

        return dense_output

模型训练（模型调用+模型训练的定义）

def main():
    vis = visdom.Visdom()

    epochs = 100

    device = torch.device('cuda')  # 预定义 GPU 槽位（一会往里面塞 模型和数据。）

    model = MyModel().to(device)   # 模型转为 GPU 计算
    
    # CrossEntropyLoss 会自动把下面的 dense_output ，也就是y_predict 加一层 softmax
    loss_ = nn.CrossEntropyLoss().to(device)  
    optimizer = optim.Adam( model.parameters() )

    for epoch in range(epochs):
        for step, (x_train, y_train) in enumerate(train):
            x_train, y_train = x_train.to(device), y_train.to(device)
            dense_output = model(x_train)

            loss = loss_(dense_output, y_train)

            optimizer.zero_grad()   # 上一个例子提到过，梯度清零
            loss.backward()         # 反向传播， 并将梯度累加到 optimizer中
            optimizer.step()        # 相当于做了 w = w - lr * 梯度

        print(loss.item())          # item() 意思就是 tensor转numpy,TF中的 API是 xx.numpy()

        sample_correct_numbers = 0
        sample_total_numbers = 0

        with torch.no_grad():   # 测试部分不需要计算梯度，因此可以包裹在上下文中。
            for x_test, y_test in test:
                x_test, y_test = x_test.to(device), y_test.to(device)
                
                # softmax 的 y_predict  与  y_test的 one-hot做交叉熵
                y_predict = model(x_test).argmax(dim=1) 
                sample_correct_numbers += torch.eq(y_predict, y_test).float().sum().item()
                sample_total_numbers += x_test.size(0)  # 每批样本的总数加在一起
            acc = sample_correct_numbers / sample_total_numbers
            print(acc)

main()

案例3：CIFAR10+ResNet-18

结构图体系：

上述结构说明：

1conv + (2+2+2+2)*2 + 1 fc = 18层
1conv + (3+4+6+3)*2 + 1 fc = 34层
1conv + (3+4+6+3)*3 + 1 fc = 50层
1conv + (3+4+23+3)*3 + 1 fc = 101层
1conv + (3+8+36+3)*3 + 1 fc = 152层

代码实现

模块导入

import cv2
import torch
from torch import nn, optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import visdom
import torch.nn.functional as F

数据导入预处理

data_preprocess = transforms.Compose([
    transforms.Resize(32,32),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

train_dataset = datasets.CIFAR10(
    '.',
    train=True,
    download=True,
    transform=data_preprocess,
)


test_dataset = datasets.CIFAR10(
    '.',
    train=False, # False代表测试集
    download=True,
    transform=data_preprocess,
)


train = DataLoader(
    train_dataset,
    batch_size=16,
    shuffle=True,
)

test = DataLoader(
    test_dataset,
    batch_size=16,
    shuffle=True,
)

基础块定义（BasicBlock）：

class BasicBlock(nn.Module):
    """单个残差块 2个卷积+2个BN"""
    def __init__(self, input_channel, output_channel, stride=1):
        super().__init__()
        self.major = nn.Sequential(
            # 第一个Conv的步长为指定步长，允许降采样，允许输出输出通道不一致
            nn.Conv2d(input_channel,output_channel,kernel_size=3,stride=stride, padding=1),
            nn.BatchNorm2d(output_channel),
            nn.ReLU(inplace=True),
            # 第二个Conv的步长为定长1， 输入输出通道不变（缓冲输出）
            nn.Conv2d(output_channel, output_channel, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(output_channel),   
            # 第二个Conv就不用ReLU了， 因为一会需要和 x加在一起，最后最一层大的Relu
        )
        # 若输入通道==输出通道，且步长为1，意味着图片未被降采样，则残差网络课直接为普通网络

        self.shortcut = nn.Sequential()
        # 若输入输出通道不匹配，这时需要将图片做同样的变换，才能加在一起。
        if input_channel != output_channel or stride != 1:
            self.shortcut = nn.Sequential(
                nn.Conv2d(
                    input_channel,
                    output_channel,
                    kernel_size=(1,1),
                    stride = stride
                ),
                nn.BatchNorm2d(output_channel)
            )            

    def forward(self, x):
        major_out = self.major(x)        # 主干网络的输出
        shotcut_out = self.shortcut(x)   # 残差网络的输出
        # 上面这两个网络是平行的关系，  因为 它们的输出不是链式的， 而是  都是同样的 x。

        # 拼接主干网络+残差网络，F 相当于TF20的 tf.nn 里面单独有各种 loss函数
        return F.relu(major_out + shotcut_out)  # 最后在拼接后的网络外面加一层relu 

ResNet+ResBlock定义：

class ResNet(nn.Module):
    def __init__(self, layers):  # layers用来接受，用户想要指定 ResNet的形状
        super().__init__()

        self.conv1 = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True),
        )        

        self.res_net = nn.Sequential(
            *self.ResBlock(32,64, layers[0],stride=2),    # 16
            *self.ResBlock(64,128, layers[1],stride=2),   # 8
            *self.ResBlock(128,256, layers[2],stride=2),  # 4
            *self.ResBlock(256,512, layers[3],stride=2),  # 2
        )
        # 因为我们一会需要展平，里面填"通道*宽度*高度", "输出通道"
        self.dense = nn.Linear(512 * 2 * 2, 10)  
        
    def forward(self, x):
        out = self.conv1(x)
        out = self.res_net(out)

        out = out.view(x.size(0), -1)# 卷积展平操作 ， torch中没有flatten所以我们就得手工
        out = self.dense(out)
        return out

    def ResBlock(self, input_channel, output_channel, block_nums=2, stride=2):
        # 自定义规定，第一个block缩小的(对应通道翻倍)，其余block大小不变
        # 通道翻倍，步长*2，特征减半
        all_block = [BasicBlock(input_channel, output_channel,stride=stride)]   

        for x in range(1,block_nums):
            all_block.append(BasicBlock(output_channel, output_channel,stride=1))
        return all_block

# resnet = ResNet(layers=[2,2,2,2])
# out = resnet(torch.randn(4,3,32,32))
# print(out.shape)

模型训练：

def main():
    vis = visdom.Visdom()

    epochs = 5

    device = torch.device('cuda')

    model = ResNet(layers=[2,2,2,2]).to(device) 
    
    # 会自动把下面的 dense_output ，也就是y_predict 加一层 softmax，y_true做one-hot
    loss_ = nn.CrossEntropyLoss().to(device)  
    optimizer = optim.Adam( model.parameters(), lr=0.0001)

    for epoch in range(epochs):
        total_loss = 0.0
        for step, (x_train, y_train) in enumerate(train):
            x_train, y_train = x_train.to(device), y_train.to(device)
            dense_output = model(x_train)

            loss = loss_(dense_output, y_train)

            optimizer.zero_grad()   # 上一个例子提到过，梯度清零
            loss.backward()         # 反向传播， 并将梯度累加到 optimizer中
            optimizer.step()        # 相当于做了 w = w - lr * 梯度
            total_loss += loss.item() # item()就是 tensor转numpy, TF中的 API是 xx.numpy()
            if step % 50 == 49:
                print('epoch:',epoch, 'loss:', total_loss / step) 

        sample_correct_numbers = 0
        sample_total_numbers = 0

        with torch.no_grad():   # 测试部分不需要计算梯度，因此可以包裹在上下文中。
            for x_test, y_test in test:
                x_test, y_test = x_test.to(device), y_test.to(device)
                # softmax 的 y_predict  与  y_test的 one-hot做交叉熵
                y_predict = model(x_test).argmax(dim=1) 
                sample_correct_numbers += torch.eq(y_predict, y_test).float().sum().item()
                sample_total_numbers += x_test.size(0)  # 每批样本的总数加在一起
            acc = sample_correct_numbers / sample_total_numbers
            print(acc)
    torch.save(model, 'model.pkl')  # 保存整个模型
main()

测试数据预处理(我随便在网上下载下来的 1 张图片)：

# 这是Cifar-10数据的标准标签
label = ['airplane','automobile','bird','cat','deer','dog','frog','horse','ship','truck']

plane = cv2.imread('plane.jpg')              # 我用的opencv
plane = cv2.cvtColor(plane, cv2.COLOR_BGR2RGB) # opencv读的数据格式是BGR，所以转为RGB

plane = (plane - 127.5) / 127.5    # 二话不说，保持模型输入数据的概率分布，先做归一化
plane = cv2.resize(plane, (32,32)) # 图片缩小到32x32,和模型的输入保持一致
plane = torch.Tensor(plane)        # 转换成 tensor
plane = plane.view(1,32,32,3)      # 增加一个维度
plane = plane.repeat(16,1,1,1)     # 我就用一张图片，为了满足模型的形状16，我复制了16次     
plane = plane.permute([0,3,1,2])   # 虽然torch也有 像TF那样的transpose，但是只能操作2D

device = torch.device('cuda')      # 先定义一个cuda设备对象
plane = plane.to(device)           # 我们训练集用的cuda， 所以预测数据也要转为cuda

正式输入模型预测：

model = torch.load('model.pkl')    # 读取出 我们训练到最后整个模型
# 说明一下，如果你的预测是另一个脚本中，class ResNet 的代码定义部分也要复制过来

out = model(plane)                 # 预测结果，形状为[16,10] 16个样本，10个预测概率，
label_indexes = out.argmax(dim=1)  # 取10个概率最大值的索引。 （1轴），形状为 [16,1]
print(label_indexes)
for i in label_indexes:            # i为每个样本预测的最大概率值 的 索引位置。
    print(label[i])                # 拿着预测标签的索引  去 真实标签中找到真实标签