def train(g_model,
d_model,
gan_model,
dataset,
latent_dim,
cat,
epochs=100,
batch=64):
batch_per_epoch = int(dataset.shape[0] / batch)
steps = batch_per_epoch * epochs
half_batch = int(batch / 2)
for i in range(steps):
X_real, y_real = generate_real_samples(dataset, half_batch)
d_loss1 = d_model.train_on_batch(X_real, y_real)
X_fake, y_fake = generate_fake_samples(g_model, latent_dim, cat,
half_batch)
d_loss2 = d_model.train_on_batch(X_fake, y_fake)
z_input, cat_codes = generate_latent_points(latent_dim, cat, batch)
y_gan = np.ones((batch, 1))
_, g_1, g_2 = gan_model.train_on_batch(z_input, [y_gan, cat_codes])
print("[INFO] {:d}, d[{:.3f}, {:.3f}], g[{:.3f}], q[{:.3f}]".format(
i + 1, d_loss1, d_loss2, g_1, g_2))
if (i + 1) % (batch_per_epoch * 10) == 0:
summarize_performance(i, g_model, gan_model, latent_dim, cat)
def train(generator,
discriminator,
gan,
dataset,
latent_dim,
epochs=100,
batch=128):
batch_per_epoch = int(dataset.shape[0] / batch)
half_batch = int(batch / 2)
for i in range(epochs):
for j in range(batch_per_epoch):
X_real, y_real = generate_real_samples(dataset, half_batch)
d_loss1, _ = discriminator.train_on_batch(X_real, y_real)
X_fake, y_fake = generate_fake_samples(generator, latent_dim,
half_batch)
d_loss2, _ = discriminator.train_on_batch(X_fake, y_fake)
Xgan = generate_latent_points(latent_dim, batch)
ygan = np.ones((batch, 1))
g_loss = gan.train_on_batch(Xgan, ygan)
print("{:d}, {:d}/{:d}, d1={:.3f}, d2={:.3f}, g={:.3f}".format(
i + 1, j + 1, batch_per_epoch, d_loss1, d_loss2, g_loss))
generator.save("models/generator.h5")
def train(g_model, d_model, gan_model, dataset, latent_dim, n_epochs=10,
n_batch=64):
# calculate number of batches per epoch
batch_per_epoch = int(dataset.shape[0] / n_batch)
# no of training iterations
n_steps = batch_per_epoch * n_epochs
# half-batch
half_batch = n_batch // 2
# empty lists to store loss
d1_hist, d2_hist, g_hist = list(), list(), list()
# training loop
for i in range(n_steps):
# generate real and fake samples
X_real, y_real = generate_mnist_samples(dataset, half_batch)
X_fake, y_fake = generate_fake_samples(g_model, latent_dim, half_batch)
# update discriminator
d_loss1 = d_model.train_on_batch(X_real, y_real)
d_loss2 = d_model.train_on_batch(X_fake, y_fake)
# update generator
z_input = generate_latent_points(latent_dim, n_batch)
y_real2 = np.ones((n_batch, 1))
g_loss = gan_model.train_on_batch(z_input, y_real2)
#
print(">%d, d1=%.3f, d2=%.3f, g=%.3f" % (i+1, d_loss1, d_loss2, g_loss))
# record
d1_hist.append(d_loss1)
d2_hist.append(d_loss2)
g_hist.append(g_loss)
# evaluate
if (i+1) % (batch_per_epoch * 1) == 0:
log_performance(i, g_model, latent_dim)
# plot
plot_history(d1_hist, d2_hist, g_hist)
def train(dataset, generator, discriminator, gan_model, latent_dim=100, n_epochs=20, n_batch=25):
bat_per_epo = int(dataset.shape[0] / n_batch)
half_batch = int(n_batch / 2)
for i in range(n_epochs):
# enumerate batches over the training set
for j in range(bat_per_epo):
start_time = time.time()
# get randomly selected 'real' samples
X_real, y_real = utils.generate_real_samples(dataset, half_batch)
# update discriminator model weights
d_loss1, _ = discriminator.train_on_batch(X_real, y_real)
# generate 'fake' examples
X_fake, y_fake = utils.generate_fake_samples(generator, latent_dim, half_batch)
# update discriminator model weights
d_loss2, _ = discriminator.train_on_batch(X_fake, y_fake)
# prepare points in latent space as input for the generator
X_gan = utils.generate_latent_points(latent_dim, n_batch)
# create inverted labels for the fake samples
y_gan = tf.ones((n_batch, 1))
# update the generator via the discriminator's error
g_loss = gan_model.train_on_batch(X_gan, y_gan)
# summarize loss on this batch
time_taken = time.time() - start_time
print('>%d, %d/%d, d1=%.3f, d2=%.3f g=%.3f Time Taken:%.2f seconds' %
(i + 1, j + 1, bat_per_epo, d_loss1, d_loss2, g_loss, time_taken))
# evaluate the model performance, sometimes
if (i + 1) % 10 == 0:
summarize_performance(i, generator, discriminator, dataset, latent_dim)
def train(g_model,
d_model,
gan_model,
dataset,
latent_dim,
epochs=20,
batch=64):
batch_per_epoch = int(dataset.shape[0] / batch)
steps = batch_per_epoch * epochs
half_batch = int(batch / 2)
d1_hist, d2_hist, g_hist = list(), list(), list()
for i in range(steps):
X_real, y_real = generate_real_samples(dataset, half_batch)
X_fake, y_fake = generate_fake_samples(g_model, latent_dim, half_batch)
# update discriminator model
d_loss1 = d_model.train_on_batch(X_real, y_real)
d_loss2 = d_model.train_on_batch(X_fake, y_fake)
# update generator via discriminator's loss
z_input = generate_latent_points(latent_dim, batch)
y_real2 = np.ones((batch, 1))
g_loss = gan_model.train_on_batch(z_input, y_real2)
print("{:d}, d1={:.3f}, d2={:.3f}, g={:.3f}".format(
i + 1, d_loss1, d_loss2, g_loss))
d1_hist.append(d_loss1)
d2_hist.append(d_loss2)
g_hist.append(g_loss)
if (i + 1) % (batch_per_epoch * 1) == 0:
summarize_performance(i, g_model, latent_dim)
plot_history(d1_hist, d2_hist, g_hist)
def train_step(images):
noise, categorical_input, continuous_input = generate_latent_points(
BATCH_SIZE, noise_dim, categorical_dim, continuous_dim)
with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
generated_images = generator(noise, training=True)
real_output = discriminator(images, training=True)
fake_output = discriminator(generated_images, training=True)
disc_loss, real_loss, fake_loss, categorical_loss, continuous_loss = discriminator_loss(
real_output, fake_output, categorical_input, continuous_input)
gen_loss = generator_loss(fake_output, categorical_loss,
continuous_loss)
discriminator_loss_metric(disc_loss)
generator_loss_metric(gen_loss)
discriminator_real_accuracy_metric(tf.ones_like(real_output[:, 0]),
real_output[:, 0])
discriminator_fake_accuracy_metric(tf.zeros_like(fake_output[:, 0]),
fake_output[:, 0])
categorical_loss_metric(categorical_loss)
continuous_loss_metric(continuous_loss)
print(
f"Losses - Disc : [{disc_loss}], Gen : [{gen_loss}], \n categorical loss : {categorical_loss}, continuous loss : {continuous_loss}"
)
gradients_of_generator = gen_tape.gradient(gen_loss,
generator.trainable_variables)
gradients_of_discriminator = disc_tape.gradient(
disc_loss, discriminator.trainable_variables)
generator_optimizer.apply_gradients(
zip(gradients_of_generator, generator.trainable_variables))
discriminator_optimizer.apply_gradients(
zip(gradients_of_discriminator, discriminator.trainable_variables))
def train_gan(sw, n_class, dataloader):
d_model, d_optim, d_lrdecay = define_discriminator()
g_model, g_optim, g_lrdecay = define_generator()
# d_model, d_optim = define_discriminator()
# g_model, g_optim = define_generator()
criterion = nn.BCELoss()
G_losses = []
D_losses = []
global best_fid
best_fid = np.inf
for epoch in range(EPOCHS):
D_x, D_G_z1, D_G_z2 = [], [], []
errD, errG = torch.tensor(0), torch.tensor(0)
mode_loss = 0
for _, data in enumerate(dataloader):
############################
# (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))
###########################
## Train with all-real batch
d_model.zero_grad()
# Format batch
real_images = data[0].to(DEVICE)
mini_batch_size = real_images.size(0)
label = torch.full((mini_batch_size, ),
REAL_LABEL,
dtype=torch.float,
device=DEVICE)
# Forward pass real batch through D
output = d_model(real_images).view(-1)
# Calculate loss on all-real batch
errD_real = criterion(output, label)
# Calculate gradients for D in backward pass
errD_real.backward()
D_x.append(output.mean().item())
## Train with all-fake batch
# Generate batch of latent vectors
noise = generate_latent_points(LATENT_DIM, mini_batch_size, DEVICE)
# Generate fake image batch with G
fake = g_model(noise)
label.fill_(FAKE_LABEL)
# Classify all fake batch with D
output = d_model(fake.detach()).view(-1)
# Calculate D's loss on the all-fake batch
errD_fake = criterion(output, label)
# Calculate the gradients for this batch
errD_fake.backward()
D_G_z1.append(output.mean().item())
# Add the gradients from the all-real and all-fake batches
errD = errD_real + errD_fake
# Update D
d_optim.step()
############################
# (2) Update G network: maximize log(D(G(z)))
###########################
g_model.zero_grad()
# Format batch
mini_batch_size = mini_batch_size * 2
label = torch.full((mini_batch_size, ),
REAL_LABEL,
dtype=torch.float,
device=DEVICE)
# Generate batch of latent vectors
noise = generate_latent_points(LATENT_DIM, mini_batch_size, DEVICE)
# Generate fake image batch with G
fake = g_model(noise)
# Since we just updated D, perform another forward pass of all-fake batch through D
output = d_model(fake).view(-1)
# Calculate mode seeking loss
z1, z2, *_ = torch.split(noise, noise.size(0) // 2)
f1, f2, *_ = torch.split(fake, fake.size(0) // 2)
mode_loss = torch.mean(torch.abs(f2 - f1)) / torch.mean(
torch.abs(z2 - z1))
mode_loss = 1 / (mode_loss + 1e-5)
# Calculate G's loss based on this output
errG = criterion(output, label) + (5 * mode_loss)
loss_G = errG + mode_loss
# Calculate gradients for G
loss_G.backward()
D_G_z2.append(output.mean().item())
# Update G
g_optim.step()
# Learning rate decay
d_lrdecay.step()
g_lrdecay.step()
# Calculate the mean
D_x = np.mean(D_x)
D_G_z1 = np.mean(D_G_z1)
D_G_z2 = np.mean(D_G_z2)
# Output training stats
LOGGER.write(
'[%d/%d]\tLoss_D: %.4f\tLoss_G: %.4f\tD(x): %.4f\tD(G(z)): %.4f / %.4f'
%
(epoch + 1, EPOCHS, errD.item(), errG.item(), D_x, D_G_z1, D_G_z2))
# Save Losses for plotting later
G_losses.append(errG.item())
D_losses.append(errD.item())
# Check how the generator is doing by saving G's output on fixed_noise
if epoch % 50 == 0:
summarize_performance(
epoch,
sw,
n_class,
errD.item(),
errG.item(),
mode_loss,
D_x,
D_G_z1,
g_lrdecay.get_last_lr()[-1],
d_lrdecay.get_last_lr()[-1],
# LR, LR,
generate_test(g_model))
# generate fake samples
fake_images = g_model(FIXED_NOISE_2)
# saving space in the gpu for loading inception v3
g_model = g_model.to(torch.device('cpu'))
d_model = d_model.to(torch.device('cpu'))
#if epoch % 50 == 0:
calculate_fid(fake_images, sw, epoch, n_class)
calculate_target_acc(fake_images, sw, epoch, n_class)
# put models back on GPU
g_model = g_model.to(DEVICE)
d_model = d_model.to(DEVICE)
#if fid < best_fid:
# best_fid = fid
#
# torch.save(g_model, f'models/gan/g_exp{EXPERIMENT_ID}_class{n_class}.pth')
# torch.save(d_model, f'models/gan/d_exp{EXPERIMENT_ID}_class{n_class}.pth')
torch.save(g_model, f'models/gan/g_exp{EXPERIMENT_ID}_class{n_class}.pth')
torch.save(d_model, f'models/gan/d_exp{EXPERIMENT_ID}_class{n_class}.pth')
DEVICE = torch.device('cuda' if torch.cuda.is_available else 'cpu')
# Parameters
DATAROOT = 'data/vgg16/dataset_ii_sl/'
WORKERS = 4
BATCH_SIZE = 16
IMAGE_SIZE = 32
LATENT_DIM = 100
LR = 0.0005
EPOCHS = 1500
D_LR_DECAY = 0.999
G_LR_DECAY = 0.999
TARGET_FID = read_stats_file('logs/cifar10_fid.npz')
DATASET_FID = read_stats_file('logs/dataset_i_sl_fid.npz')
FIXED_NOISE = generate_latent_points(LATENT_DIM, 20, DEVICE)
FIXED_NOISE_2 = generate_latent_points(LATENT_DIM, 500, DEVICE)
REAL_LABEL = 1
FAKE_LABEL = 0
LOGGER.write(f'#### Experiment {EXPERIMENT_ID} ####')
LOGGER.write(f'Date: {datetime.now().strftime("%Y%m%d_%H-%M")}')
LOGGER.write('\nHiperparametros')
LOGGER.write(f'> Epochs: {EPOCHS}')
LOGGER.write(f'> Learning Rate: {LR}')
LOGGER.write(f'> Image Size: {IMAGE_SIZE}')
LOGGER.write(f'> Image Size: {IMAGE_SIZE}')
LOGGER.write(f'> Batch Size: {BATCH_SIZE}')
LOGGER.write(f'> Latent Dimension: {LATENT_DIM}')
LOGGER.write(f'> Device: {DEVICE}')
ap.add_argument("-s",
"--samples",
type=int,
help="Number of samples to generate")
ap.add_argument("-d",
"--digit",
type=int,
help="Category control code to generate specific digit.")
args = vars(ap.parse_args())
print(args)
model = load_model(args["model"])
model.summary()
cat = 10
# Use same latent dim as during training
latent_dim = 62
# Number of samples to plot
samples = args["samples"]
if args["digit"] is None:
z_input, _ = generate_latent_points(latent_dim, cat, samples)
else:
z_input, _ = generate_latent_points_with_digit(latent_dim, cat, samples,
args["digit"])
X = model.predict(z_input)
# scale from [-1,1] to [0,1]
X = (X + 1) / 2.0
create_plot(X, samples)
from utils import generate_latent_points
from utils import show_plot
from keras.models import load_model
model = load_model("models/generator.h5")
latent_points = generate_latent_points(100, 100)
X = model.predict(latent_points)
show_plot(X, 10)
lr = tf.train.exponential_decay(config.INIT_LR, model.global_step, 1000, config.DECAY_RATE, staircase=True)
with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='discriminator')):
train_D = tf.train.AdamOptimizer(0.0002, beta1=0.5).minimize(model.loss_D, var_list=model.vars_D)
with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='generator')):
train_G = tf.train.AdamOptimizer(0.0002, beta1=0.5).minimize(model.loss_G, global_step=model.global_step, var_list=model.vars_G)
sess_config = tf.ConfigProto(gpu_options=tf.GPUOptions(allow_growth=True))
images, labels = read_images(config.PATH_DATA, "folder")
num_iters = len(images) // config.BATCH_SIZE
cnt = 0
length = 6
sample_noise = utils.generate_latent_points(config.LATENT_DIM, length*length)
with tf.Session(config=sess_config) as sess:
saver = tf.train.Saver(tf.global_variables(), max_to_keep=1000)
summary_op = tf.summary.merge_all()
init = tf.global_variables_initializer()
sess.run(init)
train_writer = tf.summary.FileWriter(config.PATH_TENSORBOARD, sess.graph)
# Load a previous checkpoint if desired
#model_checkpoint_name = config.PATH_CHECKPOINT + "/latest_model_" + config.PATH_DATA + ".ckpt"
model_checkpoint_name = config.PATH_CHECKPOINT + "/model.ckpt"
if config.IS_CONTINUE:
print('Loaded latest model checkpoint')
saver.restore(sess, model_checkpoint_name)
def train_gan(gan_model, latent_dim, n_epochs=20, n_batch=25):
for i in range(n_epochs):
x_gan = utils.generate_latent_points(latent_dim, n_batch)
y_gan = tf.ones((n_batch, 1))
gan_model.train_on_batch(x_gan, y_gan)
sess.run(init)
train_writer = tf.summary.FileWriter(config.PATH_TENSORBOARD, sess.graph)
# Load a previous checkpoint if desired
model_checkpoint_name = config.PATH_CHECKPOINT + "/latest_model_" + config.PATH_DATA + ".ckpt"
if config.IS_CONTINUE:
print('Loaded latest model checkpoint')
saver.restore(sess, model_checkpoint_name)
images, labels = read_images("data", "folder")
#num_iters = int(np.floor(len(D.train) / config.BATCH_SIZE))
num_iters = int(np.floor(len(images) / config.BATCH_SIZE))
length = 7
valid_set = utils.generate_latent_points(100, length**2)
valid_image = []
for i in range(length**2):
valid_image.append(images[i])
for epoch in range(config.EPOCH):
cnt = 0
st = time.time()
epoch_st = time.time()
#id_list = np.random.permutation(len(D.train))
for i in range(num_iters):
image_batch = []
noise_batch = utils.generate_latent_points(100, config.BATCH_SIZE)
#noise_batch = np.random.uniform(-1., 1., size=[config.BATCH_SIZE, 100])
LOGGER.write(f'#### Experiment {EXPERIMENT_ID} ####')
LOGGER.write(f'Date: {datetime.now().strftime("%d/%m/%Y %H:%M")}')
LOGGER.write('\nHiperparametros')
LOGGER.write(f'> Classes: {CLASSES}')
LOGGER.write(f'> Training Size: {TRAINING_SIZE}*{MULTIPLIER_TRAINING_SIZE}')
LOGGER.write(f'> Device: {DEVICE}')
for n in np.arange(CLASSES):
LOGGER.write(f"\nLoading generator from class {n}")
g_model = torch.load(f'models/gan/g_exp{EXPERIMENT_ID}_class{n}.pth')
LOGGER.write(f"Generating images from class {n}")
output_path = os.path.join(FAKESET, str(n))
LOGGER.write(f'> Output path: {output_path}')
if not os.path.exists(output_path):
os.mkdir(output_path)
for i in tqdm(np.arange(MULTIPLIER_TRAINING_SIZE)):
X = generate_latent_points(100, TRAINING_SIZE, DEVICE)
generated = g_model(X)
for id, image in enumerate(generated):
new_id = (TRAINING_SIZE * i) + id
save_image(
(image + 1) / 2, # normalize into [0, 1]
fp=os.path.join(output_path, f"{new_id}.png"))
os.makedirs(f"{args.outdir}/assets/{args.dataset}")
#normalizing the images
train_images = (train_images - 127.5) / 127.5
##### DEFINE GLOBAL VARIABLES AND OBJECTS ######
BUFFER_SIZE = 600000
BATCH_SIZE = args.batch_size
epochs = args.epochs
noise_dim = args.noise_dim
continuous_dim = 2
categorical_dim = 10
num_examples_to_generate = 100
continuous_weight = args.continuous_weight
seed, _, _ = generate_latent_points(
num_examples_to_generate, noise_dim, categorical_dim, continuous_dim
) # A constant sample of latent points so as to create images
# Define Generator
generator = make_generator_model(noise_dim)
print("\nGenerator : ")
print(generator.summary())
discriminator = make_discriminator_model()
print("\nDiscriminator : ")
print(discriminator.summary())
print("Dataset : ", args.dataset)
###########################################
# Converting data to tf Dataset
train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(
