pytorch训练CNN-GRU

在PyTorch中训练CNN-GRU模型，可以使用nn.Module类来构建模型。下面是一个简单的示例代码，其中包含一个CNN层和一个GRU层：

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数据集，可以使用以下代码进行训练：

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中，我们使用测试集来评估模型的性能，并输出准确率。