Pytorch：pytorch中的多种训练模型写法

日萌社

人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战（不定时更新）

---

1.optimizer优化器torch.optim、scheduler优化器步长自动调节器torch.optim.lr_scheduler
        #优化器
        optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
        optimizer = torch.optim.Adam(model.parameters(),lr=0.01)
        optimizer.step()
        
        #优化器步长自动调节方法, 用来自动衰减学习率
        scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 1, gamma=0.9)
        scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=EPOCHS)
        #每个epoch结束时，调用优化器步长调节方法, 用来衰减学习率
        scheduler.step()
        
2.pytorch中的多种训练模型写法
    1.第一种写法：
            #遍历epoch次数
            for epoch in range(N_EPOCHS)：
                data = DataLoader(train_data, batch_size=BATCH_SIZE, shuffle=True, collate_fn=generate_batch, drop_last=True)
                #遍历每个批量大小的数据
                for i, (input, label) in enumerate(data):
                    #第一种方式：在开始遍历每个批量大小的数据的一开始就设置，实际只要放置在loss.backward()之前即可
                    optimizer.zero_grad() 
                    output = model(input)
                    #交叉熵Cross Entropy用法第一种写法：nn.LogSoftmax + nn.NLLLoss = 交叉熵Cross Entropy
                    softmax = nn.LogSoftmax(dim=-1)
                    output = softmax(input)
                    criterion = nn.NLLLoss()
                    loss = criterion(output, label)
                    #第二种方式：放在反向传播求所有参数梯度(loss.backward())之前
                    #optimizer.zero_grad()  
                    loss.backward()
                    optimizer.step()
                #每个epoch结束时，调用优化器步长调节方法, 用来衰减学习率
                scheduler.step()
    
    2.第二种写法：
            #遍历epoch次数
            for epoch in range(N_EPOCHS)：
                data = DataLoader(train_data, batch_size=BATCH_SIZE, shuffle=True, collate_fn=generate_batch, drop_last=True)
                #遍历每个批量大小的数据
                for i, (input, label) in enumerate(data):
                    #第一种方式：在开始遍历每个批量大小的数据的一开始就设置，实际只要放置在loss.backward()之前即可
                    optimizer.zero_grad() 
                    output = model(input)
                    #交叉熵Cross Entropy用法第二种写法：F.log_softmax + F.nll_loss = 交叉熵Cross Entropy
                    output = F.log_softmax(output, dim=1)
                    loss = F.nll_loss(output, label)  
                    #第二种方式：放在反向传播求所有参数梯度(loss.backward())之前
                    #optimizer.zero_grad()  
                    loss.backward()
                    optimizer.step()
                #每个epoch结束时，调用优化器步长调节方法, 用来衰减学习率
                scheduler.step()
            
    3.第三种写法：
            #遍历epoch次数
            for epoch in range(N_EPOCHS)：
                data = DataLoader(train_data, batch_size=BATCH_SIZE, shuffle=True, collate_fn=generate_batch, drop_last=True)
                #遍历每个批量大小的数据
                for i, (input, label) in enumerate(data):
                    #第一种方式：在开始遍历每个批量大小的数据的一开始就设置，实际只要放置在loss.backward()之前即可
                    optimizer.zero_grad() 
                    output = model(input)
                    #交叉熵Cross Entropy用法第三种写法：torch.nn.CrossEntropyLoss()（内置softmax，无需显式写softmax层）=交叉熵Cross Entropy
                    #CrossEntropyLoss内置softmax，无需显式写softmax层
                    criterion = torch.nn.CrossEntropyLoss()
                    loss = criterion(output, label)
                    #第二种方式：放在反向传播求所有参数梯度(loss.backward())之前
                    #optimizer.zero_grad()  
                    loss.backward()
                    optimizer.step()
                #每个epoch结束时，调用优化器步长调节方法, 用来衰减学习率
                scheduler.step()
                
    4.第四种写法：
            class 自定义类名model(nn.Module) #必须继承nn.Module
                def __init__(self, ...)
                def forward(self, ...)
 
            #遍历epoch次数
            for epoch in range(N_EPOCHS)：
                data = DataLoader(train_data, batch_size=BATCH_SIZE, shuffle=True, collate_fn=generate_batch, drop_last=True)
                #遍历每个批量大小的数据
                for i, (input, label) in enumerate(data):
                    #使用继承了继承nn.Module的自定义类实例对象model调用zero_grad()
                    #在开始遍历每个批量大小的数据的一开始就设置，实际只要放置在loss.backward()之前即可
                    自定义类实例对象model.zero_grad()
		  output = 自定义类实例对象model(input)
                    #交叉熵Cross Entropy用法三种写法：
                    #   torch.nn.CrossEntropyLoss()（内置softmax，无需显式写softmax层） = 交叉熵Cross Entropy
                    #   F.log_softmax + F.nll_loss 或者 nn.LogSoftmax + nn.NLLLoss
                    #CrossEntropyLoss内置softmax，无需显式写softmax层
                    criterion = torch.nn.CrossEntropyLoss()
                    loss = criterion(output, label)
                    #放在反向传播求所有参数梯度(loss.backward())之前
                    #自定义类实例对象model.zero_grad()
                    loss.backward()
                    # 更新模型中所有的参数
                    for p in 自定义类实例对象model.parameters():
		      #add_：函数名末尾带有下划线代表变量原地修改值，并不需要返回修改好的新值
                        p.data.add_(-learning_rate, p.grad.data)

    5.第五种写法：
            class 自定义类名model(nn.Module) #必须继承nn.Module
                def __init__(self, ...)
                def forward(self, ...)

	   #优化器
	   optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
            #遍历epoch次数
            for epoch in range(N_EPOCHS)：
                data = DataLoader(train_data, batch_size=BATCH_SIZE, shuffle=True, collate_fn=generate_batch, drop_last=True)
                #遍历每个批量大小的数据
                for i, (input, label) in enumerate(data):
                    #在开始遍历每个批量大小的数据的一开始就设置，实际只要放置在loss.backward()之前即可
                    optimizer.zero_grad()
                    output = model(input)
                    #交叉熵Cross Entropy用法三种写法：
                    #   torch.nn.CrossEntropyLoss()（内置softmax，无需显式写softmax层） = 交叉熵Cross Entropy
                    #   F.log_softmax + F.nll_loss 或者 nn.LogSoftmax + nn.NLLLoss
                    #CrossEntropyLoss内置softmax，无需显式写softmax层
                    criterion = torch.nn.CrossEntropyLoss()
                    loss = criterion(output, label)
                    #放在反向传播求所有参数梯度(loss.backward())之前
                    #自定义类实例对象model.zero_grad()
                    loss.backward()
                    # 更新模型中所有的参数
		  optimizer.step()