使用GAN进行异常检测

 import torch
 import torch.nn as nn
 import torch.optim as optim
 from torch.utils.data import DataLoader, TensorDataset
 import numpy as np
 import matplotlib.pyplot as plt
 
 # Define the generator model
 class Generator(nn.Module):
     def __init__(self, latent_dim):
         super(Generator, self).__init__()
         self.model = nn.Sequential(
             nn.Linear(latent_dim, 256),
             nn.ReLU(),
             nn.BatchNorm1d(256),
             nn.Linear(256, 512),
             nn.ReLU(),
             nn.BatchNorm1d(512),
             nn.Linear(512, 784),
             nn.Sigmoid(),
             nn.Unflatten(1, (28, 28, 1))
         )
 
     def forward(self, x):
         return self.model(x)
 
 # Define the discriminator model
 class Discriminator(nn.Module):
     def __init__(self, img_shape):
         super(Discriminator, self).__init__()
         self.model = nn.Sequential(
             nn.Flatten(),
             nn.Linear(np.prod(img_shape), 512),
             nn.ReLU(),
             nn.Linear(512, 256),
             nn.ReLU(),
             nn.Linear(256, 1),
             nn.Sigmoid()
         )
 
     def forward(self, x):
         return self.model(x)
 
 # Define the GAN model
 class GAN(nn.Module):
     def __init__(self, generator, discriminator):
         super(GAN, self).__init__()
         self.generator = generator
         self.discriminator = discriminator
 
     def forward(self, x):
         x = self.generator(x)
         x = self.discriminator(x)
         return x
 
 # Function to compile models
 def compile_models(generator, discriminator, gan, latent_dim):
     d_optimizer = optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))
     g_optimizer = optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))
 
     criterion = nn.BCELoss()
 
     discriminator.compile(optimizer=d_optimizer, loss=criterion)
     gan.compile(optimizer=g_optimizer, loss=criterion)
 
 # Function to generate random noise for the generator
 def generate_latent_points(latent_dim, batch_size):
     return torch.randn(batch_size, latent_dim)
 
 # Function to train the GAN
 def train_gan(generator, discriminator, gan, dataset, latent_dim, epochs, batch_size):
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     generator.to(device)
     discriminator.to(device)
     gan.to(device)
 
     dataset = torch.tensor(dataset, dtype=torch.float32).to(device)
     dataloader = DataLoader(TensorDataset(dataset), batch_size=batch_size, shuffle=True)
 
     criterion = nn.BCELoss()
 
     for epoch in range(epochs):
         for batch_data in dataloader:
             real_data = batch_data[0].to(device)
             batch_size = real_data.size(0)
 
             noise = generate_latent_points(latent_dim, batch_size).to(device)
             generated_data = generator(noise)
 
             labels_real = torch.ones((batch_size, 1), dtype=torch.float32).to(device)
             labels_fake = torch.zeros((batch_size, 1), dtype=torch.float32).to(device)
 
             d_loss_real = criterion(discriminator(real_data), labels_real)
             d_loss_fake = criterion(discriminator(generated_data.detach()), labels_fake)
 
             d_loss = 0.5 * (d_loss_real + d_loss_fake)
 
             discriminator.zero_grad()
             d_loss.backward()
             discriminator_optimizer.step()
 
             noise = generate_latent_points(latent_dim, batch_size).to(device)
             labels_gan = torch.ones((batch_size, 1), dtype=torch.float32).to(device)
 
             g_loss = criterion(gan(noise), labels_gan)
 
             generator.zero_grad()
             g_loss.backward()
             generator_optimizer.step()
 
             print(f"Epoch {epoch + 1}/{epochs}, Batch {batch}/{len(dataloader)}, D Loss: {d_loss.item()}, G Loss: {g_loss.item()}")
 
 # Function to generate and plot synthetic data
 def generate_and_plot(generator, latent_dim, examples=10):
     generator.eval()
     noise = generate_latent_points(latent_dim, examples)
     generated_data = generator(noise).detach().cpu().numpy()
 
     for i in range(examples):
         plt.subplot(2, 5, i + 1)
         plt.imshow(generated_data[i, 0, :, :], cmap='gray_r')
         plt.axis('off')
 
     plt.show()
 
 # Example usage
 latent_dim = 100
 img_shape = (28, 28, 1)
 
 # Build and compile the models
 generator = Generator(latent_dim)
 discriminator = Discriminator(img_shape)
 gan = GAN(generator, discriminator)
 compile_models(generator, discriminator, gan, latent_dim)
 
 # Load and preprocess your dataset (e.g., MNIST)
 (train_images, _), (_, _) = tf.keras.datasets.mnist.load_data()
 train_images = train_images / 127.5 - 1.0  # Normalize images to the range [-1, 1]
 train_images = np.expand_dims(train_images, axis=-1)
 
 # Train the GAN
 train_gan(generator, discriminator, gan, train_images, latent_dim, epochs=100, batch_size=64)
 
 # Generate and plot synthetic data
 generate_and_plot(generator, latent_dim)