I wanted to make WGAN-gp generating samples of Mixture of gaussian model. So I sampled from Mixture of gaussian model like this:
import torch
import torch.distributions as D
import numpy as np
import matplotlib.pyplot as plt
import torch.utils.data as data
import torch.nn as nn
def samplling_from_MOG(n_sample,pi,mu,std):
uni = D.Uniform(0,1)
loc = uni.sample(sample_shape = [n_sample])
n_each_gau_sample = []
sum_pi = 0
for i in range(len(pi)):
if i == 0:
n_each_gau_sample.append(len(loc[loc<=pi[i]]))
elif i == len(pi)-1:
n_each_gau_sample.append(n_sample-sum(n_each_gau_sample))
else:
n_each_gau_sample.append(len(loc[(loc>sum_pi)&(loc<=(pi[i]+sum_pi))]))
sum_pi += pi[i]
sample_data = np.array([])
for i in range(len(mu)):
Gau = D.Normal(torch.tensor([mu[i]]), torch.tensor([std[i]]))
sample_data = np.concatenate((sample_data, Gau.sample(sample_shape = [n_each_gau_sample[i]]).numpy()), axis=None)
return sample_data
sampled_data = samplling_from_MOG(10000,[0.1,0.5,0.4],[1.0,2.0,5.0],[0.2,0.2,1])
plt.hist(sampled_data,bins=100,density=True)
plt.show()
and this is sample result : enter image description here and below is my WGAN-gp model
class BasicDataset(data.Dataset):
def __init__(self, x_tensor):
super(BasicDataset, self).__init__()
self.x = x_tensor
def __getitem__(self, index):
return self.x[index]
def __len__(self):
return len(self.x)
tr_dataset = BasicDataset(sampled_data)
data_loader = data.DataLoader(dataset=tr_dataset, batch_size=32, shuffle=True)
class Generator(nn.Module):
def __init__(self,latent_dim):
super(Generator, self).__init__()
self.fc1 = nn.Linear(latent_dim, 400)
self.bn1 = torch.nn.BatchNorm1d(400)
self.fc2 = nn.Linear(400, 300)
self.bn2 = torch.nn.BatchNorm1d(300)
self.fc3 = nn.Linear(300, 1)
def forward(self, z):
L1 = torch.relu(self.fc1(z))
L1 = self.bn1(L1)
L2 = torch.relu(self.fc2(L1))
L2 = self.bn2(L2)
output = self.fc3(L2)
return output
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
self.fc1 = nn.Linear(1, 256)
self.fc2 = nn.Linear(256, 256)
self.fc3 = nn.Linear(256, 1)
def forward(self, z):
L1 = torch.relu(self.fc1(z))
L2 = torch.relu(self.fc2(L1))
output = self.fc3(L2)
return output
def compute_gradient_penalty(D, real_samples, fake_samples):
"""Calculates the gradient penalty loss for WGAN GP"""
# Random weight term for interpolation between real and fake samples
alpha = torch.tensor(np.random.random((real_samples.size(0), 1)))
# Get random interpolation between real and fake samples
interpolates = (alpha * real_samples + ((1 - alpha) * fake_samples)).requires_grad_(True).float()
d_interpolates = D(interpolates)
fake = torch.empty(d_interpolates.shape[0], 1, dtype=torch.float)
fake.fill_(1.0)
fake.requires_grad=False
# Get gradient w.r.t. interpolates
gradients = torch.autograd.grad(
outputs=d_interpolates,
inputs=interpolates,
grad_outputs=fake,
create_graph=True,
retain_graph=True,
only_inputs=True,
)[0]
gradients = gradients.view(gradients.size(0), -1)
gradient_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean()
return gradient_penalty
training code
# Loss weight for gradient penalty
lambda_gp = 1
latent_dim = 100
lr = 0.0002
# Initialize generator and discriminator
generator = Generator(latent_dim)
discriminator = Discriminator()
optimizer_G = torch.optim.Adam(generator.parameters(), lr=lr)
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=lr)
n_epochs = 100
for epoch in range(n_epochs):
for i, real_data in enumerate(data_loader):
# Configure input
real_data = torch.tensor(real_data).unsqueeze(dim=1).float()
# ---------------------
# Train Discriminator
# ---------------------
optimizer_D.zero_grad()
# Sample noise as generator input
z = torch.tensor(np.random.normal(0, 1, (real_data.shape[0], latent_dim))).float()
# Generate a batch of images
fake_data = generator(z)
# Real images
real_validity = discriminator(real_data)
# Fake images
fake_validity = discriminator(fake_data)
# Gradient penalty
gradient_penalty = compute_gradient_penalty(discriminator, real_data, fake_data)
# Adversarial loss
d_loss = -torch.mean(real_validity) + torch.mean(fake_validity) + lambda_gp * gradient_penalty
d_loss.backward()
optimizer_D.step()
optimizer_G.zero_grad()
# Train the generator every n_critic steps
if i % 5 == 0:
# -----------------
# Train Generator
# -----------------
# Generate a batch of images
fake_data = generator(z)
# Loss measures generator's ability to fool the discriminator
# Train on fake images
fake_validity = discriminator(fake_data)
g_loss = -torch.mean(fake_validity)
g_loss.backward()
optimizer_G.step()
print(
"[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f]"
% (epoch, n_epochs, i, len(data_loader), d_loss.item(), g_loss.item())
)
result plot code
# Sample noise as generator input
z = torch.tensor(np.random.normal(0, 1, (10000, latent_dim))).float()
# Generate a batch of images
fake_data = generator(z)
plt.hist(fake_data.detach().numpy(),bins=100,density=True)
plt.show()
this is my generator result enter image description here but my result is bad… I don’t know what is wrong. Please help me.
