在PyTorch中训练CNN-GRU模型，可以使用nn.Module类来构建模型。下面是一个简单的示例代码，其中包含一个CNN层和一个GRU层：
```python
import torch
import torch.nn as nn
class CNN_GRU_Model(nn.Module):
def __init__(self):
super(CNN_GRU_Model, self).__init__()
# CNN layer
self.cnn = nn.Sequential(
nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2),
nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2)
)
# GRU layer
self.gru = nn.GRU(input_size=32*6*6, hidden_size=64, num_layers=1, batch_first=True)
# Output layer
self.out = nn.Linear(64, 10)
def forward(self, x):
x = self.cnn(x)
x = x.view(x.size(0), -1)
x, _ = self.gru(x)
x = self.out(x[:, -1, :])
return x
```
在上述代码中，我们首先定义了一个`CNN_GRU_Model`类，继承自`nn.Module`类。该类包含三个层，分别是CNN层、GRU层和输出层。
在`__init__`函数中，我们定义了CNN层和GRU层。CNN层包含两个卷积层和两个池化层。GRU层包含一个单层的GRU网络，其中输入大小为32\*6\*6，隐藏层大小为64。输出层使用一个线性层，将GRU层的输出映射到10个类别上。
在`forward`函数中，我们首先将输入通过CNN层进行卷积和池化，然后将输出展平成二维张量。接着，我们将展平后的张量输入到GRU层中，得到GRU层的输出。最后，我们将GRU层的最后一个时间步的隐藏状态输入到输出层中，得到最终的分类结果。
接下来，我们可以使用上述模型来训练一个分类任务的数据集。假设我们使用的是CIFAR-10数据集，可以使用以下代码进行训练：
```python
import torchvision.datasets as datasets
import torchvision.transforms as transforms
# Load CIFAR-10 dataset
train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transforms.ToTensor())
test_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transforms.ToTensor())
# Define dataloader
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)
# Define model
model = CNN_GRU_Model()
# Define loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
# Train the model
num_epochs = 10
for epoch in range(num_epochs):
for images, labels in train_loader:
# Forward pass
outputs = model(images)
loss = criterion(outputs, labels)
# Backward and optimize
optimizer.zero_grad()
loss.backward()
optimizer.step()
# Evaluate the model on test set
with torch.no_grad():
total = 0
correct = 0
for images, labels in test_loader:
outputs = model(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
accuracy = correct / total
# Print the accuracy for each epoch
print('Epoch [{}/{}], Accuracy: {:.2f}%'.format(epoch+1, num_epochs, accuracy*100))
```
在上述代码中，我们首先加载CIFAR-10数据集，并定义一个dataloader。然后，我们定义了模型、损失函数和优化器。接着，我们使用循环进行训练，每个epoch都对整个训练集进行一次遍历。在每个epoch中，我们使用测试集来评估模型的性能，并输出准确率。
1717
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
