def __init__(self): # load images and scale in range (-1, 1) self.images_loader = utils.load_images('datasets/patterns/') # dataset = datasets.CIFAR10(root='./cifar10', train=True, download=True, transform=transform) # dataloader = DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=20, drop_last=True) # Define the network self.generator = utils.load_network('generator', dcgan.Generator()) self.discriminator = utils.load_network('discriminator', dcgan.Discriminator()) # print total and trainable parameters for networks utils.print_parameters(self.generator, 'Generator') utils.print_parameters(self.discriminator, 'Discriminator') self.adversarial_loss = torch.nn.BCELoss().cuda( ) if cuda else torch.nn.BCELoss() # set up optimisers self.optimizer_D = torch.optim.RMSprop(self.discriminator.parameters(), lr=args.lr_d) self.optimizer_G = torch.optim.RMSprop(self.generator.parameters(), lr=args.lr_g) # set up LR schedulers self.scheduler_D = StepLR(self.optimizer_D, step_size=args.lr_step, gamma=args.lr_gamma) self.scheduler_G = StepLR(self.optimizer_G, step_size=args.lr_step, gamma=args.lr_gamma) # create latent vectors to visualize the progression of the generator self.fixed_noise = Variable( Tensor( np.random.normal(0, args.s_sd, (args.batch_size, args.latent_dim))))
def generate(noise): #generator model G = dcgan.Generator(fc_shapes=(7, 7, 256), num_conv=3, filters=(128, 64, 1), kernel_sizes=(5, 5, 5), strides=(1, 2, 2), activations=(tf.nn.leaky_relu, tf.nn.leaky_relu, tf.nn.tanh)) checkpoint = tf.train.Checkpoint(G=G) checkpoint.restore(CHECK_POINTS_PATH) #generate fake_images = G(noise, training=False) fig = plt.figure(figsize=(4, 4)) for i in range(fake_images.shape[0]): plt.subplot(4, 4, i + 1) plt.imshow(fake_images[i, :, :, 0] * 127.5 + 127.5, cmap='gray') plt.axis('off') plt.savefig('image_at_epoch_{:04d}.png'.format(epoch))
def train(): #trans dataset to distribute dataset with strategy.scope(): train_dist_dataset = strategy.experimental_distribute_dataset( train_dataset) #test_dist_dataset=strategy.experimental_distribute_dataset(test_dataset) #define loss with strategy.scope(): BinaryEntropy = tf.keras.losses.BinaryCrossentropy( from_logits=True, reduction=tf.keras.losses.Reduction.NONE) #generator loss def g_loss(fake_logits): ''' ''' losses = BinaryEntropy(tf.ones_like(fake_logits), fake_logits) loss = tf.nn.compute_average_loss(per_example_loss=losses, global_batch_size=BATCH_SIZE) return loss #discriminator loss def d_loss(real_logits, fake_logits): ''' ''' real_losses = BinaryEntropy(tf.ones_like(real_logits), real_logits) fake_losses = BinaryEntropy(tf.zeros_like(fake_logits), fake_logits) losses = real_losses + fake_losses loss = tf.nn.compute_average_loss(per_example_loss=losses, global_batch_size=BATCH_SIZE) return loss #define metrics # with strategy.scope(): # train_accuracy=tf.keras.metrics.SparseCategoricalAccuracy(name="train_loss") # model and optimizer must be created under `strategy.scope`. with strategy.scope(): #generator model G = dcgan.Generator(fc_shapes=(7, 7, 256), num_conv=3, filters=(128, 64, 1), kernel_sizes=(5, 5, 5), strides=(1, 2, 2), activations=(tf.nn.leaky_relu, tf.nn.leaky_relu, tf.nn.tanh)) G_optimizer = tf.keras.optimizers.Adam(1e-4) #discriminator model D = dcgan.Discriminator(num_conv=2, filters=(64, 128), kernel_sizes=(5, 5), strides=(2, 2), activations=(tf.nn.leaky_relu, tf.nn.leaky_relu)) D_optimizer = tf.keras.optimizers.Adam(1e-4) #checkpoints checkpoint = tf.train.Checkpoint(G_optimizer=G_optimizer, D_optimizer=D_optimizer, G=G, D=D) #basic train step in one device with strategy.scope(): def train_step(inputs): x, y = inputs k = 5 #train generator for i in range(k): with tf.GradientTape() as g_tape: noise = tf.random.normal(shape=(BATCH_SIZE_PER_REPLICA, NOISE_DIM)) #noise to images fake_images = G(noise, training=True) #juege by discriminator real_logits = D(x, training=True) fake_logits = D(fake_images, training=True) #compute gen loss gen_loss = g_loss(fake_logits) #compute generatorgradients g_gradients = g_tape.gradient(gen_loss, G.trainable_variables) #apply gradients G_optimizer.apply_gradients(zip(g_gradients, G.trainable_variables)) with tf.GradientTape() as g_tape, tf.GradientTape() as d_tape: #noise to images fake_images = G(noise, training=True) #juege by discriminator real_logits = D(x, training=True) fake_logits = D(fake_images, training=True) #compute loss gen_loss = g_loss(fake_logits) disc_loss = d_loss(real_logits, fake_logits) #compute gradients g_gradients = g_tape.gradient(gen_loss, G.trainable_variables) d_gradients = d_tape.gradient(disc_loss, D.trainable_variables) #apply gradients G_optimizer.apply_gradients(zip(g_gradients, G.trainable_variables)) D_optimizer.apply_gradients(zip(d_gradients, D.trainable_variables)) return gen_loss, disc_loss #distribute train_step use basic train step with strategy.scope(): def dist_train_step(dataset_inputs): replica_gen_losses, replica_disc_losses = strategy.experimental_run_v2( fn=train_step, args=(dataset_inputs, )) #print("replica_losses:\n",replica_losses) reduce_gen_loss = strategy.reduce( reduce_op=tf.distribute.ReduceOp.SUM, value=replica_gen_losses, axis=None) reduce_disc_loss = strategy.reduce( reduce_op=tf.distribute.ReduceOp.SUM, value=replica_disc_losses, axis=None) return reduce_gen_loss, reduce_disc_loss for epoch in range(EPOCHS): print("-----------EPOCH:", epoch) epoch_gen_loss = 0.0 epoch_disc_loss = 0.0 num_batchs = 0 for records in train_dist_dataset: reduce_gen_loss, reduce_disc_loss = dist_train_step(records) epoch_gen_loss += reduce_gen_loss epoch_disc_loss += reduce_disc_loss num_batchs += 1 epoch_gen_loss = epoch_gen_loss / num_batchs epoch_disc_loss = epoch_disc_loss / num_batchs print("epoch_gen_loss:", epoch_gen_loss.numpy()) print("epoch_disc_loss:", epoch_disc_loss.numpy()) #save model checkpoint.save(CHECK_POINTS_PATH)
batch_size=opt.batchSize, shuffle=True, num_workers=int(opt.workers)) ######################### #### Models building #### ######################### device = torch.device("cuda:0" if opt.cuda else "cpu") ##device = torch.device("cpu") ngpu = int(opt.ngpu) nz = int(opt.nz) ngf = int(opt.ngf) ndf = int(opt.ndf) nc = 3 netG = inputmodel.Generator().to(device) netG.apply(inputmodel.weights_init) if opt.netG != '': netG.load_state_dict(torch.load(opt.netG)) print(netG) netD = inputmodel.Discriminator().to(device) netD.apply(inputmodel.weights_init) if opt.netD != '': netD.load_state_dict(torch.load(opt.netD)) print(netD) criterion = nn.BCELoss() Tensor = torch.FloatTensor z = Variable( Tensor(np.random.normal(0, 1, (opt.batchSize, opt.nz))).to(device))
#grid_show(fig, bx, xs.shape) bx = self.grid_transform(bx, xs.shape) imsave('logs/{}/{}.png'.format(self.data, t / 100), bx) #fig.savefig('logs/{}/{}.png'.format(self.data, t/100)) def grid_transform(self, x, size): a, b = split(x.shape[0]) h, w, c = size[0], size[1], size[2] x = np.reshape(x, [a, b, h, w, c]) x = np.transpose(x, [0, 2, 1, 3, 4]) x = np.reshape(x, [a * h, b * w, c]) if x.shape[2] == 1: x = np.squeeze(x, axis=2) return x if __name__ == '__main__': parser = argparse.ArgumentParser('') parser.add_argument('--data', type=str, default='mnist') parser.add_argument('--model', type=str, default='dcgan') parser.add_argument('--gpus', type=str, default='0') args = parser.parse_args() os.environ['CUDA_VISIBLE_DEVICES'] = args.gpus #data = importlib.import_module(args.data) #model = importlib.import_module(args.data + '.' + args.model) # xs = data.DataSampler() # zs = data.NoiseSampler() d_net = dcgan.Discriminator() g_net = dcgan.Generator() wgan = WassersteinGAN(g_net, d_net, args.data, args.model) wgan.train()
ngf = int(opt.ngf) ndf = int(opt.ndf) # custom weights initialization called on netG and netD def weights_init(m): classname = m.__class__.__name__ if classname.find('Conv') != -1: m.weight.data.normal_(0.0, 0.02) elif classname.find('BatchNorm') != -1: m.weight.data.normal_(1.0, 0.02) m.bias.data.fill_(0) netD = dcgan.Discriminator(ngpu, ndf=ndf).to(device) netD.apply(weights_init) netG = dcgan.Generator(ngpu, nz=nz, ngf=ngf).to(device) netG.apply(weights_init) lrD = [] lrG = [] lossD = [] lossG = [] load_state = "" starting_epoch = 0 if not opt.fresh and opt.loadstate == '': outf_files = os.listdir(opath) states = [of for of in outf_files if 'net_state_epoch_' in of] states.sort() if len(states) >= 1: load_state = os.path.join(opath, states[-1]) if os.path.isfile(load_state):