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

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

import torch
import torch.nn as nn
import numpy as np
import os
import cv2

# 定义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 load_data(path):
    data = []
    for filename in os.listdir(path):
        img = cv2.imread(os.path.join(path, filename), cv2.IMREAD_GRAYSCALE)
        img = cv2.resize(img, (11, 11))
        data.append(img.flatten())
    return np.array(data)

# 定义训练函数
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()))

# 定义生成函数
def generate_images(model, num_images=100, save_path='generated'):
    if not os.path.exists(save_path):
        os.makedirs(save_path)
    for i in range(num_images):
        sample = model.generator(torch.randn(1, model.lstm.hidden_size))
        img = sample.detach().numpy().reshape(11, 11) * 255
        img = np.uint8(img)
        cv2.imwrite(os.path.join(save_path, f'{i}.png'), img)

# 加载数据集
data_path = 'data'
data = load_data(data_path)

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

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

# 生成新的样本
generate_images(model, num_images=100, save_path='generated')

需要注意的是，这个模型的训练需要很长的时间和大量的数据，因此建议使用GPU进行训练。同时，模型的超参数也需要进行调整以获得最佳的生成效果。生成的图像会保存在`save_path`指定的文件夹中。