transforms.Resize(IMAGE_SIZE),
transforms.ToTensor(),
transforms.Normalize(
[0.5 for _ in range(CHANNELS_IMG)], [0.5 for _ in range(CHANNELS_IMG)]
),
]
)
# If you train on MNIST, remember to set channels_img to 1
# dataset = datasets.MNIST(root="dataset/", train=True, transform=transforms, download=True)
# uncomment mnist above and comment below if train on MNIST
dataset = datasets.ImageFolder(root="dataset", transform=transforms)
dataloader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)
gen = Generator(NOISE_DIM, CHANNELS_IMG, FEATURES_GEN).to(device)
disc = Discriminator(CHANNELS_IMG, FEATURES_DISC).to(device)
initialize_weights(gen)
initialize_weights(disc)
opt_gen = optim.Adam(gen.parameters(), lr=LEARNING_RATE, betas=(0.5, 0.999))
opt_disc = optim.Adam(disc.parameters(), lr=LEARNING_RATE, betas=(0.5, 0.999))
criterion = nn.BCELoss()
fixed_noise = torch.randn(32, NOISE_DIM, 1, 1).to(device)
writer_real = SummaryWriter(f"logs/real")
writer_fake = SummaryWriter(f"logs/fake")
step = 0
gen.train()
disc.train()
def train():
"""Train DCGAN and save the generator and discrinator."""
torch.manual_seed(1)
epochs = 200
z_dim = 100
batch_size = 128
lr = 0.0002
beta_1 = 0.5
beta_2 = 0.999
criterion = nn.BCEWithLogitsLoss()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
transform = transforms.Compose([
transforms.Resize(64),
transforms.ToTensor(),
# transforms.Normalize([0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261])
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), #seems to work better
])
dataset = datasets.ImageFolder(os.path.join(DATA_DIR, "train"), transform)
dataloader = DataLoader(dataset, batch_size, shuffle=True, num_workers=4, drop_last=True)
# initialize generator and discriminator
gen = Generator(z_dim).to(device)
gen_optimizer = torch.optim.Adam(gen.parameters(), lr=lr, betas=(beta_1, beta_2))
disc = Discriminator().to(device)
disc_optimizer = torch.optim.Adam(disc.parameters(), lr=lr, betas=(beta_1, beta_2))
gen = gen.apply(weights_init)
disc = disc.apply(weights_init)
# to show generated image examples and improvement over training
fixed_noise = torch.randn(64, z_dim, device=device)
for epoch in range(epochs):
print("Epoch: ", epoch + 1, end='\n')
total_discriminator_loss = 0
total_generator_loss = 0
display_fake = None
for i, (real, _) in enumerate(dataloader):
real = real.to(device)
# UPDATE DISCRIMINATOR
disc_optimizer.zero_grad()
noise = torch.randn(batch_size, z_dim, device=device)
fake = gen(noise)
# discriminator predictions on generated images
disc_fake_pred = disc(fake.detach())
disc_fake_loss = criterion(disc_fake_pred, torch.zeros_like(disc_fake_pred))
disc_fake_loss.backward(retain_graph=True)
# discriminator predictions on real images
disc_real_pred = disc(real)
disc_real_loss = criterion(disc_real_pred, torch.ones_like(disc_real_pred))
disc_real_loss.backward(retain_graph=True)
disc_loss = disc_fake_loss + disc_real_loss
total_discriminator_loss += disc_loss.item()
# if i % 5 == 0:
disc_optimizer.step()
# UPDATE GENERATOR
gen_optimizer.zero_grad()
noise = torch.randn(batch_size, z_dim, device=device)
fake = gen(noise)
display_fake = fake
disc_fake_pred = disc(fake) # Notice no detach
gen_loss = criterion(disc_fake_pred, torch.ones_like(disc_fake_pred))
gen_loss.backward()
gen_optimizer.step()
total_generator_loss += gen_loss.item()
print('Discriminator Loss: {:.4f} \t Generator Loss: {:.4f} \t Done: {:.4f}'.format(total_discriminator_loss/(i+1),
total_generator_loss/(i+1), i/len(dataloader)), end='\r')
if (epoch + 1) % 5 == 0:
fixed_output = gen(fixed_noise)
show_tensor_images(fixed_output, id_num=epoch)
torch.save(gen.state_dict, "saved_gen/gen_{}.pth".format(epoch))
elif (epoch + 1) % 5 == 1:
show_tensor_images(display_fake, id_num=epoch)
mnist_train = torchvision.datasets.MNIST('./MNIST_data',
train=True,
download=True,
transform=transform)
train_loader = torch.utils.data.DataLoader(mnist_train,
batch_size=batch_size,
shuffle=True)
# mnist_test = torchvision.datasets.EMNIST('./EMNIST_data', train=False, download=True, transform=transform, split="letters")
# mnist_test = torchvision.datasets.EMNIST('./EMNIST_data', train=False, download=True, transform=transform, split="letters")
# test_loader = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=True)
pretrained_generator = ConditionalGenerator()
pretrained_generator.load_state_dict(torch.load(pretrained_generator_filepath))
generator = Generator()
discriminator = Discriminator()
pretrained_discriminator = Discriminator()
pretrained_discriminator.load_state_dict(
torch.load(pretrained_discriminator_filepath))
generator.deconv1 = pretrained_generator.input_layer1
# generator.deconv1.requires_grad = False
generator.deconv2 = pretrained_generator.input_layer2
# generator.deconv2.requires_grad = False
if __name__ == "__main__":
d_filename = "testD"
g_filename = "testG"
filename = "control"
filenames = []
num_epochs = 10
plt.figure(figsize=(8, 8))
plt.axis("off")
plt.title("Training Images")
plt.imshow(
np.transpose(
vutils.make_grid(real_batch[0].to(device)[:64],
padding=2,
normalize=True).cpu(), (1, 2, 0)))
plt.savefig(os.path.join(args.save_img, 'training_images.png'))
# Loss function
criterion = torch.nn.BCELoss()
# Initialize generator and discriminator
netG = Generator(nc, nz, ngf, ndf, ngpu).to(device)
netD = Discriminator(nc, nz, ngf, ndf, ngpu).to(device)
print(netD)
# Handle multi-gpu if desired
if (device.type == 'cuda') and (ngpu > 1):
netG = nn.DataParallel(netG, list(range(ngpu)))
netD = nn.DataParallel(netD, list(range(ngpu)))
# Apply the weights_init function to randomly initialize all weights to mean=0, stdev=0.2
netG.apply(weights_init)
netD.apply(weights_init)
# Print the model
print(netG)
print(netD)
nc = CFG.nc
nz = CFG.nz
ngf = CFG.ngf
ndf = CFG.ndf
ngpu = CFG.ngpu
img_size = CFG.image_size
# make output folder
os.makedirs(args.save_img, exist_ok=True)
# Decide which device we want to run on
device = torch.device("cuda:0" if (torch.cuda.is_available() and ngpu > 0) else "cpu")
# Initialize generator and discriminator
netG = Generator(nc, nz, ngf, ndf, ngpu).to(device)
netD = Discriminator(nc, nz, ngf, ndf, ngpu).to(device)
# Handle multi-gpu if desired
if (device.type == 'cuda') and (ngpu > 1):
netG = nn.DataParallel(netG, list(range(ngpu)))
netD = nn.DataParallel(netD, list(range(ngpu)))
# Print the model
print(netG)
print(netD)
# Load the model
checkpoint = torch.load(args.checkpoint)
netG.load_state_dict(checkpoint['state_dict'][0])
netD.load_state_dict(checkpoint['state_dict'][1])
netG.eval()
transforms.Resize(image_size),
transforms.ToTensor(),
transforms.Normalize((0.5, ), (0.5, ))
])
dataset = torchvision.datasets.MNIST(root='dataset/',
train=True,
transform=transform,
download=True)
dataloader = DataLoader(dataset=dataset, shuffle=True, batch_size=batch_size)
# GPU or CPU
device = 'cuda' if torch.cuda.is_available() else 'cpu'
# Model Initialization
netD = Discriminator(channels_img, features_d).train(mode=True).to(device)
netG = Generator(channels_noise, channels_img,
features_g).train(mode=True).to(device)
# Optimizers
optimizerD = optim.Adam(netD.parameters(),
lr=learning_rate,
betas=(0.5, 0.999))
optimizerG = optim.Adam(netG.parameters(),
lr=learning_rate,
betas=(0.5, 0.999))
# Loss
criterion = nn.BCELoss()
# Tensorboard init