can you provide a simple code snippet for training a RNN-GAN with Adam optimizer

python
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
from torchvision import datasets, transforms
import matplotlib.pyplot as plt
import numpy as np

# Define the RNN model
class RNNModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(RNNModel, self).__init__()
        self.hidden_size = hidden_size
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# Define the GAN model
class GANModel(nn.Module):
    def __init__(self):
        super(GANModel, self).__init__()
        self.fc1 = nn.Linear(100, 256)
        self.fc2 = nn.Linear(256, 512)
        self.fc3 = nn.Linear(512, 784)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = torch.tanh(self.fc3(x))
        return x

# Initialize the RNN and GAN models
rnn_model = RNNModel(input_size=100, hidden_size=256, output_size=784)
gan_model = GANModel()

# Set the loss functions and optimizers
criterion = nn.MSELoss()
optimizer_RNN = optim.Adam(rnn_model.parameters(), lr=0.001)
optimizer_GAN = optim.Adam(gan_model.parameters(), lr=0.001)

# Train the RNN-GAN
for epoch in range(100):
    for i in range(100):
        # Sample a batch of noise
        noise = torch.randn(100, 100)

        # Generate synthetic images
        synthetic_images = gan_model(noise)

        # Evaluate the discriminator
        discriminator.zero_grad()
        output = discriminator(synthetic_images)
        loss_D = criterion(output, torch.ones_like(output))
        loss_D.backward()
        optimizer_D.step()

        # Train the generator
        gan_model.zero_grad()
        output = discriminator(synthetic_images)
        loss_G = criterion(output, torch.ones_like(output))
        loss_G.backward()
        optimizer_G.step()

    # Print the loss at each epoch
    print(f'Epoch {epoch+1}, Loss D: {loss_D.item():.4f}, Loss G: {loss_G.item():.4f}')