def main():
strategy = tf.distribute.MirroredStrategy();
# yolov3 model
with strategy.scope():
yolov3 = YOLOv3((416,416,3,), 80);
@tf.function
def loss(labels, outputs):
return Loss((416,416,3,),80)([outputs[0], outputs[1], outputs[2], labels[0], labels[1], labels[2]]);
yolov3.compile(optimizer = tf.keras.optimizers.Adam(1e-4), loss = loss);
# load downloaded dataset
trainset_filenames = [join('trainset', filename) for filename in listdir('trainset')];
testset_filenames = [join('testset', filename) for filename in listdir('testset')];
trainset = tf.data.TFRecordDataset(trainset_filenames).map(parse_function_generator(80)).repeat(-1).shuffle(batch_size).batch(batch_size).prefetch(tf.data.experimental.AUTOTUNE);
testset = tf.data.TFRecordDataset(testset_filenames).map(parse_function_generator(80)).repeat(-1).shuffle(batch_size).batch(batch_size).prefetch(tf.data.experimental.AUTOTUNE);
yolov3.fit(trainset, epochs = 100, validation_data = testset);
yolov3.save('yolov3.h5');
def train():
category = pd.read_pickle('category.pkl')
dilations = [2**i for i in range(10)] * 5
receptive_field = calculate_receptive_field(dilations, 2, 32)
wavenet = WaveNet(dilations=dilations,
use_glob_cond=True,
glob_cls_num=len(category),
glob_embed_dim=5)
optimizer = tf.keras.optimizers.Adam(1e-3)
# load dataset
trainset = tf.data.TFRecordDataset(join(
'dataset', 'trainset.tfrecord')).repeat(-1).map(
parse_function_generator()).batch(batch_size).prefetch(
tf.data.experimental.AUTOTUNE)
# restore from existing checkpoint
if False == exists('checkpoints'): mkdir('checkpoints')
checkpoint = tf.train.Checkpoint(model=wavenet, optimizer=optimizer)
checkpoint.restore(tf.train.latest_checkpoint('checkpoints'))
# create log
log = tf.summary.create_file_writer('checkpoints')
# train model
avg_loss = tf.keras.metrics.Mean(name='loss', dtype=tf.float32)
for audios, person_id in trainset:
inputs = audios[:, :-1, :]
# inputs.shape = (batch, receptive_field + audio_length - 1, 1)
target = audios[:, receptive_field:, :]
# target.shape = (batch, audio_length, 1)
with tf.GradientTape() as tape:
outputs = wavenet([inputs, person_id])
# outputs.shape = (batch, audio_length, 1)
loss = tf.keras.losses.SparseCategoricalCrossentropy()(target,
outputs)
avg_loss.update_state(loss)
# write log
if tf.equal(optimizer.iterations % 100, 0):
with log.as_default():
tf.summary.scalar('loss',
avg_loss.result(),
step=optimizer.iterations)
print('Step #%d Loss: %.6f' %
(optimizer.iterations, avg_loss.result()))
if avg_loss.result() < 0.01: break
avg_loss.reset_states()
grads = tape.gradient(loss, wavenet.trainable_variables)
optimizer.apply_gradients(zip(grads, wavenet.trainable_variables))
# save the network structure with weights
if False == exists('model'): mkdir('model')
wavenet.save(join('model', 'wavenet.h5'))
def main():
yolov5l = YOLOv5_large((
608,
608,
3,
), 80)
loss1 = Loss((
608,
608,
3,
), 0, 80)
loss2 = Loss((
608,
608,
3,
), 1, 80)
loss3 = Loss((
608,
608,
3,
), 2, 80)
if exists('./checkpoints/ckpt'):
yolov5l.load_weights('./checkpoints/ckpt/variables/variables')
optimizer = tf.keras.optimizers.Adam(1e-4)
yolov5l.compile(optimizer=optimizer,
loss={
'output1':
lambda labels, outputs: loss1([outputs, labels]),
'output2':
lambda labels, outputs: loss2([outputs, labels]),
'output3':
lambda labels, outputs: loss3([outputs, labels])
})
class SummaryCallback(tf.keras.callbacks.Callback):
def __init__(self, eval_freq=100):
self.eval_freq = eval_freq
testset = tf.data.TFRecordDataset(testset_filenames).map(
parse_function).repeat(-1)
self.iter = iter(testset)
self.train_loss = tf.keras.metrics.Mean(name='train loss',
dtype=tf.float32)
self.log = tf.summary.create_file_writer('./checkpoints')
def on_batch_begin(self, batch, logs=None):
pass
def on_batch_end(self, batch, logs=None):
self.train_loss.update_state(logs['loss'])
if batch % self.eval_freq == 0:
image, bbox, labels = next(self.iter)
image = image.numpy().astype('uint8')
predictor = Predictor(yolov5l=yolov5l)
boundings = predictor.predict(image)
color_map = dict()
for bounding in boundings:
if bounding[5].numpy().astype('int32') not in color_map:
color_map[bounding[5].numpy().astype('int32')] = tuple(
np.random.randint(low=0, high=256,
size=(3, )).tolist())
clr = color_map[bounding[5].numpy().astype('int32')]
cv2.rectangle(image,
tuple(bounding[0:2].numpy().astype('int32')),
tuple(bounding[2:4].numpy().astype('int32')),
clr, 1)
cv2.putText(
image,
predictor.getClsName(
bounding[5].numpy().astype('int32')),
tuple(bounding[0:2].numpy().astype('int32')),
cv2.FONT_HERSHEY_PLAIN, 1, clr, 2)
image = tf.expand_dims(image, axis=0)
with self.log.as_default():
tf.summary.scalar('train loss',
self.train_loss.result(),
step=optimizer.iterations)
tf.summary.image('detect',
image[..., ::-1],
step=optimizer.iterations)
self.train_loss.reset_states()
def on_epoch_begin(self, epoch, logs=None):
pass
def on_epoch_end(self, batch, logs=None):
pass
# load downloaded dataset
trainset_filenames = [
join('trainset', filename) for filename in listdir('trainset')
]
testset_filenames = [
join('testset', filename) for filename in listdir('testset')
]
trainset = tf.data.TFRecordDataset(trainset_filenames).map(
parse_function_generator(80)).shuffle(batch_size).batch(
batch_size).prefetch(tf.data.experimental.AUTOTUNE)
testset = tf.data.TFRecordDataset(testset_filenames).map(
parse_function_generator(80)).shuffle(batch_size).batch(
batch_size).prefetch(tf.data.experimental.AUTOTUNE)
callbacks = [
tf.keras.callbacks.TensorBoard(log_dir='./checkpoints'),
tf.keras.callbacks.ModelCheckpoint(filepath='./checkpoints/ckpt',
save_freq=10000),
SummaryCallback(),
]
yolov5l.fit(trainset,
epochs=100,
validation_data=testset,
callbacks=callbacks)
yolov5l.save('yolov5l.h5')
def main():
gpus = tf.config.experimental.list_physical_devices('GPU')
[tf.config.experimental.set_memory_growth(gpu, True) for gpu in gpus]
# yolov5l model
yolov5l = YOLOv5_large((608, 608, 3), 80)
loss1 = Loss((608, 608, 3), 0, 80)
loss2 = Loss((608, 608, 3), 1, 80)
loss3 = Loss((608, 608, 3), 2, 80)
#optimizer = tf.keras.optimizers.Adam(tf.keras.optimizers.schedules.ExponentialDecay(1e-5, decay_steps = 110000, decay_rate = 0.99));
optimizer = tf.keras.optimizers.Adam(1e-5)
checkpoint = tf.train.Checkpoint(model=yolov5l, optimizer=optimizer)
train_loss = tf.keras.metrics.Mean(name='train loss', dtype=tf.float32)
test_loss = tf.keras.metrics.Mean(name='test loss', dtype=tf.float32)
# load downloaded dataset
trainset_filenames = [
join('trainset', filename) for filename in listdir('trainset')
]
testset_filenames = [
join('testset', filename) for filename in listdir('testset')
]
trainset = tf.data.TFRecordDataset(trainset_filenames).map(
parse_function_generator(80)).repeat(-1).shuffle(batch_size).batch(
batch_size).prefetch(tf.data.experimental.AUTOTUNE)
testset = tf.data.TFRecordDataset(testset_filenames).map(
parse_function_generator(80)).repeat(-1).shuffle(batch_size).batch(
batch_size).prefetch(tf.data.experimental.AUTOTUNE)
validationset = tf.data.TFRecordDataset(testset_filenames).map(
parse_function).repeat(-1)
trainset_iter = iter(trainset)
testset_iter = iter(testset)
validationset_iter = iter(validationset)
# restore from existing checkpoint
if False == exists('checkpoints'): mkdir('checkpoints')
checkpoint.restore(tf.train.latest_checkpoint('checkpoints'))
# tensorboard summary
log = tf.summary.create_file_writer('checkpoints')
# train model
while True:
images, labels = next(trainset_iter)
labels1, labels2, labels3 = labels
with tf.GradientTape() as tape:
outputs1, outputs2, outputs3 = yolov5l(images)
loss = loss1([outputs1, labels1]) + loss2(
[outputs2, labels2]) + loss3([outputs3, labels3])
# check whether the loss numberic is correct
if tf.math.reduce_any(tf.math.is_nan(loss)) == True:
print("NaN was detected in loss, skip the following steps!")
continue
grads = tape.gradient(loss, yolov5l.trainable_variables)
# check whether the grad numerics is correct
if tf.math.reduce_any([
tf.math.reduce_any(tf.math.is_nan(grad)) for grad in grads
]) == True:
print("NaN was detected in gradients, skip gradient apply!")
continue
optimizer.apply_gradients(zip(grads, yolov5l.trainable_variables))
train_loss.update_state(loss)
# save model
if tf.equal(optimizer.iterations % 10000, 0):
# save checkpoint every 1000 steps
checkpoint.save(join('checkpoints', 'ckpt'))
yolov5l.save('yolov5l.h5')
if tf.equal(optimizer.iterations % 100, 0):
# evaluate
for i in range(10):
images, labels = next(testset_iter)
# images.shape = (b, h, w, 3)
outputs = yolov5l(images)
loss = yolov3_loss([*outputs, *labels])
test_loss.update_state(loss)
# visualize
image, bbox, labels = next(validationset_iter)
# image.shape = (h, w, 3)
image = image.numpy().astype('uint8')
predictor = Predictor(yolov5l=yolov5l)
boundings = predictor.predict(image)
color_map = dict()
for bounding in boundings:
if bounding[5].numpy().astype('int32') not in color_map:
color_map[bounding[5].numpy().astype('int32')] = tuple(
np.random.randint(low=0, high=256,
size=(3, )).tolist())
clr = color_map[bounding[5].numpy().astype('int32')]
cv2.rectangle(image,
tuple(bounding[0:2].numpy().astype('int32')),
tuple(bounding[2:4].numpy().astype('int32')),
clr, 1)
cv2.putText(
image,
predictor.getClsName(bounding[5].numpy().astype('int32')),
tuple(bounding[0:2].numpy().astype('int32')),
cv2.FONT_HERSHEY_PLAIN, 1, clr, 2)
image = tf.expand_dims(image, axis=0)
# write log
with log.as_default():
tf.summary.scalar('train loss',
train_loss.result(),
step=optimizer.iterations)
tf.summary.scalar('test loss',
test_loss.result(),
step=optimizer.iterations)
tf.summary.image('detect',
image[..., ::-1],
step=optimizer.iterations)
print('Step #%d Train Loss: %.6f Test Loss: %.6f' %
(optimizer.iterations, train_loss.result(),
test_loss.result()))
# break condition
#if train_loss.result() < 0.001: break;
# reset
train_loss.reset_states()
test_loss.reset_states()
yolov5l.save('yolov5l.h5')
def main():
# models
cycleGAN = CycleGAN()
optimizerGA = tf.keras.optimizers.Adam(
tf.keras.optimizers.schedules.PiecewiseConstantDecay(
boundaries=[
dataset_size * 100 + i * dataset_size * 100 / 4
for i in range(5)
],
values=list(reversed([i * 2e-4 / 5 for i in range(6)]))),
beta_1=0.5)
optimizerGB = tf.keras.optimizers.Adam(
tf.keras.optimizers.schedules.PiecewiseConstantDecay(
boundaries=[
dataset_size * 100 + i * dataset_size * 100 / 4
for i in range(5)
],
values=list(reversed([i * 2e-4 / 5 for i in range(6)]))),
beta_1=0.5)
optimizerDA = tf.keras.optimizers.Adam(
tf.keras.optimizers.schedules.PiecewiseConstantDecay(
boundaries=[
dataset_size * 100 + i * dataset_size * 100 / 4
for i in range(5)
],
values=list(reversed([i * 2e-4 / 5 for i in range(6)]))),
beta_1=0.5)
optimizerDB = tf.keras.optimizers.Adam(
tf.keras.optimizers.schedules.PiecewiseConstantDecay(
boundaries=[
dataset_size * 100 + i * dataset_size * 100 / 4
for i in range(5)
],
values=list(reversed([i * 2e-4 / 5 for i in range(6)]))),
beta_1=0.5)
# load dataset
'''
A = tf.data.TFRecordDataset(os.path.join('dataset', 'A.tfrecord')).map(parse_function_generator(img_shape)).shuffle(batch_size).batch(batch_size).__iter__();
B = tf.data.TFRecordDataset(os.path.join('dataset', 'B.tfrecord')).map(parse_function_generator(img_shape)).shuffle(batch_size).batch(batch_size).__iter__();
'''
A = iter(
tfds.load(name='cycle_gan/horse2zebra', split="trainA",
download=False).repeat(-1).map(
parse_function_generator()).shuffle(batch_size).batch(
batch_size).prefetch(tf.data.experimental.AUTOTUNE))
B = iter(
tfds.load(name='cycle_gan/horse2zebra', split="trainB",
download=False).repeat(-1).map(
parse_function_generator()).shuffle(batch_size).batch(
batch_size).prefetch(tf.data.experimental.AUTOTUNE))
testA = iter(
tfds.load(name='cycle_gan/horse2zebra', split='testA',
download=False).repeat(-1).map(
parse_function_generator(isTrain=False)).batch(1))
testB = iter(
tfds.load(name='cycle_gan/horse2zebra', split='testB',
download=False).repeat(-1).map(
parse_function_generator(isTrain=False)).batch(1))
# restore from existing checkpoint
checkpoint = tf.train.Checkpoint(GA=cycleGAN.GA,
GB=cycleGAN.GB,
DA=cycleGAN.DA,
DB=cycleGAN.DB,
optimizerGA=optimizerGA,
optimizerGB=optimizerGB,
optimizerDA=optimizerDA,
optimizerDB=optimizerDB)
checkpoint.restore(tf.train.latest_checkpoint('checkpoints'))
# create log
log = tf.summary.create_file_writer('checkpoints')
# train model
avg_ga_loss = tf.keras.metrics.Mean(name='GA loss', dtype=tf.float32)
avg_gb_loss = tf.keras.metrics.Mean(name='GB loss', dtype=tf.float32)
avg_da_loss = tf.keras.metrics.Mean(name='DA loss', dtype=tf.float32)
avg_db_loss = tf.keras.metrics.Mean(name='DB loss', dtype=tf.float32)
while True:
imageA, _ = next(A)
imageB, _ = next(B)
with tf.GradientTape(persistent=True) as tape:
outputs = cycleGAN((imageA, imageB))
GA_loss = cycleGAN.GA_loss(outputs)
GB_loss = cycleGAN.GB_loss(outputs)
DA_loss = cycleGAN.DA_loss(outputs)
DB_loss = cycleGAN.DB_loss(outputs)
# calculate discriminator gradients
da_grads = tape.gradient(DA_loss, cycleGAN.DA.trainable_variables)
avg_da_loss.update_state(DA_loss)
db_grads = tape.gradient(DB_loss, cycleGAN.DB.trainable_variables)
avg_db_loss.update_state(DB_loss)
# calculate generator gradients
ga_grads = tape.gradient(GA_loss, cycleGAN.GA.trainable_variables)
avg_ga_loss.update_state(GA_loss)
gb_grads = tape.gradient(GB_loss, cycleGAN.GB.trainable_variables)
avg_gb_loss.update_state(GB_loss)
# update discriminator weights
optimizerDA.apply_gradients(
zip(da_grads, cycleGAN.DA.trainable_variables))
optimizerDB.apply_gradients(
zip(db_grads, cycleGAN.DB.trainable_variables))
# update generator weights
optimizerGA.apply_gradients(
zip(ga_grads, cycleGAN.GA.trainable_variables))
optimizerGB.apply_gradients(
zip(gb_grads, cycleGAN.GB.trainable_variables))
if tf.equal(optimizerGA.iterations % 500, 0):
imageA, _ = next(testA)
imageB, _ = next(testB)
outputs = cycleGAN((imageA, imageB))
real_A = tf.cast(tf.clip_by_value((imageA + 1) * 127.5,
clip_value_min=0.,
clip_value_max=255.),
dtype=tf.uint8)
real_B = tf.cast(tf.clip_by_value((imageB + 1) * 127.5,
clip_value_min=0.,
clip_value_max=255.),
dtype=tf.uint8)
fake_B = tf.cast(tf.clip_by_value((outputs[1] + 1) * 127.5,
clip_value_min=0.,
clip_value_max=255.),
dtype=tf.uint8)
fake_A = tf.cast(tf.clip_by_value((outputs[7] + 1) * 127.5,
clip_value_min=0.,
clip_value_max=255.),
dtype=tf.uint8)
with log.as_default():
tf.summary.scalar('generator A loss',
avg_ga_loss.result(),
step=optimizerGA.iterations)
tf.summary.scalar('generator B loss',
avg_gb_loss.result(),
step=optimizerGB.iterations)
tf.summary.scalar('discriminator A loss',
avg_da_loss.result(),
step=optimizerDA.iterations)
tf.summary.scalar('discriminator B loss',
avg_db_loss.result(),
step=optimizerDB.iterations)
tf.summary.image('real A', real_A, step=optimizerGA.iterations)
tf.summary.image('fake B', fake_B, step=optimizerGA.iterations)
tf.summary.image('real B', real_B, step=optimizerGA.iterations)
tf.summary.image('fake A', fake_A, step=optimizerGA.iterations)
print('Step #%d GA Loss: %.6f GB Loss: %.6f DA Loss: %.6f DB Loss: %.6f lr: %.6f' % \
(optimizerGA.iterations, avg_ga_loss.result(), avg_gb_loss.result(), avg_da_loss.result(), avg_db_loss.result(), \
optimizerGA._hyper['learning_rate'](optimizerGA.iterations)))
avg_ga_loss.reset_states()
avg_gb_loss.reset_states()
avg_da_loss.reset_states()
avg_db_loss.reset_states()
if tf.equal(optimizerGA.iterations % 10000, 0):
# save model
checkpoint.save(os.path.join('checkpoints', 'ckpt'))
if GA_loss < 0.01 and GB_loss < 0.01 and DA_loss < 0.01 and DB_loss < 0.01:
break
# save the network structure with weights
if False == os.path.exists('models'): os.mkdir('models')
cycleGAN.GA.save(os.path.join('models', 'GA.h5'))
cycleGAN.GB.save(os.path.join('models', 'GB.h5'))
cycleGAN.DA.save(os.path.join('models', 'DA.h5'))
cycleGAN.DB.save(os.path.join('models', 'DB.h5'))
def main():
gpus = tf.config.experimental.list_physical_devices('GPU');
[tf.config.experimental.set_memory_growth(gpu, True) for gpu in gpus];
# yolov3 model
yolov3 = YOLOv3((416,416,3), 80);
yolov3_loss = Loss((416,416,3), 80);
#optimizer = tf.keras.optimizers.Adam(tf.keras.optimizers.schedules.ExponentialDecay(1e-5, decay_steps = 110000, decay_rate = 0.99));
optimizer = tf.keras.optimizers.Adam(1e-5);
checkpoint = tf.train.Checkpoint(model = yolov3, optimizer = optimizer);
train_loss = tf.keras.metrics.Mean(name = 'train loss', dtype = tf.float32);
test_loss = tf.keras.metrics.Mean(name = 'test loss', dtype = tf.float32);
# load downloaded dataset
trainset_filenames = [join('trainset', filename) for filename in listdir('trainset')];
testset_filenames = [join('testset', filename) for filename in listdir('testset')];
trainset = tf.data.TFRecordDataset(trainset_filenames).map(parse_function_generator(80)).repeat(-1).shuffle(batch_size).batch(batch_size).prefetch(tf.data.experimental.AUTOTUNE);
testset = tf.data.TFRecordDataset(testset_filenames).map(parse_function_generator(80)).repeat(-1).shuffle(batch_size).batch(batch_size).prefetch(tf.data.experimental.AUTOTUNE);
validationset = tf.data.TFRecordDataset(testset_filenames).map(parse_function).repeat(-1);
trainset_iter = iter(trainset);
testset_iter = iter(testset);
validationset_iter = iter(validationset);
# restore from existing checkpoint
if False == exists('checkpoints'): mkdir('checkpoints');
checkpoint.restore(tf.train.latest_checkpoint('checkpoints'));
# tensorboard summary
log = tf.summary.create_file_writer('checkpoints');
# train model
while True:
images, labels = next(trainset_iter);
with tf.GradientTape() as tape:
outputs = yolov3(images);
loss = yolov3_loss([*outputs, *labels]);
# check whether the loss numberic is correct
if tf.math.reduce_any(tf.math.is_nan(loss)) == True:
print("NaN was detected in loss, skip the following steps!");
continue;
grads = tape.gradient(loss, yolov3.trainable_variables);
# check whether the grad numerics is correct
if tf.math.reduce_any([tf.math.reduce_any(tf.math.is_nan(grad)) for grad in grads]) == True:
print("NaN was detected in gradients, skip gradient apply!");
continue;
optimizer.apply_gradients(zip(grads, yolov3.trainable_variables));
train_loss.update_state(loss);
# save model
if tf.equal(optimizer.iterations % 10000, 0):
# save checkpoint every 1000 steps
checkpoint.save(join('checkpoints','ckpt'));
yolov3.save('yolov3.h5');
if tf.equal(optimizer.iterations % 100, 0):
# evaluate
for i in range(10):
images, labels = next(testset_iter); # images.shape = (b, h, w, 3)
outputs = yolov3(images);
loss = yolov3_loss([*outputs, *labels]);
test_loss.update_state(loss);
# visualize
image, bbox, labels = next(validationset_iter); # image.shape = (h, w, 3)
image = image.numpy().astype('uint8');
predictor = Predictor(yolov3 = yolov3);
boundings = predictor.predict(image);
color_map = dict();
for bounding in boundings:
if bounding[5].numpy().astype('int32') in color_map:
clr = color_map[bounding[5].numpy().astype('int32')];
else:
color_map[bounding[5].numpy().astype('int32')] = tuple(np.random.randint(low = 0, high = 256, size = (3,)).tolist());
clr = color_map[bounding[5].numpy().astype('int32')];
cv2.rectangle(image, tuple(bounding[0:2].numpy().astype('int32')), tuple(bounding[2:4].numpy().astype('int32')), clr, 5);
image = tf.expand_dims(image, axis = 0);
# write log
with log.as_default():
tf.summary.scalar('train loss', train_loss.result(), step = optimizer.iterations);
tf.summary.scalar('test loss', test_loss.result(), step = optimizer.iterations);
tf.summary.image('detect', image[...,::-1], step = optimizer.iterations);
print('Step #%d Train Loss: %.6f Test Loss: %.6f' % (optimizer.iterations, train_loss.result(), test_loss.result()));
# break condition
#if train_loss.result() < 0.001: break;
# reset
train_loss.reset_states();
test_loss.reset_states();
yolov3.save('yolov3.h5');