DenseNet 與學習策略的組合程式
时间: 2023-12-04 20:00:26 浏览: 30
以下是使用 PyTorch 实现 DenseNet 和学习策略的组合代码示例:
首先,我们需要导入必要的库:
```python
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
```
然后,我们定义我们的 DenseNet 模型。在这个例子中,我们使用了 DenseNet-121。模型的定义如下:
```python
class DenseNet(nn.Module):
def __init__(self):
super(DenseNet, self).__init__()
self.densenet = torchvision.models.densenet121(pretrained=True)
self.densenet.classifier = nn.Linear(1024, 10)
def forward(self, x):
x = self.densenet(x)
return x
```
接下来,我们定义我们的学习策略。在这个例子中,我们使用了 SGD 优化器和学习率衰减。学习率衰减可以帮助我们在训练过程中逐渐减小学习率,以帮助我们更好地收敛。
```python
def get_optimizer(model):
optimizer = optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=1e-4)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)
return optimizer, scheduler
```
然后,我们定义我们的数据集和数据加载器。在这个例子中,我们使用 CIFAR-10 数据集。
```python
train_transform = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
test_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=train_transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=4)
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=test_transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False, num_workers=4)
```
接下来,我们定义我们的训练和测试函数。在训练函数中,我们使用交叉熵损失和 L2 正则化。在测试函数中,我们计算模型的准确率。
```python
def train(model, optimizer, criterion, trainloader, device):
model.train()
train_loss = 0.0
correct = 0
total = 0
for inputs, targets in trainloader:
inputs, targets = inputs.to(device), targets.to(device)
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, targets)
loss.backward()
optimizer.step()
train_loss += loss.item()
_, predicted = outputs.max(1)
total += targets.size(0)
correct += predicted.eq(targets).sum().item()
return train_loss / len(trainloader), 100.0 * correct / total
def test(model, criterion, testloader, device):
model.eval()
test_loss = 0.0
correct = 0
total = 0
with torch.no_grad():
for inputs, targets in testloader:
inputs, targets = inputs.to(device), targets.to(device)
outputs = model(inputs)
loss = criterion(outputs, targets)
test_loss += loss.item()
_, predicted = outputs.max(1)
total += targets.size(0)
correct += predicted.eq(targets).sum().item()
return test_loss / len(testloader), 100.0 * correct / total
```
最后,我们可以开始训练和测试我们的模型。在这个例子中,我们使用 GPU 来加速训练。
```python
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Using device:", device)
model = DenseNet().to(device)
optimizer, scheduler = get_optimizer(model)
criterion = nn.CrossEntropyLoss()
best_acc = 0.0
for epoch in range(0, 10):
scheduler.step()
train_loss, train_acc = train(model, optimizer, criterion, trainloader, device)
test_loss, test_acc = test(model, criterion, testloader, device)
print("Epoch: {:2d} Train Loss: {:.2f} Train Acc: {:.2f}% Test Loss: {:.2f} Test Acc: {:.2f}%".format(
epoch + 1, train_loss, train_acc, test_loss, test_acc))
if test_acc > best_acc:
best_acc = test_acc
torch.save(model.state_dict(), "best_model.pt")
print("Best Test Acc: {:.2f}%".format(best_acc))
```
这就是一个使用 DenseNet 和学习策略的组合的 PyTorch 代码示例。