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')