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