基于pytorch的输入为一通道 11*11大小的灰度图像，用LSTM-GAN来扩充数据集的代码

以下是一个基于PyTorch的LSTM-GAN模型，用于扩充灰度图像数据集。这个模型可以生成11*11大小的灰度图像。

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt

# 定义LSTM-GAN模型
class LSTM_GAN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(LSTM_GAN, self).__init__()
        
        # 定义LSTM层
        self.lstm = nn.LSTM(input_size, hidden_size)
        
        # 定义生成器
        self.generator = nn.Sequential(
            nn.Linear(hidden_size, 128),
            nn.ReLU(),
            nn.Linear(128, output_size),
            nn.Tanh()
        )
        
        # 定义判别器
        self.discriminator = nn.Sequential(
            nn.Linear(output_size, 128),
            nn.ReLU(),
            nn.Linear(128, 1),
            nn.Sigmoid()
        )
        
    def forward(self, x):
        # 通过LSTM层获取隐藏状态
        _, (hidden, _) = self.lstm(x)
        
        # 生成新的样本
        generated = self.generator(hidden[-1])
        
        # 判别新的样本
        score = self.discriminator(generated)
        
        return generated, score

# 定义训练函数
def train_lstm_gan(model, data, num_epochs=1000, batch_size=64, learning_rate=0.001):
    optimizer_g = torch.optim.Adam(model.generator.parameters(), lr=learning_rate)
    optimizer_d = torch.optim.Adam(model.discriminator.parameters(), lr=learning_rate)
    criterion = nn.BCELoss()
    
    for epoch in range(num_epochs):
        # 训练判别器
        for i in range(batch_size):
            real_data = data[np.random.randint(0, len(data))]
            real_data = torch.from_numpy(real_data).float().view(1, 1, -1)
            fake_data = model.generator(torch.randn(1, model.lstm.hidden_size))
            
            optimizer_d.zero_grad()
            
            real_score = model.discriminator(real_data)
            fake_score = model.discriminator(fake_data)
            
            real_loss = criterion(real_score, torch.ones_like(real_score))
            fake_loss = criterion(fake_score, torch.zeros_like(fake_score))
            
            loss_d = real_loss + fake_loss
            loss_d.backward()
            
            optimizer_d.step()
        
        # 训练生成器
        for i in range(batch_size):
            fake_data = model.generator(torch.randn(1, model.lstm.hidden_size))
            
            optimizer_g.zero_grad()
            
            fake_score = model.discriminator(fake_data)
            
            loss_g = criterion(fake_score, torch.ones_like(fake_score))
            loss_g.backward()
            
            optimizer_g.step()
        
        # 输出损失
        if epoch % 100 == 0:
            print('Epoch [{}/{}], Loss_G: {:.4f}, Loss_D: {:.4f}'.format(epoch+1, num_epochs, loss_g.item(), loss_d.item()))

# 加载数据集
data = np.load('data.npy')

# 定义模型
model = LSTM_GAN(11, 64, 11)

# 训练模型
train_lstm_gan(model, data, num_epochs=5000, batch_size=64, learning_rate=0.001)

# 生成新的样本
generated = []
for i in range(100):
    sample = model.generator(torch.randn(1, model.lstm.hidden_size))
    generated.append(sample.detach().numpy().flatten())
generated = np.array(generated)

# 显示生成的图像
plt.imshow(generated.T, cmap='gray')
plt.show()

需要注意的是，这个模型的训练需要很长的时间和大量的数据，因此建议使用GPU进行训练。同时，模型的超参数也需要进行调整以获得最佳的生成效果。