def main(gpu, arch, bands, scale, epochs):
"""TODO"""
logger = logging.getLogger(__name__)
logger.info("TODO")
np.random.seed(42)
torch.cuda.set_device(gpu)
name = f"arch-{arch}-bands-{bands}-scale-{scale}-epochs-{epochs}"
arch, bands = get_arch_bands(arch, bands)
if arch is None or bands is None:
return
data = get_data(bands, scale)
model = get_model(arch, bands, data)
learn = get_learn(data, model, name)
cbs = get_callbacks(learn, name, "fbeta")
learn.lr_find()
learn.recorder.plot(suggestion=True, return_fig=True)
plt.savefig(f"reports/figures/{name}-lr")
learn_rate = learn.recorder.min_grad_lr
learn.fit_one_cycle(epochs, slice(learn_rate), callbacks=cbs)
learn.recorder.plot_losses()
plt.savefig(f"reports/figures/{name}-losses")
learn.recorder.plot_metrics()
plt.savefig(f"reports/figures/{name}-metrics")
learn.save(f"{name}")
learn.export(f"{name}/{name}.pkl")
state_dict = learn.model.state_dict()
torch.save(state_dict, f"models/{name}/{name}-state-dict")
def get_trainer(args):
trainer_args = {
'gpus': 1,
'max_epochs': args.epochs,
'callbacks': get_callbacks(args),
'logger': get_logger(args),
'deterministic': True,
}
trainer = pl.Trainer(**trainer_args)
return trainer
def main():
fname = str(datetime.now()).replace(':', '_').replace(' ', '_')[5:19]
create_dirs_write_config(fname, config, 'rnn')
spectrogram, melfilters = load_mel_spectrogram_db(original_audio_list[config['audio']], config)
print('Finished loading audio and creating spectrogram, shape: {}\n'.format(spectrogram.shape))
print('Min/max spectrogram: {}, {}'.format(np.min(spectrogram), np.max(spectrogram)))
config['start_offset'] += config['use_prev_frames']
spectrogram = spectrogram.T # rows should be different training examples, so different points in time
mm_scaler = MinMaxScaler()
spectrogram = mm_scaler.fit_transform(spectrogram)
print('Min/max spectrogram post-scaling: {}, {}'.format(np.min(spectrogram), np.max(spectrogram)))
X_train = np.zeros((config['n_train'], config['use_prev_frames'], spectrogram.shape[1]))
for i in range(config['use_prev_frames']):
X_train[:, i, :] = spectrogram[i:i + config['n_train'], :]
y_train = spectrogram[config['use_prev_frames']:config['n_train']+config['use_prev_frames'], :]
rnn = get_model((X_train.shape[1], X_train.shape[2]),
batch_input_shape=(config['batch_size'], X_train.shape[1], X_train.shape[2]))
callbacks = get_callbacks(fname, config)
history = rnn.fit(X_train, y_train, epochs=config['n_epochs'], batch_size=config['batch_size'],
validation_split=0.1,
verbose=1, shuffle=False, callbacks=callbacks)
write_keras_model(fname, config, 'rnn', rnn)
# plot_history(fname, config, 'rnn', history)
output_spectrogram = np.zeros((config['n_test'] + config['use_prev_frames'], spectrogram.shape[1]))
output_spectrogram[:config['use_prev_frames'], :] = spectrogram[config['test_offset']:config['test_offset']
+ config['use_prev_frames'], :]
rnn2 = get_model((X_train.shape[1], X_train.shape[2]),
batch_input_shape=(1, X_train.shape[1], X_train.shape[2]))
rnn2.set_weights(rnn.get_weights())
print('Running prediction')
for i in range(config['n_test']):
rnn_input = output_spectrogram[i:i + config['use_prev_frames'], :].reshape([1, config['use_prev_frames'], -1])
rnn_output = rnn2.predict(rnn_input)
rnn_output = rnn_output.clip(0., 1.)
output_spectrogram[config['use_prev_frames'] + i, :] = rnn_output
convert_output_to_audio(output_spectrogram, config, mm_scaler, melfilters, fname, 'rnn')
def train(batch_size=32, input_size=224, model_name='inception', epochs=10):
logger.critical(f'Start training {model_name} for {epochs} epochs.')
train_generator, validation_generator, _ = data_reader.get_generators(
batch_size, input_size)
model = models.get_model(model_name)
callbacks = utils.get_callbacks(model_name)
# train the model on the new data for a few epochs
history = model.fit(train_generator,
validation_data=validation_generator,
epochs=epochs,
shuffle=True,
use_multiprocessing=False,
verbose=1,
callbacks=callbacks)
logger.critical(f'Finish training {model_name}.')
return history
def train_model():
train_gen = train_data()
X_test, y_test = test_data()
model = keras_model.vgg(input_shape=utils.TARGET_SIZE + (1, ))
print(model.input_shape)
print(model.output_shape)
callbacks = utils.get_callbacks('./logs')
model.fit_generator(train_gen,
steps_per_epoch=6000 / utils.BATCH_SIZE,
epochs=500,
verbose=1,
callbacks=callbacks,
validation_data=(X_test, y_test),
validation_steps=len(X_test) / utils.BATCH_SIZE)
def main(gpu, arch, bands, weighted, epochs):
"""TODO"""
logger = logging.getLogger(__name__)
logger.info("TODO")
np.random.seed(42)
torch.cuda.set_device(gpu)
pre_name = f"arch-{arch}-bands-{bands}-scale-True-epochs-20"
name = f"arch-unet-{arch}-bands-{bands}-weighted-{weighted}-epochs-{epochs}"
arch, bands = get_arch_bands(arch, bands)
if arch is None or bands is None:
return
data = get_data(bands, bs=8)
if arch in [resnet18, resnet34, resnet50, resnet101, resnet152]:
cut = -2
learn = get_learn(data, arch, name, weighted, cut=cut)
else:
cut = -3
model = get_model(arch, bands, pre_name)
learn = get_learn(data,
lambda pretrained: model,
name,
weighted,
cut=cut)
cbs = get_callbacks(learn, name, "f_beta")
learn.lr_find()
learn.recorder.plot(suggestion=True, return_fig=True)
plt.savefig(f"reports/figures/{name}-lr")
learn_rate = learn.recorder.min_grad_lr * 100
learn.fit_one_cycle(epochs, slice(learn_rate), callbacks=cbs)
learn.recorder.plot_losses()
plt.savefig(f"reports/figures/{name}-losses")
learn.recorder.plot_metrics()
plt.savefig(f"reports/figures/{name}-metrics")
learn.save(f"{name}")
learn.export(f"{name}/{name}.pkl")
state_dict = learn.model.state_dict()
torch.save(state_dict, f"models/{name}/{name}-state-dict")
def get_trainer(args, dls):
"""
Return the PyTorch Lightning Trainer.
"""
# Logger and callbacks
logger = get_logger(args)
callbacks = get_callbacks(args)
# Trainer
trainer_args = {
'gpus': args.num_gpus,
'max_epochs': args.epochs,
'deterministic': True,
'callbacks': callbacks,
'logger': logger,
'max_steps': args.epochs * len(dls['train_aug']),
'stochastic_weight_avg': True,
}
trainer = pl.Trainer(**trainer_args)
return trainer
# type:
#'AE'=autoencoder
#'VAE'=variational autoencoder
#'DFC_VAE'=deep feature consistent variational autoencoder
model, encoder, decoder, lossModel, encoded = build_model(type='DFC_VAE')
#hyper parameters
epochs = 50
batch_size = 128
learning_rate = 1e-6
optimizer = keras.optimizers.Adam(lr=learning_rate, clipnorm=1)
#callbacks
callback_list = get_callbacks()
model.compile(optimizer=optimizer)
model.fit(
X_train,
batch_size=batch_size,
epochs=epochs,
verbose=1, #initial_epoch=,
validation_data=(X_val, None),
callbacks=callback_list)
model_train = model.history
loss = model_train.history['loss']
val_loss = model_train.history['val_loss']
train_data['inc_angle'] = train_data['inc_angle'].replace('na', 0)
train_data['inc_angle'] = train_data['inc_angle'].astype(float).fillna(0.0)
if TEST:
SEED = np.random.randint(9999)
else:
SEED = 42 # Constant seed for comparability between runs
X = generate_data(train_data)
y = train_data['is_iceberg']
X_train, X_val, y_train, y_val = train_test_split(X,
y,
train_size=.8,
random_state=SEED)
callback_list = get_callbacks(WEIGHT_SAVE_PATH, 20)
model = build_model()
start_time = time.time()
if USE_AUGMENTATION:
image_augmentation = ImageDataGenerator(rotation_range=20,
horizontal_flip=True,
vertical_flip=True,
width_shift_range=.3,
height_shift_range=.3,
zoom_range=.1)
model.fit_generator(image_augmentation.flow(X_train, y_train),
steps_per_epoch=4096 / BATCH_SIZE,
epochs=EPOCHS,
def train_vgg16(X_train, X_angle, target_train, X_test, X_test_angle, K):
print("Running vgg16")
folds = list(
StratifiedKFold(n_splits=K, shuffle=True,
random_state=16).split(X_train, target_train))
y_test_pred_log = 0
y_train_pred_log = 0
y_valid_pred_log = 0.0 * target_train
for j, (train_idx, test_idx) in enumerate(folds):
print('\n===================FOLD=', j + 1)
limit_mem()
X_train_cv = X_train[train_idx]
y_train_cv = target_train[train_idx]
X_holdout = X_train[test_idx]
Y_holdout = target_train[test_idx]
#Angle
X_angle_cv = X_angle[train_idx]
X_angle_hold = X_angle[test_idx]
#define file path and get callbacks
file_path = "%s_aug_model_weights.hdf5" % j
callbacks = get_callbacks(filepath=file_path, patience=10)
gen_flow = gen_flow_for_two_inputs(X_train_cv, X_angle_cv, y_train_cv)
galaxyModel = Vgg16Model()
galaxyModel.fit_generator(gen_flow,
steps_per_epoch=24,
epochs=100,
shuffle=True,
verbose=1,
validation_data=([X_holdout,
X_angle_hold], Y_holdout),
callbacks=callbacks)
#Getting the Best Model
galaxyModel.load_weights(filepath=file_path)
#Getting Training Score
score = galaxyModel.evaluate([X_train_cv, X_angle_cv],
y_train_cv,
verbose=0)
print('Train loss:', score[0])
print('Train accuracy:', score[1])
#Getting Test Score
score = galaxyModel.evaluate([X_holdout, X_angle_hold],
Y_holdout,
verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
#Getting validation Score.
pred_valid = galaxyModel.predict([X_holdout, X_angle_hold])
y_valid_pred_log[test_idx] = pred_valid.reshape(pred_valid.shape[0])
#Getting Test Scores
temp_test = galaxyModel.predict([X_test, X_test_angle])
y_test_pred_log += temp_test.reshape(temp_test.shape[0])
#Getting Train Scores
temp_train = galaxyModel.predict([X_train, X_angle])
y_train_pred_log += temp_train.reshape(temp_train.shape[0])
y_test_pred_log = y_test_pred_log / K
y_train_pred_log = y_train_pred_log / K
print('\n Train Log Loss Validation= ',
log_loss(target_train, y_train_pred_log))
print(' Test Log Loss Validation= ',
log_loss(target_train, y_valid_pred_log))
return y_test_pred_log
from vae import Vae
from utils import get_tokenizer, Args, get_dataloader, get_logger, get_callbacks
import pytorch_lightning as pl
import torch
if __name__ == "__main__":
with open(sys.argv[1]) as f:
config = json.load(f)
args = Args(**config)
args.gpus = torch.cuda.device_count()
args.distributed_backend = 'ddp' if args.gpus > 1 else None
tokenizer = get_tokenizer(args.vocab_type)
args.vocab_size = tokenizer.vocab_size
train_dl = get_dataloader(args, tokenizer, type='train')
model = Vae(args)
logger = get_logger(args)
callbacks = get_callbacks(args)
trainer = pl.Trainer(max_steps=args.max_steps,
gpus=args.gpus,
logger=logger,
log_every_n_steps=args.log_steps,
callbacks=callbacks,
distributed_backend=args.distributed_backend)
trainer.fit(model, train_dl)
# with open(runPath+'/model_summary.txt', 'w') as f:
# with redirect_stdout(f): model.summary()
# Multi-gpu setup:
basemodel = model
if args.gpus > 1: model = multi_gpu_model(model, gpus=args.gpus)
# Optimizer
optimizer = Adam(lr=args.lr, amsgrad=True)
# Compile the model
print(
'\n\n\n', 'Compiling model..', runID, '\n\n\tGPU ' +
(str(args.gpus) + ' gpus' if args.gpus > 1 else args.gpuids) +
'\t\tBatch size [ ' + str(args.bs) + ' ] ' + ' \n\n')
model.compile(loss=depth_loss_function, optimizer=optimizer)
print('Ready for training!\n')
callbacks = get_callbacks(runPath)
# Start training
model.fit_generator(train_generator,
callbacks=callbacks,
validation_data=test_generator,
epochs=args.epochs,
shuffle=True)
# Save the final trained model:
basemodel.save(runPath + '/model.h5')
max_words = 100000000
WINDOW = 4
tokenizer = Tokenizer(num_words=max_words,
filters='"#$%&()*+-/:;<=>@[\]^_`{|}~')
tokenizer.fit_on_texts(text)
X_train = tokenizer.texts_to_sequences(text)
print('Train shape:', np.array(X_train).shape)
X_train_time, Y_train_time = create_dataset(np.array(X_train), WINDOW)
vocab_size = len(tokenizer.word_index) + 1
y = to_categorical(Y_train_time, num_classes=vocab_size)
print('Vocabulary size: ', vocab_size)
save_labels('models/labels.dump', Y_train_time, y)
save_tokenizer(FILE_NAME)
model = build_model(vocab_size, WINDOW)
model.fit(X_train_time,
y,
epochs=50,
batch_size=16,
validation_split=0.1,
verbose=1,
callbacks=get_callbacks(),
shuffle=False)
for path in os.listdir("data1") \
if '.mid' in path or '.midi' in path]
print(len(midi_files))
experiment_dir = utils.create_experiment_dir('experiment_dir4', 1)
val_split = 0.2
val_split_index = int(float(len(midi_files)) * val_split)
train_generator = utils.get_data_generator(midi_files[0:val_split_index])
val_generator = utils.get_data_generator(midi_files[val_split_index:])
callbacks = utils.get_callbacks(experiment_dir)
batch_size = 60
start_time = time.time()
num_epochs = 10
model.fit_generator(train_generator,
steps_per_epoch=len(midi_files) * 600 / batch_size,
epochs=num_epochs,
validation_data=val_generator,
validation_steps=0.2 * len(midi_files) * 600 / batch_size,
verbose=1,
callbacks=callbacks,
initial_epoch=0)
log('Finished in {:.2f} seconds'.format(time.time() - start_time), 1)
def main(_):
assert '.yaml' in FLAGS.config, 'Please provide path to yaml file.'
cfg = get_default_config()
cfg.merge_from_file(FLAGS.config)
cfg.freeze()
model_dir = FLAGS.model_dir
if not tf.io.gfile.exists(model_dir):
tf.io.gfile.makedirs(model_dir)
# init wandb
if cfg.WANDB.ENABLE:
wandb.tensorboard.patch(root_logdir=model_dir)
wandb.init(job_type='train',
group=cfg.WANDB.GROUP_NAME,
project=cfg.WANDB.PROJECT_NAME,
sync_tensorboard=cfg.WANDB.TENSORBOARD,
mode=cfg.WANDB.MODE,
config=dict(cfg),
resume=True)
if FLAGS.debug:
tf.config.run_functions_eagerly(True)
tf.debugging.set_log_device_placement(True)
os.environ['TF_DETERMINISTIC_OPS'] = '1'
tf.random.set_seed(1111)
logging.set_verbosity(logging.DEBUG)
tf.debugging.experimental.enable_dump_debug_info(
model_dir,
tensor_debug_mode="FULL_HEALTH",
circular_buffer_size=-1)
strategy = utils.get_strategy(FLAGS.num_gpus)
# mixed precision
precision = utils.get_precision(FLAGS.mixed_precision)
policy = tf.keras.mixed_precision.Policy(precision)
tf.keras.mixed_precision.set_global_policy(policy)
def get_dataset(cfg, file_pattern, is_training):
"""Returns a tf.data.Dataset"""
return dataloader.InputReader(
cfg, is_training, FLAGS.use_tfrecord, FLAGS.mixed_precision)(
file_pattern,
cfg.TRAIN.BATCH_SIZE if is_training else cfg.TEST.BATCH_SIZE)
def load_model(model, cfg):
"""Compile model with loss function, model optimizers and metrics."""
opt_str = cfg.TRAIN.OPTIMIZER.lower()
if opt_str == 'sgd':
opt = tf.optimizers.SGD(learning_rate=cfg.TRAIN.WARMUP_LR,
momentum=cfg.TRAIN.MOMENTUM,
nesterov=True)
elif opt_str == 'adam':
opt = tf.optimizers.Adam(learning_rate=cfg.TRAIN.WARMUP_LR)
else:
raise NotImplementedError(f'{opt_str} not supported')
if FLAGS.mixed_precision:
opt = tf.keras.mixed_precision.LossScaleOptimizer(opt)
model.compile(
optimizer=opt,
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=[
tf.keras.metrics.SparseCategoricalAccuracy(name='acc'),
tf.keras.metrics.SparseTopKCategoricalAccuracy(
k=5, name='top_5_acc')
])
return model
# learning rate schedule
def lr_schedule(epoch, lr):
"""
Implements the learning rate schedule used in
https://arxiv.org/abs/2004.04730
"""
if epoch > cfg.TRAIN.WARMUP_EPOCHS:
new_lr = cfg.TRAIN.BASE_LR * (0.5 * (
tf.math.cos(tf.constant(math.pi) *
(epoch / cfg.TRAIN.EPOCHS)) + 1))
else:
new_lr = cfg.TRAIN.WARMUP_LR + (
epoch * (cfg.TRAIN.BASE_LR - cfg.TRAIN.WARMUP_LR) /
cfg.TRAIN.WARMUP_EPOCHS)
return new_lr
with strategy.scope():
model = X3D(cfg)
model = load_model(model, cfg)
# resume training from latest checkpoint, if available
current_epoch = 0
ckpt_path = tf.train.latest_checkpoint(model_dir)
if ckpt_path:
current_epoch = int(os.path.basename(ckpt_path).split('-')[1])
logging.info(
f'Found checkpoint {ckpt_path} at epoch {current_epoch}')
model.load_weights(ckpt_path)
elif FLAGS.pretrained_ckpt:
logging.info(
f'Loading model from pretrained weights at {FLAGS.pretrained_ckpt}'
)
if tf.io.gfile.isdir(FLAGS.pretrained_ckpt):
model.load_weights(
tf.train.latest_checkpoint(FLAGS.pretrained_ckpt))
else:
model.load_weights(FLAGS.pretrained_ckpt)
model.fit(
get_dataset(cfg, FLAGS.train_file_pattern, True),
verbose=1,
epochs=cfg.TRAIN.EPOCHS,
initial_epoch=current_epoch,
steps_per_epoch=cfg.TRAIN.DATASET_SIZE // cfg.TRAIN.BATCH_SIZE,
validation_data=get_dataset(cfg, FLAGS.val_file_pattern, False)
if FLAGS.val_file_pattern else None,
callbacks=utils.get_callbacks(cfg, lr_schedule, FLAGS))
def main(args):
"""Train (and evaluate) a GRU-based model for classifying toxic content in
wikipedia comments. Takes a preprocessed (cleaned, tokenized, and padded)
comments as input and outputs the probability of six different types of toxicity
being contained in the comment. Execution is modified by a number of call
arguments, described below.
Parameters
----------
--train (-t) : (Re)train the model. Leave this out if only doing inference or
only evaluating on test set.
--auxilliary_input (-a) : Use auxilliary input to the model for training and
testing. Auxilliary input consists of class probabilities calculated using
ridge regression. Requires that said auxilliary input is already generate
for a given input sentence.
--combine_data (-c) : Combine training and test data with additional figshare
comments when fitting tokenizer to data.
--submit (-s) : Turn test predictions into a submission for Kaggle.
--visualise (-v) : Visualise attention activations for a sentence.
--fasttext (-f) : Use word embeddings trained using fasttext instead of
pre-trained GloVe embeddings.
"""
TRAIN = args.train
USE_AUXILLIARY_INPUT = args.auxilliary_input
COMBINE_DATA = args.combine_data
MAKE_SUBMISSION = args.submit
VISUALISE_FULL_ATTENTION = args.visualise
USE_FASTTEXT = args.fasttext
MAX_NUM_WORDS = None
MAX_LENGTH = 150
EMBEDDING_DIM = 300
SKIPGRAM = True
MAX_EPOCHS = 50
BATCH_SIZE = 512
VAL_SPLIT = 0.2
SENTENCE_NUM = 51
TOXICITY_THRESHOLD = 0.6
AVERAGE_ATTENTION = False
BASE_LR = 0.0001
MAX_LR = 0.005
STEP_SIZE = 30000
CLR_MODE = 'triangular'
now = datetime.datetime.now()
now = now.strftime('%Y%m%d%H%M')
LOG_PATH = './logs/' + now
WEIGHT_SAVE_PATH = 'weights_base.best.hdf5'
SUBMISSION_SAVE_PATH = './submissions/submission_' + now + '.csv'
ES_PATIENCE = 6
TB_HIST_FREQ = 0
TB_WRITE_GRAPH = True
clr_params = {
'base_lr': BASE_LR,
'max_lr': MAX_LR,
'step_size': STEP_SIZE,
'mode': CLR_MODE
}
ckpt_params = {
'filepath': WEIGHT_SAVE_PATH,
'verbose': 1,
'save_best_only': True,
'save_weights_only': True
}
es_params = {'patience': ES_PATIENCE}
tb_params = {
'log_dir': LOG_PATH,
'histogram_freq': TB_HIST_FREQ,
'write_graph': TB_WRITE_GRAPH,
'batch_size': BATCH_SIZE,
'embeddings_freq': MAX_EPOCHS + 1
}
callbacks = get_callbacks(clr_params, ckpt_params, es_params, tb_params)
CLASS_LIST = [
'toxic', 'severe_toxic', 'obscene', 'threat', 'insult', 'identity_hate'
]
txt_prep = TextPreprocessor(max_nb_words=MAX_NUM_WORDS,
max_padding_length=MAX_LENGTH,
combine_data=COMBINE_DATA,
use_auxilliary_features=USE_AUXILLIARY_INPUT)
if USE_AUXILLIARY_INPUT:
X_train, X_aux, y_train, X_test, test_aux, word_index, sample_text, sample_target = \
txt_prep.load_and_tokenize(class_list=CLASS_LIST,
sample_index=SENTENCE_NUM)
else:
X_train, y_train, X_test, word_index, sample_text, sample_target = \
txt_prep.load_and_tokenize(class_list=CLASS_LIST,
sample_index=SENTENCE_NUM)
tc = ToxicClassifier(embedding_dim=EMBEDDING_DIM,
num_timesteps=MAX_LENGTH,
word_index=word_index,
weight_path=WEIGHT_SAVE_PATH,
use_aux_input=USE_AUXILLIARY_INPUT,
average_attention=AVERAGE_ATTENTION,
use_ft=USE_FASTTEXT,
visualize=VISUALISE_FULL_ATTENTION)
if USE_AUXILLIARY_INPUT:
tc.set_input_and_labels(X_train, y_train, X_aux)
tc.set_sample_sentence(sample_text, X_train[SENTENCE_NUM],
y_train[SENTENCE_NUM], X_aux[SENTENCE_NUM])
else:
tc.set_input_and_labels(X_train, y_train)
tc.set_sample_sentence(sample_text, X_train[SENTENCE_NUM],
y_train[SENTENCE_NUM])
tc.build_model(word_index=word_index, use_skipgram=SKIPGRAM)
tc.model.summary()
if TRAIN:
tc.train(max_epochs=MAX_EPOCHS,
batch_size=BATCH_SIZE,
val_split=VAL_SPLIT,
callbacks=callbacks)
sample_pred = tc.predict_sample_output()
print('Original sentence: ', sample_text)
print('Actual label: ', sample_target)
print('Model prediction :', sample_pred[0, :])
present_toxicity = get_toxicity_classes(sample_pred[0, :],
TOXICITY_THRESHOLD, CLASS_LIST)
print_toxicity_report(sample_pred[0, :], TOXICITY_THRESHOLD,
CLASS_LIST)
if VISUALISE_FULL_ATTENTION:
visualise_attention(tc.attention_history, sample_text)
else:
attention = tc.get_attention_output()
attention /= sum(attention) # Normalise to percentage
label = tc.get_sample_labels()
visualise_attention_with_text(attention, sample_text,
sample_pred[0, :], present_toxicity,
sample_target, label)
if MAKE_SUBMISSION:
print('Loading best weights and predicting on test data\n')
if USE_AUXILLIARY_INPUT:
make_aux_submission(tc.model,
X_test,
test_aux,
CLASS_LIST,
WEIGHT_SAVE_PATH,
SUBMISSION_SAVE_PATH,
post_process=True)
else:
make_submission(tc.model, X_test, CLASS_LIST, WEIGHT_SAVE_PATH,
SUBMISSION_SAVE_PATH)
datagen = get_image_generator()
# define triplet network model
base_model = base_network_vgg(input_shape=img_size)
triplet_model = triplet_network(base_model=base_model, input_shape=img_size)
print("Base model:")
base_model.summary()
print("\nTriplet model:")
triplet_model.summary()
# callbacks
callbacks = get_callbacks(
"./models/dresses-s2s-iteration1-ckpt.h5",
initial_learning_rate=0.0002,
learning_rate_drop=0.5,
learning_rate_epochs=50,
learning_rate_patience=50,
early_stopping_patience=50)
triplet_model.compile(optimizer=opt, loss=lossless_triplet_loss)
# data generator
training_generator = s2s_generator(
duplets,
catalog_images,
batch_size=batch_size)
# fit the model
history = triplet_model.fit_generator(
# Pre-train preparation
batch_size = 64
file_path = "../weights_resnet1.hdf5"
train_generator = augmentors.train_datagen_1.flow(X_train_cv,
y_train_cv,
batch_size=batch_size)
validation_generator = augmentors.test_datagen_1.flow(
X_valid, y_valid, batch_size=batch_size)
# Load Model
model = Keras_CNN.simple_resnet_v1()
optimizer = Adam(lr=0.0005, beta_1=0.9, beta_2=0.999,
epsilon=1e-08) # decay=0.0015) # Optimizer
callbacks = utils.get_callbacks(filepath=file_path,
patience=15,
save_best=True) # Callbacks
model.compile(optimizer=optimizer,
loss='binary_crossentropy',
metrics=['accuracy']) # Compile
model.fit_generator(
train_generator,
steps_per_epoch=128,
epochs=200,
verbose=1,
validation_data=(X_valid, y_valid),
# validation_data = validation_generator,
# validation_steps = len(X_valid)/batch_size,
callbacks=callbacks)
print('Fit Model.........Done')
