def train(model=model()): dataset = build_dataset() callback = TensorBoard("_tensor_board") callback.set_model(model) labels = interested_words for i in range(10000): model.save("latest.hdf5") print("Chunk " + str(i) + " of 10000...") X, Y = get_batch(dataset, batchsize=100) for j in range(10): #print(np.shape(X)) logs = model.train_on_batch(np.array(X), np.array(Y)) print("loss:", logs) write_log(callback, ["training loss"], [logs], i * 10 + j) X, Y = get_batch(dataset, batchsize=100, batchtype="test") results = model.predict(X) accuracy = 0 for result, actual in zip(results, Y): #print("running test") x = np.argmax(result) j = np.argmax(actual) try: print("expected " + labels[j], " got " + labels[x]) except: pass if x == j: accuracy += 1 write_log(callback, ["test accuracy"], [accuracy], i)
def train_model(model, dataset): log.info("training model (train on %d samples, validate on %d) ..." % ( \ len(dataset.Y_train), len(dataset.Y_val) ) ) loss = 'binary_crossentropy' optimizer = 'adam' metrics = ['accuracy'] model.compile(loss=loss, optimizer=optimizer, metrics=metrics) earlyStop = EarlyStopping(monitor='val_acc', min_delta=0.0001, patience=5, mode='auto') log_dir = os.path.join(dataset.path, "logs/{}".format(time.time())) tensorboard = TensorBoard( \ log_dir = log_dir, histogram_freq = 1, write_graph = True, write_grads = True, write_images = True) tensorboard.set_model(model) return model.fit(dataset.X_train, dataset.Y_train, batch_size=64, epochs=50, verbose=2, validation_data=(dataset.X_val, dataset.Y_val), callbacks=[tensorboard, earlyStop])
def train(self, epochs, batch_size=128, save_interval=50): # Adversarial ground truths valid = np.ones((batch_size, 1)) fake = np.zeros((batch_size, 1)) start_time = datetime.datetime.now() tensorboard = TensorBoard(batch_size=batch_size, write_grads=True) tensorboard.set_model(self.combined) def named_logs(model, logs): result = {} for l in zip(model.metrics_names, logs): result[l[0]] = l[1] return result for epoch in range(epochs): # --------------------- # Train Discriminator # --------------------- # Select a random half of images imgs = self.data_loader.load_data(batch_size) # Sample noise and generate a batch of new images noise = np.random.normal(0, 1, (batch_size, self.latent_dim)) gen_imgs = self.generator.predict(noise) # Train the discriminator (real classified as ones and generated as zeros) d_loss_real = self.discriminator.train_on_batch(imgs, valid) d_loss_fake = self.discriminator.train_on_batch(gen_imgs, fake) d_loss = np.add(d_loss_real, d_loss_fake) # --------------------- # Train Generator # --------------------- # Train the generator (wants discriminator to mistake images as real) g_loss = self.combined.train_on_batch(noise, valid) elapsed_time = datetime.datetime.now() - start_time # Plot the progress print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f] time: %s" % (epoch, d_loss[0], 100 * d_loss[1], g_loss, elapsed_time)) tensorboard.on_epoch_end(epoch, named_logs(self.combined, [g_loss])) # If at save interval => save generated image samples if epoch % save_interval == 0: self.save_imgs(epoch) self.combined.save_weights( f"saved_model/{self.dataset_name}/{epoch}.h5") self.save_imgs(epochs - 1) self.combined.save_weights( f"saved_model/{self.dataset_name}/{epoch}.h5")
def set_callbacks(self): """Setup callbacks""" p = self.params if p.logs_root is not None: log_dir = os.path.join(p.logs_root, self.model_name()) tb_callback = TensorBoard(log_dir=log_dir, write_graph=p.write_graph, histogram_freq=0, write_images=p.write_images) tb_callback.set_model(self.model) else: tb_callback = None # separator = self.model_name._ShortNameBuilder__sep[1] best_model_path = os.path.join(p.models_root, self.model_name() + '_best_weights.h5') make_dirs(best_model_path) checkpointer = ModelCheckpoint(filepath=best_model_path, verbose=0, monitor=p.monitor_metric, mode=p.monitor_mode, period=p.checkpoint_period, save_best_only=p.save_best_only, save_weights_only=True) earlystop = EarlyStopping(monitor=p.monitor_metric, patience=p.early_stop_patience, mode=p.monitor_mode) return [earlystop, checkpointer ] + ([tb_callback] if tb_callback else [])
def train_model(self, max_iters=100000, number_of_steps=10, log_path='./log', debug=False): tb = TensorBoard(log_path) tb.set_model(self.rl_model) self.beta_schedule = LinearSchedule(100000, initial_p=0.4, final_p=1.0) epsilon = 1. for i in range(max_iters): if epsilon > 0.1: epsilon *= 0.98 with timer('all', i): reward, step, loss = self.train_iterator( debug, i, number_of_steps, epsilon) if not debug: summary = tf.Summary() reward_value = summary.value.add() reward_value.simple_value = reward reward_value.tag = 'reward' step_value = summary.value.add() step_value.simple_value = step step_value.tag = 'step' if len(loss) > 0: loss_value = summary.value.add() loss_value.simple_value = sum(loss) / len(loss) loss_value.tag = 'loss' tb.writer.add_summary(summary, i) tb.writer.flush() #sys.stdout.write('\r'+str(i)) if (i + 1) % 10000 is 0: self.save_model(i / 10000 + 1)
def train(model, dataset, checkpoint_file, epochs, embeddings_path): """ Trains model with the given data set. :param model: model to be trained :param dataset: dataset to train with :param checkpoint_file: path of file for storing weights :param epochs: number of executed epochs :param embeddings_path: Path of embeddings file, which is used to visualized word vectors via Tensorboard """ # define the checkpoint logger.info('Storing weights in %s', checkpoint_file) checkpoint_cb = ModelCheckpoint(checkpoint_file, monitor='loss', verbose=1, mode='min', save_best_only=True) # Tensorboard callack tensorboard_cb = TensorBoard(log_dir=TENSORBOARD_LOGS_DIR, write_graph=True, embeddings_metadata=str(embeddings_path), embeddings_freq=1) tensorboard_cb.set_model(model) # prediction/validation callback prediction_cb = partial(epoch_end_prediction, model=model, dataset=dataset) prediction_cb = LambdaCallback(on_epoch_end=prediction_cb) # learning rate decay # learning_rate_decay_db = LearningRateReducer(reduce_rate=0.1) # fit the model callbacks = [checkpoint_cb, tensorboard_cb, prediction_cb] # adapt weights for proper handling of under-represented classes word_counts = dataset.output_word_counts counts_no_unk = { w: c for w, c in word_counts.items() if w != dataset.oov_token } max_count = np.max(list(counts_no_unk.values())) min_count = np.min(list(counts_no_unk.values())) # normalize weights between 0.66 and 2.0 def class_weight(word_id): word_count = dataset.output_word_counts[ dataset.output_word_ids[word_id]] return 1.0 / ((word_count - min_count) / (max_count - min_count) + 0.5) class_weights = {w: class_weight(w) for w in dataset.output_word_ids} # class_weights = {w: 1.0 for w in dataset.output_vocab.values()} # ToDo: remove class_weights[dataset.output_unk_id] = 1e-7 # decrease loss for UNK model.fit_generator(generator=dataset, epochs=epochs, verbose=1, callbacks=callbacks, shuffle=True, class_weight=class_weights)
def create_initial_model(name): full_filename = os.path.join(conf['MODEL_DIR'], name) + ".h5" if os.path.isfile(full_filename): model = load_model(full_filename, custom_objects={'loss': loss}) return model model = build_model(name) # Save graph in tensorboard. This graph has the name scopes making it look # good in tensorboard, the loaded models will not have the scopes. tf_callback = TensorBoard(log_dir=os.path.join(conf['LOG_DIR'], name), histogram_freq=0, batch_size=1, write_graph=True, write_grads=False) tf_callback.set_model(model) tf_callback.on_epoch_end(0) tf_callback.on_train_end(0) from self_play import self_play self_play(model, n_games=conf['N_GAMES'], mcts_simulations=conf['MCTS_SIMULATIONS']) model.save(full_filename) best_filename = os.path.join(conf['MODEL_DIR'], 'best_model.h5') model.save(best_filename) return model
def train(reward_dict): input_shape = [9, 17, 17] output_shape = [3] x_train, x_test, y_train, y_test = extract_train_and_test(reward_dict, input_shape) steps_per_epoch = 10 # steps_per_epoch / num_validation_steps == num_training_examples / num_testing_examples num_classes = 3 epochs = 6 tensor_board_path = Path('logs/{}'.format(time.time())) tensor_board = TensorBoard(log_dir=str(tensor_board_path), write_graph=True, write_images=True, ) model = create_model(input_shape, num_classes) tensor_board.set_model(model) model.fit(x_train, y_train, steps_per_epoch=steps_per_epoch, validation_steps=21, epochs=epochs, verbose=1, validation_data=(x_test, y_test), callbacks=[tensor_board]) score = model.evaluate(x_test, y_test, verbose=0) print('Test loss:', score[0]) print('Test accuracy:', score[1]) return model
def main(not_parsed_args): # we use a margin loss model = CapsNet() last_epoch = load_weights(model) model.compile(loss=margin_loss, optimizer=optimizers.Adam(FLAGS.lr), metrics=['accuracy']) model.summary() dataset = Dataset(FLAGS.dataset, FLAGS.batch_size) tensorboard = TensorBoard(log_dir='./tf_logs', batch_size=FLAGS.batch_size, write_graph=False, write_grads=True, write_images=True, update_freq='batch') tensorboard.set_model(model) for epoch in range(last_epoch, FLAGS.epochs): logging.info('Epoch %d' % epoch) model.fit_generator(generator=dataset, epochs=1, steps_per_epoch=len(dataset), verbose=1, validation_data=dataset.eval_dataset, validation_steps=len(dataset.eval_dataset)) logging.info('Saving model') filename = 'model_%d.h5' % (epoch) path = os.path.join(FLAGS.model_dir, filename) path_info = os.path.join(FLAGS.model_dir, 'info') model.save_weights(path) f = open(path_info, 'w') f.write(filename) f.close()
def train(self, epochs, batch_size, sample_interval): def named_logs(model, logs): result = {} for l in zip(model.metrics_names, logs): result[l[0]] = l[1] return result start_time = datetime.datetime.now() valid = np.ones((batch_size, 1)) fake = np.zeros((batch_size, 1)) max_iter = int(self.n_data / batch_size) os.makedirs(f"{self.backup_dir}/logs/{self.time}", exist_ok=True) tensorboard = TensorBoard(f"{self.backup_dir}/logs/{self.time}") tensorboard.set_model(self.generator) os.makedirs(f"{self.backup_dir}/models/{self.time}/", exist_ok=True) with open( f"{self.backup_dir}/models/{self.time}/generator_architecture.json", "w") as f: f.write(self.generator.to_json()) print( f"\nbatch size : {batch_size} | num_data : {self.n_data} | max iteration : {max_iter} | time : {self.time} \n" ) for epoch in range(1, epochs + 1): for iter in range(max_iter): # ------------------ # Train Generator # ------------------ ref_imgs = self.dl.load_data(batch_size) noise = np.random.normal(0, 1, (batch_size, self.latent_dim)) gen_imgs = self.generator.predict(noise) make_trainable(self.discriminator, True) d_loss_real = self.discriminator.train_on_batch( ref_imgs, valid * 0.9) # label smoothing *0.9 d_loss_fake = self.discriminator.train_on_batch(gen_imgs, fake) d_loss = 0.5 * np.add(d_loss_real, d_loss_fake) make_trainable(self.discriminator, False) logs = self.combined.train_on_batch([noise], [valid]) tensorboard.on_epoch_end(iter, named_logs(self.combined, [logs])) if iter % (sample_interval // 10) == 0: elapsed_time = datetime.datetime.now() - start_time print( f"epoch:{epoch} | iter : {iter} / {max_iter} | time : {elapsed_time} | g_loss : {logs} | d_loss : {d_loss} " ) if (iter + 1) % sample_interval == 0: self.sample_images(epoch, iter + 1) # save weights after every epoch self.generator.save_weights( f"{self.backup_dir}/models/{self.time}/generator_epoch{epoch}_weights.h5" )
def train(self, epochs=11, batch_size=32, sample_interval=10, save_interval=10, enable_plot=False): if enable_plot: log_path = self.DIR + self.dataset_name + '/graphs/wgan' callback = TensorBoard(log_path) callback.set_model(self.generator_model) train_names = [ 'D_loss', 'G_loss', ] # Adversarial ground truths valid = -np.ones((batch_size, 1)) fake = np.ones((batch_size, 1)) dummy = np.zeros((batch_size, 1)) for epoch in range(epochs): for _ in range(self.n_critic): # --------------------- # Train Discriminator # --------------------- # Select a random half of images idx = np.random.randint(0, self.train_data.shape[0], batch_size) imgs = self.train_data[idx] # Sample noise and generate a batch of new images noise = np.random.normal(0, 1, (batch_size, self.latent_dim)) # Train the critic d_loss = self.critic_model.train_on_batch([imgs, noise], [valid, fake, dummy]) # --------------------- # Train Generator # --------------------- g_loss = self.generator_model.train_on_batch(noise, valid) # Plot the progress if enable_plot: self.write_log(callback, train_names, np.asarray([d_loss[0], g_loss]), epoch) print ( '%d [D loss: %f] [G loss: %f]' % \ ( epoch, d_loss[ 0 ], g_loss ) ) # If at save interval => save generated image samples if epoch % sample_interval == 0: self.sample_imgs(epoch) if epoch % save_interval == 0: save_dir = os.path.join(self.DIR, self.dataset_name, 'wgan_saved_weights', 'background') os.makedirs(save_dir, exist_ok=True) save_name = os.path.join(save_dir, 'g_' + str(epoch) + '.hdf5') self.generator.save_weights(save_name)
def train_model(model, epochs, x_test, y_test, x_train, y_train, weights_path, log_path, learning_rate): """ Training a model on training data, while evaluating it on the validation set Args: model: Keras model to train epochs: number of epochs the model should be trained for x_train: training data x_test: validation data y_train: training labels y_test: validation labels weights_path: the filepath of weights of the model, if existant log_path: filepath of were to log data about training into learning_rate: learning rate used to train the model Returns: - """ adam = optimizers.Adam(lr=learning_rate) sdg = optimizers.SGD(lr=learning_rate, momentum=0.0, decay=0.0, nesterov=False) model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['accuracy']) if os.path.isfile(weights_path): model.load_weights(weights_path, by_name=False) cb = callbacks.Callback() cb.set_model(model) tensorboard = TensorBoard(log_dir=log_path) tensorboard.set_model(model) checkpoint = ModelCheckpoint(weights_path, monitor='val_acc', verbose=1, save_best_only=False, mode='max') #early_stop = EarlyStopping(monitor='val_loss', patience=5, verbose=0) callbacks_list = [checkpoint, cb, tensorboard] model.fit(x_train, y_train, batch_size=256, epochs=epochs, shuffle=True, verbose=2, callbacks=callbacks_list, validation_data=(x_test, y_test)) model.save_weights(weights_path) score = model.evaluate(x_test, y_test, batch_size=128) print(score)
def train(model_name, fold_count, train_full_set=False, load_weights_path=None, ndsb3_holdout=0, manual_labels=True, local_patient_set=False): batch_size = 16 train_files, holdout_files = get_train_holdout_files(train_percentage=80, ndsb3_holdout=ndsb3_holdout, manual_labels=manual_labels, full_luna_set=train_full_set, fold_count=fold_count,local_patient_set=local_patient_set) logger.info("train/holdout files are done.") # train_files = train_files[:100] # holdout_files = train_files[:10] train_gen = data_generator(batch_size, train_files, True) holdout_gen = data_generator(batch_size, holdout_files, False) logger.info("generator is ok.") # for i in range(0, 10): # tmp = next(holdout_gen) # cube_img = tmp[0][0].reshape(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE, 1) # cube_img = cube_img[:, :, :, 0] # cube_img *= 255. # cube_img += MEAN_PIXEL_VALUE # helpers.save_cube_img("c:/tmp/img_" + str(i) + ".png", cube_img, 4, 8) # logger.info(tmp) history = LossHistory() logcallback = LoggingCallback(logger.info) learnrate_scheduler = LearningRateScheduler(step_decay) logger.info("get_resnet is beginning") model = ResNet50.get_resnet50(input_shape=(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE, 1), load_weight_path=load_weights_path) logger.info("get_resnet is done") # Tensorboard setting if not os.path.exists(TENSORBOARD_LOG_DIR): os.makedirs(TENSORBOARD_LOG_DIR) tensorboard_callback = TensorBoard( log_dir=TENSORBOARD_LOG_DIR, histogram_freq=2, # write_images=True, # Enabling this line would require more than 5 GB at each `histogram_freq` epoch. write_graph=True # embeddings_freq=3, # embeddings_layer_names=list(embeddings_metadata.keys()), # embeddings_metadata=embeddings_metadata ) tensorboard_callback.set_model(model) holdout_txt = "_h" + str(ndsb3_holdout) if manual_labels else "" if train_full_set: holdout_txt = "_fs" + holdout_txt # checkpoint = ModelCheckpoint(settings.WORKING_DIR + "workdir/model_" + model_name + "_" + holdout_txt + "_e" + "{epoch:02d}-{val_loss:.4f}.hd5", monitor='val_loss', verbose=1, save_best_only=not train_full_set, save_weights_only=False, mode='auto', period=1) checkpoint_fixed_name = ModelCheckpoint(settings.WORKING_DIR + "workdir/model_" + model_name + "_" + holdout_txt + "_best.hd5", monitor='val_loss', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=1) # train_history = model.fit_generator(train_gen, len(train_files) / 1, 12, validation_data=holdout_gen, nb_val_samples=len(holdout_files) / 1, callbacks=[checkpoint, checkpoint_fixed_name, learnrate_scheduler]) train_history = model.fit_generator(train_gen, len(train_files) / batch_size, 100, validation_data=holdout_gen, validation_steps=len(holdout_files) / batch_size, callbacks=[logcallback, tensorboard_callback, checkpoint_fixed_name, learnrate_scheduler]) logger.info("Model fit_generator finished.") model.save(settings.WORKING_DIR + "workdir/model_" + model_name + "_" + holdout_txt + "_end.hd5") logger.info("history keys: {0}".format(train_history.history.keys())) # numpy_loss_history = numpy.array(history.history) # numpy.savetxt("workdir/model_" + model_name + "_" + holdout_txt + "_loss_history.txt", numpy_loss_history, delimiter=",") pandas.DataFrame(train_history.history).to_csv(settings.WORKING_DIR + "workdir/model_" + model_name + "_" + holdout_txt + "history.csv")
def train(self, epochs, batch_size, sample_interval): def named_logs(model, logs): result = {} for l in zip(model.metrics_names, logs): result[l[0]] = l[1] return result start_time = datetime.datetime.now() valid = np.ones((batch_size, 1)) fake = np.zeros((batch_size, 1)) max_iter = int(self.n_data / batch_size) os.makedirs('./logs/%s' % self.time, exist_ok=True) tensorboard = TensorBoard('./logs/%s' % self.time) tensorboard.set_model(self.generator) os.makedirs('models/%s' % self.time, exist_ok=True) with open('models/%s/%s_architecture.json' % (self.time, 'generator'), 'w') as f: f.write(self.generator.to_json()) print( "\nbatch size : %d | num_data : %d | max iteration : %d | time : %s \n" % (batch_size, self.n_data, max_iter, self.time)) for epoch in range(1, epochs + 1): for iter in range(max_iter): # ------------------ # Train Generator # ------------------ ref_imgs = self.data_loader.load_data(batch_size) noise = np.random.normal(0, 1, (batch_size, self.latent_dim)) gen_imgs = self.generator.predict(noise) make_trainable(self.discriminator, True) d_loss_real = self.discriminator.train_on_batch( ref_imgs, valid * 0.9) # label smoothing d_loss_fake = self.discriminator.train_on_batch(gen_imgs, fake) d_loss = 0.5 * np.add(d_loss_real, d_loss_fake) make_trainable(self.discriminator, False) logs = self.combined.train_on_batch([noise], [valid]) tensorboard.on_epoch_end(iter, named_logs(self.combined, [logs])) if iter % (sample_interval // 10) == 0: elapsed_time = datetime.datetime.now() - start_time print( "epoch:%d | iter : %d / %d | time : %10s | g_loss : %15s | d_loss : %s " % (epoch, iter, max_iter, elapsed_time, logs, d_loss)) if (iter + 1) % sample_interval == 0: self.sample_images(epoch, iter + 1) # save weights after every epoch self.generator.save_weights('models/%s/%s_epoch%d_weights.h5' % (self.time, 'generator', epoch))
def train_save(classifier, training_set): tbCallBack = TensorBoard(log_dir='./Graph', histogram_freq=0, write_graph=True, write_images=True) tbCallBack.set_model(classifier) classifier.fit_generator(training_set, epochs=epochs) print("Training finished. Saving the model as " + model_name) classifier.save(model_name) print("Model saved to disk")
def tf_log_start(model, timestamp): path = "./_logs/" + timestamp tensorboard = TensorBoard(log_dir=path, histogram_freq=0, write_graph=True, write_images=False) tensorboard.set_model(model) return tensorboard
class _logs_manager: def __init__(self, log_path, model, init_step=0): if not os.path.exists(log_path): os.makedirs(log_path) self.plots_path = os.path.join(log_path, 'plots') if not os.path.exists(self.plots_path): os.makedirs(self.plots_path) self.tb_callback = TensorBoard(log_path) self.tb_callback.set_model(model.combined) self.step = 0 self.val_step = 0, self.plot_index = init_step def update(self, progbar, names, values, val_names=None, val_values=None, display_step=10): logs_list = [] for name, value in zip(names, values): logs_list.append((name, value)) if (self.step + 1) % display_step == 0 and self.step != 0: summary = Summary() summary_value = summary.value.add() summary_value.simple_value = value summary_value.tag = name self.tb_callback.writer.add_summary( summary, ((self.step + 1) // display_step) - 1) self.tb_callback.writer.flush() if val_names is not None and val_values is not None: for name, value in zip(val_names, val_values): logs_list.append((name, value)) summary = Summary() summary_value = summary.value.add() summary_value.simple_value = value summary_value.tag = name self.tb_callback.writer.add_summary(summary, self.val_step) self.tb_callback.writer.flush() self.val_step += 1 progbar.add(1, values=logs_list) self.step += 1 def save_plots(self, epoch, step, batch_fake, batch_real): np.save( os.path.join(self.plots_path, 'p%d_e%d_s%d_fake' % (self.plot_index, epoch, step)), batch_fake[:16]) np.save( os.path.join(self.plots_path, 'p%d_e%d_s%d_real' % (self.plot_index, epoch, step)), batch_real[:16]) self.plot_index += 1
def __call__(self,epochs, batch_size=64, sample_interval=50): #Dataset input #(x_train, y_train), (x_test, y_test) = tf.keras.datasets.fashion_mnist.load_data() (X_train, Y_train) = data.getIcons50ClassDataset() #X_train = np.expand_dims(X_train,axis=3) valid = -np.ones((batch_size,1)) fake = np.ones((batch_size,1)) log_dir = "./logs/" callback = TensorBoard(log_dir) callback2 = TensorBoard(log_dir) callback.set_model(self.critic) callback2.set_model(self.generator) train_names = ['d_loss'] train_names2 = ['g_loss'] for epoch in range(epochs): #Critic if epoch>1000: self.n_critic=1 for _ in range(self.n_critic): idx = np.random.randint(0,X_train.shape[0],batch_size) imgs = X_train[idx] noise = np.random.normal(0,1,(batch_size,self.input_size)) gen_imgs = self.generator.predict(noise) d_loss_real = self.critic.train_on_batch(imgs,valid) d_loss_fake = self.critic.train_on_batch(gen_imgs,fake) self.d_loss = 0.5*np.add(d_loss_fake, d_loss_real) if epoch % 50 == 0: write_log(callback,train_names,self.d_loss,epoch) for l in self.critic.layers: weights = l.get_weights() weights = [np.clip(w,-self.clip_value, self.clip_value) for w in weights] l.set_weights(weights) #Generator self.g_loss = self.combined.train_on_batch(noise,valid) if epoch % 50 == 0: write_log(callback2,train_names2,self.g_loss,epoch) if epoch % self.save_epoch == 0: self.combined.save("models\combined_"+str(epoch)+".model") self.generator.save("models\generator"+str(epoch)+".model") self.critic.save("models\critic_"+str(epoch)+".model") print("%d [D loss: %f] [G loss: %f]" % (epoch, self.d_loss[0], self.g_loss[0])) if epoch % sample_interval == 0: self.sample_images(epoch)
def train(self): ## split training set further for training and validation set start_time = time.time() # used for choosing triplets to train pca = PCA(n_components=embedding_num) temp = np.array(self.x_codes).reshape((self.x_codes.shape[0],-1)) g_embeddings = pca.fit_transform(temp) file_name = os.path.join(self.data_dir, 'embeddings.npy') np.save(open(file_name, 'wb'),g_embeddings) print("Embeddings updated") logger.info('Training starts...' ) checkpointer = EmbeddingUpdator(filepath=self.classifier_filename,train_codes=self.x_codes, train_labels = self.y_labels , data_dir = self.data_dir, monitor ='val_loss', verbose=1, save_best_only=True) #early_stopping = EarlyStopping(monitor='val_loss',patience=20) tbCallBack = TensorBoard(log_dir='./logs',batch_size= batch_num, histogram_freq=0, write_graph=True, write_images=True, write_grads = True) tbCallBack.set_model(self.model) train_data_params = { 'batch_size':batch_num, 'shuffle':True, 'classifier_filename': self.classifier_filename, 'data_dir':self.data_dir } val_batch_size = 64 val_data_params = { 'batch_size':val_batch_size, 'shuffle':True } train_data_generator = tripletDataGenerator(**train_data_params).generate(self.x_codes,self.y_labels,self.model) val_data_generator = tripletValidationDataGenerator (**val_data_params).generate(self.val_codes,self.val_labels) evaluation = self.model.fit_generator(train_data_generator, steps_per_epoch=(len(self.y_labels)+ batch_num-1) // batch_num, epochs=1000, verbose=1, callbacks=[checkpointer,tbCallBack], validation_data=val_data_generator, validation_steps = (val_batch_size * len(np.unique(self.val_labels))+ batch_num-1)//batch_num, use_multiprocessing = False) logger.info('Completed in {} seconds'.format(time.time() - start_time)) logger.info("Training result {}".format(evaluation)) pickle.dump(evaluation.history, open("../model/triplet_train_history.pickle", "wb")) return 0
def model_setup(model, config, task=None): if task == 'segmentation': model = segmentation_model_compile(model, config) elif task == 'classification': model = classification_model_compile(model, config) else: raise if os.path.exists(os.path.join(config.model_path, config.exp_name + ".txt")): os.remove(os.path.join(config.model_path, config.exp_name + ".txt")) with open(os.path.join(config.model_path, config.exp_name + ".txt"), 'w') as fh: model.summary(print_fn=lambda x: fh.write(x + '\n')) shutil.rmtree(os.path.join(config.logs_path, config.exp_name), ignore_errors=True) if not os.path.exists(os.path.join(config.logs_path, config.exp_name)): os.makedirs(os.path.join(config.logs_path, config.exp_name)) tbCallBack = TensorBoard( log_dir=os.path.join(config.logs_path, config.exp_name), histogram_freq=0, write_graph=True, write_images=True, ) tbCallBack.set_model(model) early_stopping = keras.callbacks.EarlyStopping( monitor='val_loss', patience=config.patience, verbose=config.verbose, mode='min', ) check_point = keras.callbacks.ModelCheckpoint( os.path.join(config.model_path, config.exp_name + ".h5"), monitor='val_loss', verbose=config.verbose, save_best_only=True, mode='min', ) lrate_scheduler = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=6, min_delta=0.0001, min_lr=1e-6, verbose=1) callbacks = [check_point, early_stopping, tbCallBack, lrate_scheduler] return model, callbacks
def buildFCModel(): model = models.Sequential() model.add(Dense(100, input_shape=(INPUT_COUNT, ))) model.add(LeakyReLU(alpha=0.03)) model.add(Dense(100)) model.add(LeakyReLU(alpha=0.03)) model.add(Dense(1)) model.compile(loss='mse', optimizer=adam(lr=0.0001)) board = TensorBoard(log_dir='model', histogram_freq=1, write_graph=True, write_images=False) board.set_model(model) return model, board
def train(self, epochs, batch_size=128, save_interval=50): file = np.load("/Users/athreya/desktop/Python/private/privater/privater/idata.npy",allow_pickle = True) X_train = np.array([i[0] for i in file]).reshape(-1,42,42,1) print(X_train.shape) # Rescale -1 to 1 #X_train = (X_train.astype(np.float32) - 127.5) / 127.5 #X_train = np.expand_dims(X_train, axis=3) half_batch = int(batch_size / 2) for epoch in range(epochs): idx = np.random.randint(0, X_train.shape[0], half_batch) imgs = X_train[idx] noise = np.random.normal(0, 1, (half_batch, 100)) gen_imgs = self.generator.predict(noise) # Train the discriminator d_loss_real = self.discriminator.train_on_batch(imgs, np.ones((half_batch, 1))) d_loss_fake = self.discriminator.train_on_batch(gen_imgs, np.zeros((half_batch, 1))) d_loss = 0.5 * np.add(d_loss_real, d_loss_fake) # --------------------- # Train Generator # --------------------- noise = np.random.normal(0, 1, (batch_size, 100)) valid_y = np.array([1] * batch_size) g_loss = self.combined.train_on_batch(noise, valid_y) log_path = './logs' callback = TensorBoard(log_path) callback.set_model(self.build_generator) #write_log(callback, ['g_loss'], [g_loss], epoch) #write_log(callback, ['d_loss'], [d_loss[0]], epoch) #write_log(callback,['acc'],[100*d_loss[1]],epoch) print ("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss)) if epoch % save_interval == 0: self.save_imgs(epoch)
def load_data(self): self.Initialize() object_name = "airplane" # Change the object of your choice found in the volumetric_data directory data_dir = "E:\\workdirectory\\Code Name Val Halen\\DS Sup\\DL\\GAN - Projects\\9781789136678_Code\\Chapter02\\3DShapeNets\\volumetric_data" \ "\\{}\\30\\train\\*.mat".format(object_name) # Change the location to file on your device; print(data_dir) volumes = self.get3DImages(data_dir=data_dir) self.volumes = volumes[..., np.newaxis].astype(np.float) print("No of volumes") print(len(self.volumes)) print(self.volumes.shape[0]) tensorboard = TensorBoard(log_dir="logs/{}".format(time.time())) self.Create_Generator() self.Create_Discriminator() tensorboard.set_model(self.gen_model) tensorboard.set_model(self.dis_model) self.tensorboard = tensorboard
def buildLSTMModel(): model = models.Sequential() model.add( LSTM(100, batch_input_shape=(1, 1, 1), return_sequences=True, stateful=True)) model.add(LSTM(100, return_sequences=False, stateful=True)) model.add(Dense(1)) model.compile(loss='mse', optimizer=adam(lr=0.0001)) board = TensorBoard(log_dir='model', histogram_freq=1, write_graph=True, write_images=False) board.set_model(model) return model, board
def createModel(): model = models.Sequential() model.add(Dense(100, input_shape=(TCOL_SCORE, ), name='d1')) model.add(LeakyReLU(alpha=0.03)) model.add(Dense(100, name='d2')) model.add(LeakyReLU(alpha=0.03)) model.add(Dense(1, activation='sigmoid', name='out')) model.compile(loss='mse', optimizer=adam()) global randomWeights randomWeights = model.get_weights().copy() board = TensorBoard(log_dir=MODEL_DIR, histogram_freq=2, write_graph=True, write_images=False) board.set_model(model) return model, board
def predict(self, X): print 'predicting with ' + str( self) + ' on data shape - %s' % (X.shape, ) tensorboard = TensorBoard( log_dir= '/home/ise/Desktop/dga_lstm_v2/res/results/tensorBoard/logs', histogram_freq=0, write_graph=True, write_grads=False, write_images=False, embeddings_freq=0, embeddings_layer_names=None, embeddings_metadata=None) tensorboard.set_model(self.model) return self.model.predict(X, self.batch_size)
def train(model_name, gpu_id): params = param.get_general_params() network_dir = params['model_save_dir'] + '/' + model_name if not os.path.isdir(network_dir): os.mkdir(network_dir) train_feed = data_generation.create_feed(params, params['data_dir'], 'train') os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id) config = tf.ConfigProto() config.gpu_options.allow_growth = True set_session(tf.Session(config=config)) vgg_model = truncated_vgg.vgg_norm() networks.make_trainable(vgg_model, False) response_weights = sio.loadmat( '../data/vgg_activation_distribution_train.mat') model = networks.network_posewarp(params) model.compile(optimizer=Adam(lr=1e-4), loss=[networks.vgg_loss(vgg_model, response_weights, 12)]) #model.summary() n_iters = params['n_training_iter'] log_dir = '../log/{:s}'.format(model_name) callback = TensorBoard(log_dir, write_graph=True) callback.set_model(model) train_names = ['train_loss'] for step in range(0, n_iters): x, y = next(train_feed) train_loss = model.train_on_batch(x, y) util.printProgress(step, 0, train_loss) write_log(callback, train_names, [train_loss], step) if step > 0 and step % params['model_save_interval'] == 0: model.save(network_dir + '/' + str(step) + '.h5')
def train_model(model_dir, log_dir, transformations=False): (tr_pairs, tr_y), (te_pairs, te_y) = prepare_data_for_work(transformations, False) model = create_model() tensorboard = TensorBoard( log_dir=log_dir, histogram_freq=0, batch_size=20, write_graph=True, write_grads=True) tensorboard.set_model(model) model.fit([tr_pairs[:, 0], tr_pairs[:, 1]], tr_y, batch_size=128, callbacks=[tensorboard], epochs=epochs, validation_data=([te_pairs[:, 0], te_pairs[:, 1]], te_y)) compute_final_accuracy(model, tr_pairs, tr_y, te_pairs, te_y) return model
def train_network(GLR, DLR, runNo): parser = argparse.ArgumentParser() help_ = "Load generator h5 model with trained weights" parser.add_argument("-g", "--generator", help=help_) help_ = "Specify a specific digit to generate" parser.add_argument("-d", "--digit", type=int, help=help_) args = parser.parse_args() if args.generator: generator = load_model(args.generator) class_label = 0 if args.digit is not None: classLabel = args.digit test_generator(generator, class_label, GLR, DLR, runNo) else: L = [GLR, DLR, runNo] gan = DCGAN(*L) callback = TensorBoard(gan.NAME) callback.set_model(gan.stack) gan.train(1000, gan.batchSize, 25, callback)
def visualize_model(layers, model_desc, vol_size=(256, 256, 1)): K.clear_session() model_class = Network_Building.new_model(image_size=vol_size, layers=layers, visualize=True, batch_normalization=False) model = model_class.model tensorboard_output = os.path.join('..', 'Tensorboard_models', model_desc) if not os.path.exists(tensorboard_output): os.makedirs(tensorboard_output) tensorboard = TensorBoard(log_dir=tensorboard_output, batch_size=2, write_graph=True, write_grads=False, write_images=True, update_freq='epoch', histogram_freq=0) tensorboard.set_model(model) tensorboard._write_logs({}, 0) print('Model created at: ' + os.path.abspath(tensorboard_output)) return None
def set_model(self, model): TensorBoard.set_model(self, model) TensorBoardEmbeddingMixin.set_model(self, model)