这里提供一个使用余弦退火算法自适应学习率优化CNN模型的PyTorch程序。 首先，导入必要的库： ```python import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader from torchvision.datasets import MNIST from torchvision.transforms import ToTensor ``` 然后，定义一个简单的CNN模型： ```python class CNN(nn.Module): def __init__(self): super(CNN, self).__init__() self.conv1=nn.Conv2d(1, 10, kernel_size=5) self.conv2=nn.Conv2d(10, 20, kernel_size=5) self.fc1=nn.Linear(320, 50) self.fc2=nn.Linear(50, 10) def forward(self, x): x=nn.functional.relu(nn.functional.max_pool2d(self.conv1(x), 2)) x=nn.functional.relu(nn.functional.max_pool2d(self.conv2(x), 2)) x=x.view(-1, 320) x=nn.functional.relu(self.fc1(x)) x=self.fc2(x) return nn.functional.log_softmax(x, dim=1) ``` 接下来，定义训练函数： ```python 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=nn.functional.nll_loss(output, target) loss.backward() optimizer.step() if batch_idx % 100==0: print('Train Epoch: {} [{}/{} ({:.0f}%)] Loss: {:.6f}'.format( epoch, batch_idx * len(data), len(train_loader.dataset), 100. * batch_idx / len(train_loader), loss.item())) ``` 然后，定义测试函数： ```python 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 +=nn.functional.nll_loss(output, target, reduction='sum').item() pred=output.argmax(dim=1, keepdim=True) correct +=pred.eq(target.view_as(pred)).sum().item() test_loss /=len(test_loader.dataset) print(' Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%) '.format( test_loss, correct, len(test_loader.dataset), 100. * correct / len(test_loader.dataset))) ``` 最后，定义主函数： ```python def main(): # 设置设备 device=torch.device("cuda" if torch.cuda.is_available() else "cpu") # 加载数据集 train_dataset=MNIST('https://blog.csdn.net/weixin_44943389/article/details/data', train=True, download=True, transform=ToTensor()) test_dataset=MNIST('https://blog.csdn.net/weixin_44943389/article/details/data', train=False, download=True, transform=ToTensor()) train_loader=DataLoader(train_dataset, batch_size=64, shuffle=True) test_loader=DataLoader(test_dataset, batch_size=1000, shuffle=True) # 定义模型 model=CNN().to(device) # 定义优化器 optimizer=optim.SGD(model.parameters(), lr=0.1) # 训练模型 for epoch in range(1, 11): train(model, device, train_loader, optimizer, epoch) test(model, device, test_loader) # 更新学习率 optimizer.param_groups[0]['lr']=0.1 * (1 + math.cos(math.pi * epoch / 10)) if __name__=='__main__': main() ``` 在主函数中，我们使用余弦退火算法来自适应地更新学习率。具体来说，我们将学习率初始化为0.1，然后在每个epoch中，根据当前epoch数使用余弦函数计算新的学习率，然后将其更新到优化器中的参数组中。这样，我们可以在训练过程中自适应地调整学习率，从而更好地优化模型。