def check(fold, weights):
dataset = ClassificationDataset(fold=fold)
model = build_model_densenet_161()
model.load_weights(weights)
batch_size = 2
for x_batch, y_batch in dataset.generate(batch_size=batch_size):
print(y_batch)
predicted = model.predict_on_batch(x_batch)
print(predicted)
for i in range(batch_size):
plt.imshow(utils.preprocessed_input_to_img_resnet(x_batch[i]))
true_species = y_batch['cat_species'][i]
true_cover = y_batch['cat_cover'][i]
predicted_species = predicted[0][i]
predicted_cover = predicted[1][i]
for cls_id, cls in enumerate(SPECIES_CLASSES):
print('{:12} {:.02f} {:.02f}'.format(
cls, true_species[cls_id], predicted_species[cls_id]))
for cls_id, cls in enumerate(COVER_CLASSES):
print('{:12} {:.02f} {:.02f}'.format(cls, true_cover[cls_id],
predicted_cover[cls_id]))
print(SPECIES_CLASSES[np.argmax(y_batch['cat_species'][i])],
COVER_CLASSES[np.argmax(y_batch['cat_cover'][i])])
plt.show()
def check_dataset():
dataset = Dataset(update_cache=False)
for batch_x, batch_y in dataset.generate(batch_size=16):
print(batch_x.shape, batch_y.shape)
plt.imshow(unprocess_input(batch_x[0]))
plt.imshow(batch_y[0], alpha=0.2)
plt.show()
def train_unet(continue_from_epoch=-1, weights='', batch_size=8):
dataset = Dataset(update_cache=True)
model = model_unet(INPUT_SHAPE)
model.summary()
model_name = 'model_unet1'
checkpoints_dir = '../output/checkpoints/mask_unet/' + model_name
tensorboard_dir = '../output/tensorboard/mask_unet/' + model_name
os.makedirs(checkpoints_dir, exist_ok=True)
os.makedirs(tensorboard_dir, exist_ok=True)
if len(weights) > 0:
model.load_weights(weights)
checkpoint_best = ModelCheckpoint(
checkpoints_dir + "/checkpoint-best-{epoch:03d}-{val_loss:.4f}.hdf5",
verbose=1,
save_weights_only=False,
save_best_only=True)
checkpoint_periodical = ModelCheckpoint(
checkpoints_dir + "/checkpoint-{epoch:03d}-{val_loss:.4f}.hdf5",
verbose=1,
save_weights_only=True,
period=8)
tensorboard = TensorBoard(tensorboard_dir,
histogram_freq=0,
write_graph=False,
write_images=True)
def cheduler(epoch):
if epoch < 10:
return 1e-3
if epoch < 25:
return 2e-4
if epoch < 60:
return 1e-4
if epoch < 80:
return 5e-5
return 2e-5
lr_sched = LearningRateScheduler(schedule=cheduler)
nb_epoch = 24
validation_batch_size = 4
model.fit_generator(
dataset.generate(batch_size=batch_size),
steps_per_epoch=60,
epochs=nb_epoch,
verbose=1,
callbacks=[
checkpoint_periodical, checkpoint_best, tensorboard, lr_sched
],
validation_data=dataset.generate_validation(
batch_size=validation_batch_size),
validation_steps=len(dataset.test_idx) // validation_batch_size,
initial_epoch=continue_from_epoch + 1)
model.save_weights('../output/ruler_masks_unet.h5')
def check_dataset_generator():
dataset = ClassificationDataset(fold=1)
batch_size = 2
for x_batch, y_batch in dataset.generate(batch_size=batch_size, skip_pp=True, verbose=True):
print(y_batch)
for i in range(batch_size):
print(np.min(x_batch[i]), np.max(x_batch[i]))
plt.imshow(x_batch[i] / 256.0)
# print(SPECIES_CLASSES[y_batch['cat_species'][i]], COVER_CLASSES[y_batch['cat_cover'][i]])
plt.show()
def check_unet(weights):
dataset = Dataset()
model = model_unet(INPUT_SHAPE)
model.load_weights(weights)
batch_size = 16
for batch_x, batch_y in dataset.generate(batch_size=batch_size):
print(batch_x.shape, batch_y.shape)
with utils.timeit_context('predict 16 images'):
prediction = model.predict_on_batch(batch_x)
for i in range(batch_size):
plt.imshow(unprocess_input(batch_x[i]))
plt.imshow(prediction[i, :, :, 0], alpha=0.75)
plt.show()
def train(fold,
continue_from_epoch=0,
weights='',
batch_size=8,
model_type='densenet'):
preprocess_input_func = preprocess_input
if model_type == 'densenet':
model = build_model_densenet_161()
model_name = 'model_densenet161_ds3'
lock_layer1 = 'pool5'
lock_layer2 = 'pool4'
elif model_type == 'densenet121':
model = build_model_densenet_121()
model_name = 'model_densenet121'
lock_layer1 = 'pool5'
lock_layer2 = 'pool4'
elif model_type == 'densenet121_mask':
model = build_model_densenet121_with_mask()
model_name = 'model_densenet121_mask'
lock_layer1 = 'cat_species'
lock_layer2 = 'densenet'
elif model_type == 'densenet2':
model = build_model_densenet_161()
model_name = 'model_densenet161_ds3'
lock_layer1 = 'pool5'
lock_layer2 = 'pool4'
elif model_type == 'resnet50':
model = build_model_resnet50()
model_name = 'model_resnet50_cat'
lock_layer1 = 'activation_49'
lock_layer2 = 'activation_40'
elif model_type == 'xception':
model = build_model_xception()
model_name = 'model_xception'
lock_layer1 = 'block14_sepconv2_act'
lock_layer2 = 'block14_sepconv1'
preprocess_input_func = preprocess_input_xception
elif model_type == 'inception':
model = build_model_inception()
model_name = 'model_inception'
lock_layer1 = 'mixed10'
lock_layer2 = 'mixed9'
preprocess_input_func = preprocess_input_xception
elif model_type == 'resnet50_mask':
model = build_model_resnet50_with_mask()
model_name = 'model_resnet50_mask'
lock_layer1 = 'cat_species'
lock_layer2 = 'resnet50'
else:
print('Invalid model_type', model_type)
return
model.summary()
dataset = ClassificationDataset(fold=fold,
preprocess_input=preprocess_input_func)
checkpoints_dir = '../output/checkpoints/classification/{}_fold_{}'.format(
model_name, fold)
tensorboard_dir = '../output/tensorboard/classification/{}_fold_{}'.format(
model_name, fold)
os.makedirs(checkpoints_dir, exist_ok=True)
os.makedirs(tensorboard_dir, exist_ok=True)
if len(weights) > 0:
model.load_weights(weights)
def cheduler(epoch):
if epoch < 1:
return 5e-4
if epoch < 5:
return 3e-4
if epoch < 10:
return 1e-4
if epoch < 20:
return 5e-5
return 1e-5
validation_batch_size = 8
if continue_from_epoch == 0:
utils.lock_layers_until(model, lock_layer1)
model.summary()
model.fit_generator(
dataset.generate(batch_size=batch_size),
steps_per_epoch=dataset.train_batches(batch_size),
epochs=1,
verbose=1,
callbacks=[],
validation_data=dataset.generate_test(
batch_size=validation_batch_size),
validation_steps=dataset.test_batches(validation_batch_size),
initial_epoch=0)
continue_from_epoch += 1
checkpoint_periodical = ModelCheckpoint(
checkpoints_dir + "/checkpoint-{epoch:03d}-{val_loss:.4f}.hdf5",
verbose=1,
save_weights_only=True,
period=1)
tensorboard = TensorBoard(tensorboard_dir,
histogram_freq=0,
write_graph=False,
write_images=True)
lr_sched = LearningRateScheduler(schedule=cheduler)
utils.lock_layers_until(model, lock_layer2)
model.summary()
nb_epoch = 10
model.fit_generator(
dataset.generate(batch_size=batch_size),
steps_per_epoch=dataset.train_batches(batch_size),
epochs=nb_epoch,
verbose=1,
callbacks=[checkpoint_periodical, tensorboard, lr_sched],
validation_data=dataset.generate_test(
batch_size=validation_batch_size),
validation_steps=dataset.test_batches(validation_batch_size),
initial_epoch=continue_from_epoch + 1)
return wait_time / size
if __name__ == '__main__':
rounds = 1000
results = {
'first_come_first_served': [[], [], []],
'shortest_job_first': [[], [], []],
'round_robin': [[], [], []]
}
for i in range(rounds):
jobsets = [
generate(100, [(2, 8, 0.7), (20, 30, 0.2), (35, 40, 0.1)]),
generate(100, [(2, 8, 0.5), (20, 30, 0.3), (35, 40, 0.2)]),
generate(100, [(2, 8, 0.3), (20, 30, 0.3), (35, 40, 0.4)])
]
for j in range(len(jobsets)):
jobs = jobsets[j]
results['first_come_first_served'][j].append(
first_come_first_served(jobs))
results['shortest_job_first'][j].append(shortest_job_first(jobs))
results['round_robin'][j].append(round_robin(jobs))
print results
colors = {
'first_come_first_served': 'Y',
def main(args):
# Determine which algorithms to perform
algorithms = []
if args.bf:
algorithms.append(wrp.AlgorithmWrapper(bf.CONTENT))
if args.nn:
algorithms.append(wrp.AlgorithmWrapper(nn.CONTENT))
if args.ni:
algorithms.append(wrp.AlgorithmWrapper(ni.CONTENT))
if args.mst:
algorithms.append(wrp.AlgorithmWrapper(mst.CONTENT))
if args.ci:
algorithms.append(wrp.AlgorithmWrapper(ci.CONTENT))
# Initialize plots
fig_correct, fig_complex, plot_correct, plot_complex = init_plots(
algorithms)
# Execute correct command
if args.cmd == 'read':
datasets = dataset.read(args.path)
for ds in datasets:
for algorithm in algorithms:
y1, y2 = analyse_algorithm(ds.adj, ds.order, algorithm,
args.repeat)
plot_correct.scatter(ds.order,
y2,
color=algorithm.color,
alpha=0.5,
s=0.5)
plot_complex.scatter(ds.order,
y1,
color=algorithm.color,
alpha=0.5,
s=0.5)
elif args.cmd == 'random':
if args.write:
if not os.path.exists('datasets'):
os.makedirs('datasets')
order = args.order # reset n
while order <= args.max:
for i in range(args.trials):
path = None
if args.write:
path = "datasets/order_{}_trial_{}.dat".format(order, i)
adj = dataset.generate(order, args.spread, path)
for algorithm in algorithms:
y1, y2 = analyse_algorithm(adj, order, algorithm,
args.repeat)
algorithm.x.append(order)
algorithm.complex.append(y1)
algorithm.working_complex.append(y1)
algorithm.correct.append(y2)
algorithm.working_correct.append(y2)
for algorithm in algorithms:
algorithm.avg_correct.append(
util.average(algorithm.working_correct))
algorithm.avg_complex.append(
util.average(algorithm.working_complex))
algorithm.avg_x.append(order)
algorithm.working_correct.clear()
algorithm.working_complex.clear()
order += 1
if args.plot:
for algorithm in algorithms:
# Plot correctness measure
plot_correct.scatter(algorithm.x,
algorithm.correct,
color=algorithm.color,
alpha=0.5,
s=0.5)
plot_correct.plot(algorithm.avg_x,
algorithm.avg_correct,
'-',
color=algorithm.color,
linewidth=0.5)
fig_correct.savefig('Correctness',
dpi=300,
bbox_inches='tight')
# Plot complexity measure
plot_complex.scatter(algorithm.x,
algorithm.complex,
color=algorithm.color,
alpha=0.5,
s=0.5)
plot_complex.plot(algorithm.avg_x,
algorithm.avg_complex,
'-',
color=algorithm.color,
linewidth=0.5)
fig_complex.savefig('Complexity', dpi=300, bbox_inches='tight')
def train(self, epochs, batch_size=1, sample_interval=50):
start_time = datetime.datetime.now()
# Adversarial loss ground truths
valid = np.ones((batch_size,) + self.disc_patch)
fake = np.zeros((batch_size,) + self.disc_patch)
# Generate dataset
dataset.generate("sketches", self.img_cols, self.img_rows, 0.95)
dataset.generate("pictures", self.img_cols, self.img_rows, 0.95)
# Load the dataset
(X_train, X_test) = dataset.load("sketches")
(Y_train, Y_test) = dataset.load("pictures")
# Rescale -1 to 1
X_train = X_train / 127.5 - 1.
X_train = np.expand_dims(X_train, axis=3)
X_test = X_test / 127.5 - 1.
X_test = np.expand_dims(X_test, axis=3)
Y_train = Y_train / 127.5 - 1.
Y_train = np.expand_dims(Y_train, axis=3)
Y_test = Y_test / 127.5 - 1.
Y_test = np.expand_dims(Y_test, axis=3)
# Load sample inputs
train_sketches = X_train[0:self.sample_size]
train_pictures = Y_train[0:self.sample_size]
test_sketches = X_test[0:self.sample_size]
test_pictures = Y_test[0:self.sample_size]
# Make directories
if not os.path.exists('p2p_results/train_sketches/'):
os.makedirs('p2p_results/train_sketches/')
if not os.path.exists('p2p_results/train_pictures/'):
os.makedirs('p2p_results/train_pictures/')
if not os.path.exists('p2p_results/test_sketches/'):
os.makedirs('p2p_results/test_sketches/')
if not os.path.exists('p2p_results/test_pictures/'):
os.makedirs('p2p_results/test_pictures/')
# Save images
for i in range(len(train_sketches)):
img = image.array_to_img(train_sketches[i])
img.save('p2p_results/train_sketches/' + str(i) + '.png')
for i in range(len(train_pictures)):
img = image.array_to_img(train_pictures[i])
img.save('p2p_results/train_pictures/' + str(i) + '.png')
for i in range(len(test_sketches)):
img = image.array_to_img(test_sketches[i])
img.save('p2p_results/test_sketches/' + str(i) + '.png')
for i in range(len(test_pictures)):
img = image.array_to_img(test_pictures[i])
img.save('p2p_results/test_pictures/' + str(i) + '.png')
for epoch in range(epochs):
# Select a random batch of images
idx = np.random.randint(0, X_train.shape[0], batch_size)
imgs_B = X_train[idx]
imgs_A = Y_train[idx]
# ---------------------
# Train Discriminator
# ---------------------
# Condition on B and generate a translated version
fake_A = self.generator.predict(imgs_B)
# Train the discriminators (original images = real / generated = Fake)
d_loss_real = self.discriminator.train_on_batch([imgs_A, imgs_B], valid)
d_loss_fake = self.discriminator.train_on_batch([fake_A, imgs_B], fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# -----------------
# Train Generator
# -----------------
# Train the generators
g_loss = self.combined.train_on_batch([imgs_A, imgs_B], [valid, imgs_A])
elapsed_time = datetime.datetime.now() - start_time
# Plot the progress
print ("[Epoch %d/%d] [D loss: %f, acc: %3d%%] [G loss: %f] time: %s" % (epoch, epochs,
d_loss[0], 100*d_loss[1],
g_loss[0],
elapsed_time))
# If at save interval => save images and models
if epoch % sample_interval == 0:
self.sample_train_images(epoch, X_train, Y_train)
self.sample_test_images(epoch, X_test, Y_test)
self.save_models(epoch)
def train(self, epochs, batch_size=128, sample_interval=50):
# Load the dataset
# # Generate the dataset
dataset.generate("sketches", self.img_cols, self.img_rows, 0.95)
dataset.generate("pictures", self.img_cols, self.img_rows, 0.95)
# Load the dataset
(X_train, X_test) = dataset.load("sketches")
(Y_train, Y_test) = dataset.load("pictures")
# Rescale -1 to 1
X_train = X_train / 127.5 - 1.
X_train = np.expand_dims(X_train, axis=3)
X_test = X_test / 127.5 - 1.
X_test = np.expand_dims(X_test, axis=3)
y_train = Y_train / 127.5 - 1.
y_train = np.expand_dims(Y_train, axis=3)
Y_test = Y_test / 127.5 - 1.
Y_test = np.expand_dims(Y_test, axis=3)
# Adversarial ground truths
valid = np.ones((batch_size, 1))
fake = np.zeros((batch_size, 1))
for epoch in range(epochs):
# ---------------------
# Train Discriminator
# ---------------------
# Select a random half batch of images
idx = np.random.randint(0, X_train.shape[0], batch_size)
imgs, sketches = X_train[idx], y_train[idx]
# Sample noise as generator input
# noise = np.random.normal(0, 1, (batch_size, 100))
# Generate a half batch of new images
gen_imgs = self.generator.predict([sketches])
# sketches = np.asarray(sketches).reshape(batch_size, self.img_size)
# Train the discriminator
d_loss_real = self.discriminator.train_on_batch([imgs, sketches], valid)
d_loss_fake = self.discriminator.train_on_batch([gen_imgs, sketches], fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# ---------------------
# Train Generator
# ---------------------
# Condition on sketches
# sampled_sketches = np.random.randint(0, 10, batch_size).reshape(-1, 1)
# Train the generator
g_loss = self.combined.train_on_batch([sketches], valid)
# Plot the progress
print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100 * d_loss[1], g_loss))
# If at save interval => save generated image samples
if epoch % sample_interval == 0:
self.sample_images(epoch, X_train)
# Plot the progress
# print ("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss))
# print ("%d [D2 loss: %f, acc.: %.2f%%] [G2 loss: %f]" % (epoch, d2_loss[0], 100*d2_loss[1], g2_loss))
# If at save interval => save generated image samples
if epoch % sample_interval == 0:
self.sample_images(epoch, X_train)
self.generator.save('generator.h5')
self.discriminator.save('discriminator.h5')
self.generator.save_weights('models/generator_weights.h5')
self.discriminator.save_weights('models/discriminator_weights.h5')
import dataset
import neutal_nets
import visualizer
# HYPERPARAMETERS
batch_size = 32
number_of_epochs = 5
train_samples, validation_samples = dataset.get_data()
# compile and train the model using the generator function
train_generator = dataset.generate(train_samples, batch_size)
validation_generator = dataset.generate(validation_samples, batch_size)
model = neutal_nets.le_net(0.5)
model.compile(loss='mse', optimizer='adam')
history_object = model.fit_generator(train_generator,
samples_per_epoch=len(train_samples),
validation_data=validation_generator,
nb_val_samples=len(validation_samples),
nb_epoch=number_of_epochs,
verbose=1)
# save model
model.save('dg_model_lenet.h5')
print(history_object.history.keys())
visualizer.plot_loss(history_object)
def train(self, epochs, batch_size=128, sample_interval=50):
# Generate the dataset
dataset.generate("sketches", self.img_cols, self.img_rows, 0.95)
dataset.generate("pictures", self.img_cols, self.img_rows, 0.95)
# Load the dataset
(A_train, A_test) = dataset.load("sketches")
(B_train, B_test) = dataset.load("pictures")
# Rescale -1 to 1
A_train = (A_train.astype(np.float32) - 127.5) / 127.5
B_train = (B_train.astype(np.float32) - 127.5) / 127.5
A_test = (A_test.astype(np.float32) - 127.5) / 127.5
B_test = (B_test.astype(np.float32) - 127.5) / 127.5
# Reshape for generators / discriminators
A_train = A_train.reshape(A_train.shape[0], self.img_dim)
B_train = B_train.reshape(B_train.shape[0], self.img_dim)
A_test = A_test.reshape(A_test.shape[0], self.img_dim)
B_test = B_test.reshape(B_test.shape[0], self.img_dim)
clip_value = 0.01
n_critic = 4
# Adversarial ground truths
valid = -np.ones((batch_size, 1))
fake = np.ones((batch_size, 1))
for epoch in range(epochs):
# Train the discriminator for n_critic iterations
for _ in range(n_critic):
# ----------------------
# Train Discriminators
# ----------------------
# Sample generator inputs
imgs_A = self.sample_generator_input(A_train, batch_size)
imgs_B = self.sample_generator_input(B_train, batch_size)
# Translate images to their opposite domain
fake_B = self.G_AB.predict(imgs_A)
fake_A = self.G_BA.predict(imgs_B)
# Train the discriminators
D_A_loss_real = self.D_A.train_on_batch(imgs_A, valid)
D_A_loss_fake = self.D_A.train_on_batch(fake_A, fake)
D_B_loss_real = self.D_B.train_on_batch(imgs_B, valid)
D_B_loss_fake = self.D_B.train_on_batch(fake_B, fake)
D_A_loss = 0.5 * np.add(D_A_loss_real, D_A_loss_fake)
D_B_loss = 0.5 * np.add(D_B_loss_real, D_B_loss_fake)
# Clip discriminator weights
for d in [self.D_A, self.D_B]:
for l in d.layers:
weights = l.get_weights()
weights = [
np.clip(w, -clip_value, clip_value)
for w in weights
]
l.set_weights(weights)
# ------------------
# Train Generators
# ------------------
# Train the generators
g_loss = self.combined.train_on_batch(
[imgs_A, imgs_B], [valid, valid, imgs_A, imgs_B])
# Plot the progress
print ("%d [D1 loss: %f] [D2 loss: %f] [G loss: %f]" \
% (epoch, D_A_loss[0], D_B_loss[0], g_loss[0]))
# If at save interval => save generated image samples
if epoch % sample_interval == 0:
self.save_imgs(epoch, A_test, B_test)
self.save_models(epoch)
global_step=global_step, optimizer='Adam', clip_gradients=2.5)
# parameter learning_rate clip_gradients
bj_air = ['PM2.5', 'PM10', 'O3']
ld_air = ['PM2.5', 'PM10']
bj.extend(ld)
for where in bj:
if where in ld:
air = ld_air
else:
air = bj_air
for which in air:
print('-------------------------------------------')
print(where, which)
with tf.Session() as session:
session.run(tf.global_variables_initializer())
d = dataset.generate(where, which)
n = 0
while True:
try:
n += 1
x_, y_ = d.next()
feed = {X[t]:x_.reshape((-1, 120))[:,t].reshape((-1, 1)) for t in range(120)}
feed.update({y[t]: y_.reshape((-1, 48))[:,t].reshape((-1, 1)) for t in range(48)})
_, l = session.run([optimizer, loss], feed_dict=feed)
if n % 50 == 0:
print("loss after %d iteractions : %.3f" %(n ,l))
saver = tf.train.Saver()
if (len(where)) > 3:
save_path = saver.save(session, './save/iteraction_%s_%s_%d' % (where[:-3], which, n))
else:
save_path = saver.save(session, './save/iteraction_%s_%s_%d' % (where, which, n))
from keras.models import Sequential
from keras.layers import Dense, Conv2D, MaxPooling2D, Flatten
import dataset
model = Sequential()
chars = 'あいうえおかきくけこさしすせそたちつてとなにのひふへまみむもやゆよらりん';
# add model layers
model.add(Conv2D(16, kernel_size=(3, 3), activation='relu', input_shape=(24, 15, 1)))
model.add(MaxPooling2D(pool_size=(2, 2), strides=None))
model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=None))
model.add(Flatten())
model.add(Dense(500, activation='relu'))
model.add(Dense(len(chars), activation='softmax'))
# Prepare model for training
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
(x_train, x_test, y_train, y_test) = dataset.generate([char for char in chars])
# Run
model.fit(x_train, y_train, validation_data=(x_test, y_test), epochs=10, shuffle=True)
# Epoch 10/10
# loss: 0.0069 - accuracy: 0.9979 - val_loss: 0.0593 - val_accuracy: 0.9872
model.save('model.h5')
model.summary()
def train(self, epochs, batch_size=128, sample_interval=50):
# Generate the dataset
dataset.generate("sketches", self.img_cols, self.img_rows, 0.95)
dataset.generate("pictures", self.img_cols, self.img_rows, 0.95)
# Load the dataset
(X_train, X_test) = dataset.load("sketches")
(Y_train, Y_test) = dataset.load("pictures")
# Rescale -1 to 1
X_train = X_train / 127.5 - 1.
X_train = np.expand_dims(X_train, axis=3)
X_test = X_test / 127.5 - 1.
X_test = np.expand_dims(X_test, axis=3)
Y_train = Y_train / 127.5 - 1.
Y_train = np.expand_dims(Y_train, axis=3)
Y_test = Y_test / 127.5 - 1.
Y_test = np.expand_dims(Y_test, axis=3)
# Reshape sketches for generator
X_train = X_train.reshape(X_train.shape[0], self.img_size)
X_test = X_test.reshape(X_test.shape[0], self.img_size)
# Adversarial ground truths
valid = np.ones((batch_size, 1))
fake = np.zeros((batch_size, 1))
for epoch in range(epochs):
# ---------------------
# Train Discriminator
# ---------------------
# Select a random batch of images
idx = np.random.randint(0, X_train.shape[0], batch_size)
sketches = X_train[idx]
pictures = Y_train[idx]
# Generate a batch of new images
gen_imgs = self.generator.predict(sketches)
# Train the discriminator
d_loss_real = self.discriminator.train_on_batch(pictures, valid)
d_loss_fake = self.discriminator.train_on_batch(gen_imgs, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# ---------------------
# Train Generator
# ---------------------
# Select a random batch of images
idx = np.random.randint(0, X_train.shape[0], batch_size)
sketches = X_train[idx]
# Train the generator (to have the discriminator label samples as valid)
g_loss = self.combined.train_on_batch(sketches, valid)
# Plot the progress
print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" %
(epoch, d_loss[0], 100 * d_loss[1], g_loss))
# If at save interval => save generated image samples and models
if epoch % sample_interval == 0:
self.sample_images(epoch, X_test, Y_test)
self.save_models(epoch)
# Show 16 images on a grid
def show_images(x):
pyplot.figure(1)
k = 0
for i in range(0, 4):
for j in range(0, 4):
pyplot.subplot2grid((4, 4), (i, j))
pyplot.imshow(Image.fromarray(x[k], 'P'))
k = k + 1
pyplot.show()
# Generate a zip file containing train and test numpy arrays
dataset.generate("sketches", 128, 192, 0.9)
dataset.generate("pictures", 128, 192, 0.9)
# Extract train and test numpy arrays
x_train, x_test = dataset.load("sketches")
y_train, y_test = dataset.load("pictures")
# Check array dimensions
print(x_train.shape)
print(x_test.shape)
print(y_train.shape)
print(y_test.shape)
# Display datasets
show_images(x_train[:16])
show_images(x_test[:16])
def train(self, epochs, batch_size=128, sample_interval=50):
# Generate the dataset
dataset.generate("sketches", self.img_cols, self.img_rows, 0.95)
dataset.generate("pictures", self.img_cols, self.img_rows, 0.95)
# Load the dataset
(X_train, X_test) = dataset.load("sketches")
(Y_train, Y_test) = dataset.load("pictures")
# Rescale -1 to 1
X_train = X_train / 127.5 - 1.
X_train = np.expand_dims(X_train, axis=3)
X_test = X_test / 127.5 - 1.
X_test = np.expand_dims(X_test, axis=3)
Y_train = Y_train / 127.5 - 1.
Y_train = np.expand_dims(Y_train, axis=3)
Y_test = Y_test / 127.5 - 1.
Y_test = np.expand_dims(Y_test, axis=3)
# batch_shape = (batch_size, self.img_rows, self.img_cols, self.channels)
# Reshape sketches for generator
X_train = X_train.reshape(len(X_train), self.img_rows, self.img_cols,
self.channels)
X_test = X_test.reshape(len(X_test), self.img_rows, self.img_cols,
self.channels)
# Adversarial ground truths
# valid = np.ones((batch_size, 1))
# fake = np.zeros((batch_size, 1))
valid = np.full(batch_size, 0.95)
fake = np.full(batch_size, 0.05)
# print(str(valid))
for epoch in range(epochs):
# ---------------------
# Train Discriminator
# ---------------------
# Select a random batch of images
idx = np.random.randint(0, Y_train.shape[0], batch_size)
imgs = Y_train[idx]
idx = np.random.randint(0, X_train.shape[0], batch_size)
sketches_list = X_train[idx]
sketches = self.reshape_sketches(sketches_list)
gen_imgs = self.generator.predict(sketches)
# Train the discriminator
# d_loss_real = self.discriminator.train_on_batch(imgs, valid)
# d_loss_fake = self.discriminator.train_on_batch(gen_imgs, fake)
# d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
if (epoch >= 0) and (epoch % 1 == 0):
two_imgs_same = list()
imgs_dif = list()
# for i in range(batch_size):
# two_imgs_same.append([imgs[i], imgs[i]])
# imgs_dif.append([self.generator(imgs[i]), imgs[i]])
# if i >= batch_size - 1:
# imgs_dif.append(imgs[i - 1])
# else:
# imgs_dif.append(imgs[i - 1])
# imgs_dif = np.asarray(two_imgs_dif)
# two_imgs_same = np.asarray(two_imgs_same)
d2_loss_real = self.second_discriminator.train_on_batch(
[imgs, imgs], valid)
d2_loss_fake = self.second_combined.train_on_batch(
[gen_imgs, imgs], fake)
d2_loss = 0.5 * np.add(d2_loss_real, d2_loss_fake)
# ---------------------
# Train Generator
# ---------------------
idx = np.random.randint(0, X_train.shape[0], batch_size)
sketches_list = X_train[idx]
pic_list = Y_train[idx]
sketches = self.reshape_sketches(sketches_list)
pics = self.reshape_sketches(pic_list)
# Train the generator (to have the discriminator label samples as valid)
# g_loss = self.combined.train_on_batch(sketches, valid)
# print ("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss))
if (epoch >= 0) and (epoch % 1 == 0):
g2_loss = self.second_combined.train_on_batch([sketches, pics],
valid)
print("%d [D2 loss: %f, acc.: %.2f%%] [G2 loss: %f]" %
(epoch, d2_loss[0], 100 * d2_loss[1], g2_loss))
# Plot the progress
# print ("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss))
# print ("%d [D2 loss: %f, acc.: %.2f%%] [G2 loss: %f]" % (epoch, d2_loss[0], 100*d2_loss[1], g2_loss))
# If at save interval => save generated image samples
if epoch % sample_interval == 0:
self.sample_images(epoch, X_train)
self.generator.save('generator.h5')
self.discriminator.save('discriminator.h5')
self.generator.save_weights('models/generator_weights.h5')
self.discriminator.save_weights(
'models/discriminator_weights.h5')
# Training options
parser.add_argument('--batch_size', type=int, default=64,
help='batch size')
parser.add_argument('--epochs', type=int, default=100,
help='upper epoch limit')
args = parser.parse_args()
# data pre-processing
dataset = Dataset(args)
dataset.data_preprocess()
dataset.rescale()
dataset.generate_key()
dataset.random_get_val()
train = dataset.generate(args.json_path, args.save_path, args.key_path, args.batch_size, args.max_label_length, (args.image_height, args.image_width))
val = dataset.generate(args.json_val_path, args.save_path, args.key_path, args.batch_size, args.max_label_length, (args.image_height, args.image_width))
crnn = model.CRNN(args)
y_pred = crnn.model()
loss = crnn.get_loss(y_pred)
inputs = crnn.inputs
labels = crnn.labels
input_length = crnn.input_length
label_length = crnn.label_length
model = Model(inputs=[inputs, labels, input_length, label_length], outputs=loss)
adam = Adam()
model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer=adam,metrics=['accuracy'])
checkpoint = ModelCheckpoint(args.model_path + (r'weights-{epoch:02d}.hdf5'),
save_weights_only=True)
earlystop = EarlyStopping(patience=10)
