def update_graph(self, word_vocab, char_vocab, max_word_length, epoch): with self._graph.as_default(): with tf.device('/gpu:%d' % self._gpu_id): initializer = tf.random_uniform_initializer( -FLAGS.param_init, FLAGS.param_init) # TODO: other way to rebuild graph? reuse = None # if epoch > 0: # reuse = True with tf.variable_scope("Epoch_%d_Individual_%d" % (epoch, self._id_number), initializer=initializer, reuse=reuse): my_model = model.individual_graph( char_vocab_size=char_vocab.size, word_vocab_size=word_vocab.size, char_embed_size=self._knowledge.char_embed_size[-1], batch_size=FLAGS.batch_size, max_word_length=max_word_length, num_unroll_steps=FLAGS.num_unroll_steps, num_highway_layers=2, cnn_layer=self._cnn_layer, rnn_layers=self._rnn_layers, dropout=self._knowledge.dropout[-1]) my_model.update( model.loss_graph(my_model.logits, FLAGS.batch_size, FLAGS.num_unroll_steps)) my_model.update( model.training_graph( my_model.loss * FLAGS.num_unroll_steps, FLAGS.learning_rate, FLAGS.max_grad_norm)) saver = tf.train.Saver(max_to_keep=1) with tf.variable_scope("Epoch_%d_Individual_%d" % (epoch, self._id_number), reuse=True): valid_model = model.individual_graph( char_vocab_size=char_vocab.size, word_vocab_size=word_vocab.size, char_embed_size=self._knowledge.char_embed_size[-1], batch_size=FLAGS.batch_size, max_word_length=max_word_length, num_unroll_steps=FLAGS.num_unroll_steps, num_highway_layers=2, cnn_layer=self._cnn_layer, rnn_layers=self._rnn_layers, dropout=self._knowledge.dropout[-1]) valid_model.update( model.loss_graph(valid_model.logits, FLAGS.batch_size, FLAGS.num_unroll_steps)) return my_model, valid_model, saver
def main(_): ''' Trains model from data ''' if not os.path.exists(FLAGS.train_dir): os.mkdir(FLAGS.train_dir) print('Created training directory', FLAGS.train_dir) word_vocab, char_vocab, word_tensors, char_tensors, max_word_length = \ load_data(FLAGS.data_dir, FLAGS.max_word_length, eos=FLAGS.EOS) train_reader = DataReader(word_tensors['train'], char_tensors['train'], FLAGS.batch_size, FLAGS.num_unroll_steps) valid_reader = DataReader(word_tensors['valid'], char_tensors['valid'], FLAGS.batch_size, FLAGS.num_unroll_steps) test_reader = DataReader(word_tensors['test'], char_tensors['test'], FLAGS.batch_size, FLAGS.num_unroll_steps) print('initialized all dataset readers') minimum_valid_ppl = 1000000 minimum_vl_epoch = 0 text_file = open("train_log.txt", "w") # text_file.write("Purchase Amount: %s" % TotalAmount) with tf.Graph().as_default(), tf.Session() as session: # tensorflow seed must be inside graph tf.set_random_seed(FLAGS.seed) np.random.seed(seed=FLAGS.seed) ''' build training graph ''' initializer = tf.random_uniform_initializer(-FLAGS.param_init, FLAGS.param_init) with tf.variable_scope("Model", initializer=initializer): train_model = model.inference_graph( char_vocab_size=char_vocab.size, word_vocab_size=word_vocab.size, char_embed_size=FLAGS.char_embed_size, batch_size=FLAGS.batch_size, num_highway_layers=FLAGS.highway_layers, num_rnn_layers=FLAGS.rnn_layers, rnn_size=FLAGS.rnn_size, max_word_length=max_word_length, kernels=eval(FLAGS.kernels), kernel_features=eval(FLAGS.kernel_features), num_unroll_steps=FLAGS.num_unroll_steps, dropout=FLAGS.dropout) train_model.update( model.loss_graph(train_model.logits, FLAGS.batch_size, FLAGS.num_unroll_steps)) # scaling loss by FLAGS.num_unroll_steps effectively scales gradients by the same factor. # we need it to reproduce how the original Torch code optimizes. Without this, our gradients will be # much smaller (i.e. 35 times smaller) and to get system to learn we'd have to scale learning rate and max_grad_norm appropriately. # Thus, scaling gradients so that this trainer is exactly compatible with the original train_model.update( model.training_graph(train_model.loss * FLAGS.num_unroll_steps, FLAGS.learning_rate, FLAGS.max_grad_norm)) # create saver before creating more graph nodes, so that we do not save any vars defined below saver = tf.train.Saver(max_to_keep=10) ''' build graph for validation and testing (shares parameters with the training graph!) ''' with tf.variable_scope("Model", reuse=True): valid_model = model.inference_graph( char_vocab_size=char_vocab.size, word_vocab_size=word_vocab.size, char_embed_size=FLAGS.char_embed_size, batch_size=FLAGS.batch_size, num_highway_layers=FLAGS.highway_layers, num_rnn_layers=FLAGS.rnn_layers, rnn_size=FLAGS.rnn_size, max_word_length=max_word_length, kernels=eval(FLAGS.kernels), kernel_features=eval(FLAGS.kernel_features), num_unroll_steps=FLAGS.num_unroll_steps, dropout=0.0) valid_model.update( model.loss_graph(valid_model.logits, FLAGS.batch_size, FLAGS.num_unroll_steps)) if FLAGS.load_model: saver.restore(session, FLAGS.load_model) print('Loaded model from', FLAGS.load_model, 'saved at global step', train_model.global_step.eval()) else: tf.global_variables_initializer().run() session.run(train_model.clear_char_embedding_padding) print('Created and initialized fresh model. Size:', model.model_size()) summary_writer = tf.summary.FileWriter(FLAGS.train_dir, graph=session.graph) ''' take learning rate from CLI, not from saved graph ''' session.run(tf.assign(train_model.learning_rate, FLAGS.learning_rate), ) ''' training starts here ''' best_valid_loss = None rnn_state = session.run(train_model.initial_rnn_state) for epoch in range(FLAGS.max_epochs): epoch_start_time = time.time() avg_train_loss = 0.0 count = 0 for x, y in train_reader.iter(): count += 1 start_time = time.time() loss, _, rnn_state, gradient_norm, step, _ = session.run( [ train_model.loss, train_model.train_op, train_model.final_rnn_state, train_model.global_norm, train_model.global_step, train_model.clear_char_embedding_padding ], { train_model.input: x, train_model.targets: y, train_model.initial_rnn_state: rnn_state }) avg_train_loss += 0.05 * (loss - avg_train_loss) time_elapsed = time.time() - start_time if count % FLAGS.print_every == 0: print( '%6d: %d [%5d/%5d], train_loss/perplexity = %6.8f/%6.7f secs/batch = %.4fs, grad.norm=%6.8f' % (step, epoch, count, train_reader.length, loss, np.exp(loss), time_elapsed, gradient_norm)) text_file.write( '%6d: %d [%5d/%5d], train_loss/perplexity = %6.8f/%6.7f secs/batch = %.4fs, grad.norm=%6.8f \n' % (step, epoch, count, train_reader.length, loss, np.exp(loss), time_elapsed, gradient_norm)) print('Epoch training time:', time.time() - epoch_start_time) # text_file.write('Epoch training time:'+str( time.time()-epoch_start_time) # epoch done: time to evaluate avg_valid_loss = 0.0 count = 0 rnn_state = session.run(valid_model.initial_rnn_state) for x, y in valid_reader.iter(): count += 1 start_time = time.time() loss, rnn_state = session.run( [valid_model.loss, valid_model.final_rnn_state], { valid_model.input: x, valid_model.targets: y, valid_model.initial_rnn_state: rnn_state, }) if count % FLAGS.print_every == 0: print("\t> validation loss = %6.8f, perplexity = %6.8f" % (loss, np.exp(loss))) avg_valid_loss += loss / valid_reader.length print("at the end of epoch:", epoch) print("train loss = %6.8f, perplexity = %6.8f" % (avg_train_loss, np.exp(avg_train_loss))) print("validation loss = %6.8f, perplexity = %6.8f" % (avg_valid_loss, np.exp(avg_valid_loss))) text_file.write("at the end of epoch:" + str(epoch) + '\n') text_file.write("train loss = %6.8f, perplexity = %6.8f \n" % (avg_train_loss, np.exp(avg_train_loss))) text_file.write("validation loss = %6.8f, perplexity = %6.8f \n" % (avg_valid_loss, np.exp(avg_valid_loss))) if (np.exp(avg_valid_loss) < minimum_valid_ppl): minimum_valid_ppl = np.exp(avg_valid_loss) minimum_vl_epoch = epoch save_as = '%s/epoch%03d_%.4f.model' % (FLAGS.train_dir, epoch, avg_valid_loss) saver.save(session, save_as) print('Saved model', save_as) elif (epoch % 4 == 0): save_as = '%s/epoch%03d_%.4f.model' % (FLAGS.train_dir, epoch, avg_valid_loss) saver.save(session, save_as) print('Saved model', save_as) ''' write out summary events ''' summary = tf.Summary(value=[ tf.Summary.Value(tag="train_loss", simple_value=avg_train_loss), tf.Summary.Value(tag="valid_loss", simple_value=avg_valid_loss) ]) summary_writer.add_summary(summary, step) ''' decide if need to decay learning rate ''' if best_valid_loss is not None and np.exp(avg_valid_loss) > np.exp( best_valid_loss) - FLAGS.decay_when: print( 'validation perplexity did not improve enough, decay learning rate' ) current_learning_rate = session.run(train_model.learning_rate) print('learning rate was:', current_learning_rate) current_learning_rate *= FLAGS.learning_rate_decay if current_learning_rate < 1.e-5: print('learning rate too small - stopping now') break session.run( train_model.learning_rate.assign(current_learning_rate)) print('new learning rate is:', current_learning_rate) else: best_valid_loss = avg_valid_loss save_as = '%s/epoch%03d_%.4f.model' % (FLAGS.train_dir, epoch, avg_valid_loss) saver.save(session, save_as) print('Saved model', save_as) print("----------------------------------------------") print( "Minimum Valid PPL is attained in epoch:%d and Validation PPL is %6.8f" % (minimum_vl_epoch, minimum_valid_ppl))
def build_model(word_vocab, max_doc_length, train): '''build a training or inference graph, based on the model choice''' my_model = None if train: pretrained_emb = None embedding_path = FLAGS.embedding_path if FLAGS.load_model is None and embedding_path != None and os.path.exists( embedding_path): pretrained_emb = load_wordvec(embedding_path, word_vocab) if FLAGS.model_choice == 'bilstm': my_model = model.cnn_sen_enc( word_vocab_size=word_vocab.size, word_embed_size=FLAGS.word_embed_size, batch_size=FLAGS.batch_size, num_highway_layers=FLAGS.highway_layers, max_sen_length=FLAGS.max_sen_length, kernels=eval(FLAGS.kernels), kernel_features=eval(FLAGS.kernel_features), max_doc_length=max_doc_length, pretrained=pretrained_emb) my_model.update( model.bilstm_doc_enc(my_model.input_cnn, batch_size=FLAGS.batch_size, num_rnn_layers=FLAGS.rnn_layers, rnn_size=FLAGS.rnn_size, max_doc_length=max_doc_length, dropout=FLAGS.dropout)) my_model.update(model.label_prediction(my_model.enc_outputs)) my_model.update( model.loss_extraction(my_model.logits, FLAGS.batch_size, max_doc_length)) my_model.update( model.training_graph(my_model.loss * max_doc_length, FLAGS.learning_rate, FLAGS.max_grad_norm)) elif FLAGS.model_choice == 'lstm': my_model = model.cnn_sen_enc( word_vocab_size=word_vocab.size, word_embed_size=FLAGS.word_embed_size, batch_size=FLAGS.batch_size, num_highway_layers=FLAGS.highway_layers, max_sen_length=FLAGS.max_sen_length, kernels=eval(FLAGS.kernels), kernel_features=eval(FLAGS.kernel_features), max_doc_length=max_doc_length, pretrained=pretrained_emb) my_model.update( model.lstm_doc_enc(my_model.input_cnn, batch_size=FLAGS.batch_size, num_rnn_layers=FLAGS.rnn_layers, rnn_size=FLAGS.rnn_size, max_doc_length=max_doc_length, dropout=FLAGS.dropout)) my_model.update( model.lstm_doc_dec(my_model.input_cnn, my_model.final_enc_state, batch_size=FLAGS.batch_size, num_rnn_layers=FLAGS.rnn_layers, rnn_size=FLAGS.rnn_size, max_doc_length=max_doc_length, dropout=FLAGS.dropout)) my_model.update( model.label_prediction_att(my_model.enc_outputs, my_model.dec_outputs)) my_model.update( model.loss_extraction(my_model.logits, FLAGS.batch_size, max_doc_length)) my_model.update( model.training_graph(my_model.loss * max_doc_length, FLAGS.learning_rate, FLAGS.max_grad_norm)) else: if FLAGS.model_choice == 'bilstm': my_model = model.cnn_sen_enc( word_vocab_size=word_vocab.size, word_embed_size=FLAGS.word_embed_size, batch_size=FLAGS.batch_size, num_highway_layers=FLAGS.highway_layers, max_sen_length=FLAGS.max_sen_length, kernels=eval(FLAGS.kernels), kernel_features=eval(FLAGS.kernel_features), max_doc_length=max_doc_length) my_model.update( model.bilstm_doc_enc(my_model.input_cnn, batch_size=FLAGS.batch_size, num_rnn_layers=FLAGS.rnn_layers, rnn_size=FLAGS.rnn_size, max_doc_length=max_doc_length, dropout=FLAGS.dropout)) my_model.update(model.label_prediction(my_model.enc_outputs)) my_model.update( model.loss_extraction(my_model.logits, FLAGS.batch_size, max_doc_length)) elif FLAGS.model_choice == 'lstm': my_model = model.cnn_sen_enc( word_vocab_size=word_vocab.size, word_embed_size=FLAGS.word_embed_size, batch_size=FLAGS.batch_size, num_highway_layers=FLAGS.highway_layers, max_sen_length=FLAGS.max_sen_length, kernels=eval(FLAGS.kernels), kernel_features=eval(FLAGS.kernel_features), max_doc_length=max_doc_length) my_model.update( model.lstm_doc_enc(my_model.input_cnn, batch_size=FLAGS.batch_size, num_rnn_layers=FLAGS.rnn_layers, rnn_size=FLAGS.rnn_size, max_doc_length=max_doc_length, dropout=FLAGS.dropout)) my_model.update( model.lstm_doc_dec(my_model.input_cnn, my_model.final_enc_state, batch_size=FLAGS.batch_size, num_rnn_layers=FLAGS.rnn_layers, rnn_size=FLAGS.rnn_size, max_doc_length=max_doc_length, dropout=FLAGS.dropout)) my_model.update( model.label_prediction_att(my_model.enc_outputs, my_model.dec_outputs)) my_model.update( model.loss_extraction(my_model.logits, FLAGS.batch_size, max_doc_length)) return my_model
def main(print): ''' Trains model from data ''' if not os.path.exists(FLAGS.train_dir): os.mkdir(FLAGS.train_dir) print('Created training directory' + FLAGS.train_dir) # CSV initialize pd.DataFrame(FLAGS.flag_values_dict(), index=range(1)).to_csv(FLAGS.train_dir + '/train_parameters.csv') epochs_results = initialize_epoch_data_dict() fasttext_model_path = None if FLAGS.fasttext_model_path: fasttext_model_path = FLAGS.fasttext_model_path word_vocab, char_vocab, word_tensors, char_tensors, max_word_length, words_list = \ load_data(FLAGS.data_dir, FLAGS.max_word_length, eos=FLAGS.EOS) fasttext_model = None if 'fasttext' in FLAGS.embedding: fasttext_model = FasttextModel( fasttext_path=fasttext_model_path).get_fasttext_model() train_ft_reader = DataReaderFastText( words_list=words_list, batch_size=FLAGS.batch_size, num_unroll_steps=FLAGS.num_unroll_steps, model=fasttext_model, data='train') valid_ft_reader = DataReaderFastText( words_list=words_list, batch_size=FLAGS.batch_size, num_unroll_steps=FLAGS.num_unroll_steps, model=fasttext_model, data='valid') train_reader = DataReader(word_tensors['train'], char_tensors['train'], FLAGS.batch_size, FLAGS.num_unroll_steps) valid_reader = DataReader(word_tensors['valid'], char_tensors['valid'], FLAGS.batch_size, FLAGS.num_unroll_steps) test_reader = DataReader(word_tensors['test'], char_tensors['test'], FLAGS.batch_size, FLAGS.num_unroll_steps) print('initialized all dataset readers') with tf.Graph().as_default(), tf.Session() as session: # tensorflow seed must be inside graph tf.set_random_seed(FLAGS.seed) np.random.seed(seed=FLAGS.seed) ''' build training graph ''' initializer = tf.random_uniform_initializer(-FLAGS.param_init, FLAGS.param_init) with tf.variable_scope("Model", initializer=initializer): train_model = model.inference_graph( char_vocab_size=char_vocab.size, word_vocab_size=word_vocab.size, char_embed_size=FLAGS.char_embed_size, batch_size=FLAGS.batch_size, num_highway_layers=FLAGS.highway_layers, num_rnn_layers=FLAGS.rnn_layers, rnn_size=FLAGS.rnn_size, max_word_length=max_word_length, kernels=eval(FLAGS.kernels), kernel_features=eval(FLAGS.kernel_features), num_unroll_steps=FLAGS.num_unroll_steps, dropout=FLAGS.dropout, embedding=FLAGS.embedding, fasttext_word_dim=300, acoustic_features_dim=4) train_model.update( model.loss_graph(train_model.logits, FLAGS.batch_size, FLAGS.num_unroll_steps)) train_model.update( model.training_graph(train_model.loss * FLAGS.num_unroll_steps, FLAGS.learning_rate, FLAGS.max_grad_norm)) # create saver before creating more graph nodes, so that we do not save any vars defined below saver = tf.train.Saver(max_to_keep=50) ''' build graph for validation and testing (shares parameters with the training graph!) ''' with tf.variable_scope("Model", reuse=True): valid_model = model.inference_graph( char_vocab_size=char_vocab.size, word_vocab_size=word_vocab.size, char_embed_size=FLAGS.char_embed_size, batch_size=FLAGS.batch_size, num_highway_layers=FLAGS.highway_layers, num_rnn_layers=FLAGS.rnn_layers, rnn_size=FLAGS.rnn_size, max_word_length=max_word_length, kernels=eval(FLAGS.kernels), kernel_features=eval(FLAGS.kernel_features), num_unroll_steps=FLAGS.num_unroll_steps, dropout=0.0, embedding=FLAGS.embedding, fasttext_word_dim=300, acoustic_features_dim=4) valid_model.update( model.loss_graph(valid_model.logits, FLAGS.batch_size, FLAGS.num_unroll_steps)) if FLAGS.load_model_for_training: saver.restore(session, FLAGS.load_model_for_training) string = str('Loaded model from' + str(FLAGS.load_model_for_training) + 'saved at global step' + str(train_model.global_step.eval())) print(string) else: tf.global_variables_initializer().run() session.run(train_model.clear_char_embedding_padding) string = str('Created and initialized fresh model. Size:' + str(model.model_size())) print(string) summary_writer = tf.summary.FileWriter(FLAGS.train_dir, graph=session.graph) ''' take learning rate from CLI, not from saved graph ''' session.run(tf.assign(train_model.learning_rate, FLAGS.learning_rate), ) ''' training starts here ''' best_valid_loss = None rnn_state = session.run(train_model.initial_rnn_state) for epoch in range(FLAGS.max_epochs): epoch_start_time = time.time() avg_train_loss = 0.0 count = 0 if fasttext_model: iter_over = zip(train_reader.iter(), train_ft_reader.iter()) else: iter_over = train_reader.iter() for batch_kim, batch_ft in iter_over: if fasttext_model: x, y = batch_kim else: x, y = batch_kim, batch_ft count += 1 start_time = time.time() if fasttext_model: ft_vectors = fasttext_model.wv[ words_list['train'][count]].reshape( fasttext_model.wv.vector_size, 1) loss, _, rnn_state, gradient_norm, step, _, probas = session.run( [ train_model.loss, train_model.train_op, train_model.final_rnn_state, train_model.global_norm, train_model.global_step, train_model.clear_char_embedding_padding ], { train_model.input2: batch_ft, train_model.input: x, train_model.targets: y, train_model.initial_rnn_state: rnn_state }) else: loss, _, rnn_state, gradient_norm, step, _ = session.run( [ train_model.loss, train_model.train_op, train_model.final_rnn_state, train_model.global_norm, train_model.global_step, train_model.clear_char_embedding_padding ], { train_model.input: x, train_model.targets: y, train_model.initial_rnn_state: rnn_state }) avg_train_loss += 0.05 * (loss - avg_train_loss) time_elapsed = time.time() - start_time if count % FLAGS.print_every == 0: string = str( '%6d: %d [%5d/%5d], train_loss/perplexity = %6.8f/%6.7f secs/batch = %.4fs, grad.norm=%6.8f' % (step, epoch, count, train_reader.length, loss, np.exp(loss), time_elapsed, gradient_norm)) print(string) string = str('Epoch training time:' + str(time.time() - epoch_start_time)) print(string) epochs_results['epoch_training_time'].append( str(time.time() - epoch_start_time)) # epoch done: time to evaluate avg_valid_loss = 0.0 count = 0 rnn_state = session.run(valid_model.initial_rnn_state) for batch_kim, batch_ft in zip(valid_reader.iter(), valid_ft_reader.iter()): x, y = batch_kim count += 1 start_time = time.time() loss, rnn_state = session.run( [valid_model.loss, valid_model.final_rnn_state], { valid_model.input2: batch_ft, valid_model.input: x, valid_model.targets: y, valid_model.initial_rnn_state: rnn_state, }) if count % FLAGS.print_every == 0: string = str( "\t> validation loss = %6.8f, perplexity = %6.8f" % (loss, np.exp(loss))) print(string) avg_valid_loss += loss / valid_reader.length print("at the end of epoch:" + str(epoch)) epochs_results['epoch_number'].append(str(epoch)) print("train loss = %6.8f, perplexity = %6.8f" % (avg_train_loss, np.exp(avg_train_loss))) epochs_results['train_loss'].append(avg_train_loss) epochs_results['train_perplexity'].append(np.exp(avg_train_loss)) print("validation loss = %6.8f, perplexity = %6.8f" % (avg_valid_loss, np.exp(avg_valid_loss))) epochs_results['validation_loss'].append(avg_valid_loss) epochs_results['valid_perplexity'].append(np.exp(avg_valid_loss)) save_as = '%s/epoch%03d_%.4f.model' % (FLAGS.train_dir, epoch, avg_valid_loss) saver.save(session, save_as) print('Saved model' + str(save_as)) epochs_results['model_name'].append(str(save_as)) epochs_results['learning_rate'].append( str(session.run(train_model.learning_rate))) ''' write out summary events ''' summary = tf.Summary(value=[ tf.Summary.Value(tag="train_loss", simple_value=avg_train_loss), tf.Summary.Value(tag="train_perplexity", simple_value=np.exp(avg_train_loss)), tf.Summary.Value(tag="valid_loss", simple_value=avg_valid_loss), tf.Summary.Value(tag="valid_perplexity", simple_value=np.exp(avg_valid_loss)), ]) summary_writer.add_summary(summary, step) ''' decide if need to decay learning rate ''' if best_valid_loss is not None and np.exp(avg_valid_loss) > np.exp( best_valid_loss) - FLAGS.decay_when: print( 'validation perplexity did not improve enough, decay learning rate' ) current_learning_rate = session.run(train_model.learning_rate) string = str('learning rate was:' + str(current_learning_rate)) print(string) current_learning_rate *= FLAGS.learning_rate_decay if current_learning_rate < 1.e-3: print('learning rate too small - stopping now') break session.run( train_model.learning_rate.assign(current_learning_rate)) string = str('new learning rate is:' + str(current_learning_rate)) print(string) else: best_valid_loss = avg_valid_loss # Save model performance data pd.DataFrame(epochs_results).to_csv(FLAGS.train_dir + '/train_results.csv')
def main(file, batch_size=20, num_unroll_steps=35, char_embed_size=15, rnn_size=650, kernels="[1,2,3,4,5,6,7]", kernel_features="[50,100,150,200,200,200,200]", max_grad_norm=5.0, learning_rate=1.0, learning_rate_decay=0.5, decay_when=1.0, seed=3435, param_init=0.05, max_epochs=25, print_every=5): ''' Trains model from data ''' if not os.path.exists(TRAINING_DIR): os.mkdir(TRAINING_DIR) print('Created training directory', TRAINING_DIR) word_vocab, char_vocab, word_tensors, char_tensors, max_word_length = \ load_dataset() print('initialized all dataset readers') with tf.Graph().as_default(), tf.Session() as session: train_reader = DataReader(word_tensors['train'], char_tensors['train'], batch_size, num_unroll_steps, char_vocab) valid_reader = DataReader(word_tensors['valid'], char_tensors['valid'], batch_size, num_unroll_steps, char_vocab) test_reader = DataReader(word_tensors['test'], char_tensors['test'], batch_size, num_unroll_steps, char_vocab) # tensorflow seed must be inside graph tf.set_random_seed(seed) np.random.seed(seed=seed) ''' build training graph ''' initializer = tf.random_uniform_initializer(param_init, param_init) with tf.variable_scope("Model", initializer=initializer): train_model = model.inference_graph( char_vocab_size=char_vocab.size(), word_vocab_size=word_vocab.size(), char_embed_size=char_embed_size, batch_size=batch_size, rnn_size=rnn_size, max_word_length=max_word_length, kernels=eval(kernels), kernel_features=eval(kernel_features), num_unroll_steps=num_unroll_steps) train_model.update( model.loss_graph(train_model.logits, batch_size, num_unroll_steps)) # scaling loss by FLAGS.num_unroll_steps effectively scales gradients by the same factor. # we need it to reproduce how the original Torch code optimizes. Without this, our gradients will be # much smaller (i.e. 35 times smaller) and to get system to learn we'd have to scale learning rate and max_grad_norm appropriately. # Thus, scaling gradients so that this trainer is exactly compatible with the original train_model.update( model.training_graph(train_model.loss * num_unroll_steps, learning_rate, max_grad_norm)) # create saver before creating more graph nodes, so that we do not save any vars defined below saver = tf.train.Saver(max_to_keep=50) ''' build graph for validation and testing (shares parameters with the training graph!) ''' with tf.variable_scope("Model", reuse=True): valid_model = model.inference_graph( char_vocab_size=char_vocab.size(), word_vocab_size=word_vocab.size(), char_embed_size=char_embed_size, batch_size=batch_size, rnn_size=rnn_size, max_word_length=max_word_length, kernels=eval(kernels), kernel_features=eval(kernel_features), num_unroll_steps=num_unroll_steps) valid_model.update( model.loss_graph(valid_model.logits, batch_size, num_unroll_steps)) '''if load_model: saver.restore(session, load_model) print('Loaded model from', load_model, 'saved at global step', train_model.global_step.eval()) else:''' tf.global_variables_initializer().run() session.run(train_model.clear_char_embedding_padding) print('Created and initialized fresh model. Size:', model.model_size()) summary_writer = tf.summary.FileWriter(TRAINING_DIR, graph=session.graph) ''' take learning rate from CLI, not from saved graph ''' session.run(tf.assign(train_model.learning_rate, learning_rate), ) ''' training starts here ''' best_valid_loss = None rnn_state = session.run(train_model.initial_rnn_state) for epoch in range(max_epochs): epoch_start_time = time.time() avg_train_loss = 0.0 count = 0 for x, y in train_reader.iter(): count += 1 start_time = time.time() loss, _, rnn_state, gradient_norm, step, _ = session.run( [ train_model.loss, train_model.train_op, train_model.final_rnn_state, train_model.global_norm, train_model.global_step, train_model.clear_char_embedding_padding ], { train_model.input: x, train_model.targets: y, train_model.initial_rnn_state: rnn_state }) avg_train_loss += 0.05 * (loss - avg_train_loss) time_elapsed = time.time() - start_time if count % print_every == 0: print( '%6d: %d [%5d/%5d], train_loss/perplexity = %6.8f/%6.7f secs/batch = %.4fs, grad.norm=%6.8f' % (step, epoch, count, train_reader.length, loss, np.exp(loss), time_elapsed, gradient_norm)) print('Epoch training time:', time.time() - epoch_start_time) # epoch done: time to evaluate avg_valid_loss = 0.0 count = 0 rnn_state = session.run(valid_model.initial_rnn_state) for x, y in valid_reader.iter(): count += 1 start_time = time.time() loss, rnn_state = session.run( [valid_model.loss, valid_model.final_rnn_state], { valid_model.input: x, valid_model.targets: y, valid_model.initial_rnn_state: rnn_state, }) if count % print_every == 0: print("\t> validation loss = %6.8f, perplexity = %6.8f" % (loss, np.exp(loss))) avg_valid_loss += loss / valid_reader.length print("at the end of epoch:", epoch) print("train loss = %6.8f, perplexity = %6.8f" % (avg_train_loss, np.exp(avg_train_loss))) print("validation loss = %6.8f, perplexity = %6.8f" % (avg_valid_loss, np.exp(avg_valid_loss))) save_as = '%s/epoch%03d_%.4f.model' % (TRAINING_DIR, epoch, avg_valid_loss) saver.save(session, save_as) print('Saved model', save_as) ''' write out summary events ''' summary = tf.Summary(value=[ tf.Summary.Value(tag="train_loss", simple_value=avg_train_loss), tf.Summary.Value(tag="valid_loss", simple_value=avg_valid_loss) ]) summary_writer.add_summary(summary, step) ''' decide if need to decay learning rate ''' if best_valid_loss is not None and np.exp( avg_valid_loss) > np.exp(best_valid_loss) - decay_when: print( 'validation perplexity did not improve enough, decay learning rate' ) current_learning_rate = session.run(train_model.learning_rate) print('learning rate was:', current_learning_rate) current_learning_rate *= learning_rate_decay if current_learning_rate < 1.e-5: print('learning rate too small - stopping now') break session.run( train_model.learning_rate.assign(current_learning_rate)) print('new learning rate is:', current_learning_rate) else: best_valid_loss = avg_valid_loss
def train(): dataset_tensors, labels_tensors = dl.make_batches() input_tensor_tr, label_tensor_tr, seq_tensor_tr = dl.sequence_init( dataset_tensors, labels_tensors, FLAGS.num_unroll_steps, 'Train', allow_short_seq=False) input_tensor_te, label_tensor_te, seq_tensor_te = dl.sequence_init( dataset_tensors, labels_tensors, FLAGS.num_unroll_steps, 'Devel', allow_short_seq=True) train_reader = dl.TrainDataReader(input_tensor_tr, label_tensor_tr, seq_tensor_tr, FLAGS.batch_size, FLAGS.num_unroll_steps, False) eval_reader = dl.EvalDataReader(input_tensor_te, label_tensor_te, seq_tensor_te, FLAGS.batch_size_eval, FLAGS.num_unroll_steps, False) labels = tf.placeholder(tf.float32, [None, FLAGS.num_unroll_steps, 3], name='labels') train_model = model.inference_graph( word_vocab_size=FLAGS.word_vocab_size, kernels=eval(FLAGS.kernels), kernel_features=eval(FLAGS.kernel_features), rnn_size=FLAGS.rnn_size, dropout=FLAGS.dropout, num_rnn_layers=FLAGS.rnn_layers, num_highway_layers=FLAGS.highway_layers, num_unroll_steps=FLAGS.num_unroll_steps, max_sent_length=FLAGS.max_sent_length, # batch_size= FLAGS.batch_size, embed_size=FLAGS.word_embed_size, trnn_size=eval(FLAGS.trnn_size), num_trnn_layers=eval(FLAGS.trnn_layers), num_heads=FLAGS.head_attention_layers) predictions_arousal = train_model.predictions_arousal predictions_valence = train_model.predictions_valence predictions_liking = train_model.predictions_liking predictions_AV = tf.concat([predictions_arousal, predictions_valence], 1) predictions = tf.concat( [predictions_arousal, predictions_valence, predictions_liking], 1) embedding_matrix = dl.loadPickle(Embedding_PATH, 'Embedding_300_fastText_training.pkl') AV_losses = model.loss_graph_ccc_arousal_valence(predictions_AV, labels) eval_model = model.metric_graph() loss_av = AV_losses.AV_CCC eval_arousal = eval_model.eval_metric_arousal eval_valence = eval_model.eval_metric_valence eval_liking = eval_model.eval_metric_liking optimize_graph = model.training_graph(loss_av, FLAGS.learning_rate, FLAGS.max_grad_norm) train_op = optimize_graph.train_op saver = tf.train.Saver(max_to_keep=100) with tf.Session() as sess: sess.run(tf.initialize_all_variables()) train_writer = tf.summary.FileWriter('.\logs\\train', graph=sess.graph) eval_writer = tf.summary.FileWriter('.\logs\\eval', graph=sess.graph) best, inx = 0.92, 1 epoch = 0 global_step = 0 while epoch < FLAGS.max_epochs: batch = 1 epoch += 1 train_reader.make_batches() for minibatch in train_reader.iter(): x, y = minibatch _, l = sess.run( [train_op, loss_av], feed_dict={ train_model.input: x, labels: y, train_model.sequence_length: [96] * x.shape[0], train_model.batch_size: x.shape[0], train_model.training: True, train_model.word_embedding: embedding_matrix, train_model.dropout_LSTM: 0.0, train_model.dropout_text: 0.1, train_model.dropout_atdnn: 0.3, train_model.dropout_trnn: 0.3, train_model.dropout_mlattention: 0.2 }) with open(ArchivePathTrain, 'a') as apt: apt.write(str(l) + ';' + str(global_step)) apt.write('\n') print('Epoch: %5d/%5d -- batch: %5d -- loss: %.4f' % (epoch, FLAGS.max_epochs, batch, l)) summary = tf.Summary( value=[tf.Summary.Value(tag="TRAIN_LOSS", simple_value=l)]) train_writer.add_summary(summary, global_step) if batch % 9 == 0: # 7, change print from 7 to 9 20180725 print( '-------------------Devel Set Start------------------------------' ) cnt = 0 prev = None eval_x_total = None eval_y = None for mb in eval_reader.iter(): eval_x_list, eval_y_list, eval_z_list = mb for eval_x, eval_z in zip(eval_x_list, eval_z_list): cnt += np.sum(eval_z) eval_tmp_preds = sess.run( [predictions], feed_dict={ train_model.input: eval_x, train_model.sequence_length: eval_z, train_model.batch_size: eval_x.shape[0], train_model.training: False, train_model.word_embedding: embedding_matrix, train_model.dropout_LSTM: 0.0, train_model.dropout_text: 0.0, train_model.dropout_atdnn: 0.0, train_model.dropout_trnn: 0.0, train_model.dropout_mlattention: 0.0 }) if prev is None: prev = eval_tmp_preds[0] else: prev = np.vstack((prev, eval_tmp_preds[0])) prev = prev[:cnt] if eval_x_total is None: eval_x_total = prev else: eval_x_total = np.vstack((eval_x_total, prev)) if eval_y is None: eval_y = np.array(eval_y_list).reshape([-1, 3])[:cnt] else: eval_y = np.vstack( (eval_y, np.array(eval_y_list).reshape([-1, 3])[:cnt])) prev = None cnt = 0 e_arousal, e_valence, e_liking = sess.run( [eval_arousal, eval_valence, eval_liking], feed_dict={ eval_model.eval_predictions: eval_x_total, eval_model.eval_labels: eval_y }) eval_res = np.array([e_arousal, e_valence, e_liking]) eval_loss = 2. - eval_res[0] - eval_res[1] with open(ArchivePathEval, 'a') as ape: ape.write(str(eval_loss) + ';' + str(global_step)) ape.write('\n') summary_eval = tf.Summary(value=[ tf.Summary.Value(tag="Eval_LOSS", simple_value=eval_loss) ]) eval_writer.add_summary(summary_eval, global_step) if eval_loss < best: saver.save(sess, SAVE_PATH + '-{}'.format(inx)) inx += 1 log = open(LOGGING_PATH, 'a') log.write('Model, ' + SAVE_PATH + '-{}'.format(inx) + '\n') log.write( '%s, Epoch: %d, Batch: %d, Loss: %.4f, Arousal: %.4f, Valence: %.4f\n' % ('Devel', epoch, batch, eval_loss, eval_res[0], eval_res[1])) log.write( '======================================================\n' ) log.close() print( 'Devel Set, Epoch: %5d/%5d -- batch: %5d -- loss: _%.4f -- arousal: %.4f -- valence: %.4f -- liking: %.4f' % (epoch, FLAGS.max_epochs, batch, eval_loss, eval_res[0], eval_res[1], eval_res[2])) print( '---------------------Devel Finished----------------------' ) global_step += 1 batch += 1
def main(_): ''' Trains model from data ''' print("we in main") print(sys.argv[2]) print(FLAGS) if not os.path.exists(FLAGS.train_dir): os.mkdir(FLAGS.train_dir) print('Created training directory', FLAGS.train_dir) word_vocab, char_vocab, word_tensors, char_tensors, max_word_length = \ load_data(FLAGS.data_dir, FLAGS.max_word_length, eos=FLAGS.EOS) train_reader = DataReader(word_tensors['train'], char_tensors['train'], FLAGS.batch_size, FLAGS.num_unroll_steps) valid_reader = DataReader(word_tensors['valid'], char_tensors['valid'], FLAGS.batch_size, FLAGS.num_unroll_steps) test_reader = DataReader(word_tensors['test'], char_tensors['test'], FLAGS.batch_size, FLAGS.num_unroll_steps) print('initialized all dataset readers') with tf.Graph().as_default(), tf.Session() as session: # tensorflow seed must be inside graph tf.set_random_seed(FLAGS.seed) np.random.seed(seed=FLAGS.seed) ''' build training graph ''' initializer = tf.random_uniform_initializer(-FLAGS.param_init, FLAGS.param_init) with tf.variable_scope("Model", initializer=initializer): train_model = model.inference_graph( char_vocab_size=char_vocab.size, word_vocab_size=word_vocab.size, char_embed_size=FLAGS.char_embed_size, batch_size=FLAGS.batch_size, num_highway_layers=FLAGS.highway_layers, num_rnn_layers=FLAGS.rnn_layers, rnn_size=FLAGS.rnn_size, max_word_length=max_word_length, kernels=eval(FLAGS.kernels), kernel_features=eval(FLAGS.kernel_features), num_unroll_steps=FLAGS.num_unroll_steps, dropout=FLAGS.dropout) train_model.update(model.loss_graph(train_model.logits, FLAGS.batch_size, FLAGS.num_unroll_steps)) # scaling loss by FLAGS.num_unroll_steps effectively scales gradients by the same factor. # we need it to reproduce how the original Torch code optimizes. Without this, our gradients will be # much smaller (i.e. 35 times smaller) and to get system to learn we'd have to scale learning rate and max_grad_norm appropriately. # Thus, scaling gradients so that this trainer is exactly compatible with the original train_model.update(model.training_graph(train_model.loss * FLAGS.num_unroll_steps, FLAGS.learning_rate, FLAGS.max_grad_norm)) # create saver before creating more graph nodes, so that we do not save any vars defined below saver = tf.train.Saver(max_to_keep=50) ''' build graph for validation and testing (shares parameters with the training graph!) ''' with tf.variable_scope("Model", reuse=True): valid_model = model.inference_graph( char_vocab_size=char_vocab.size, word_vocab_size=word_vocab.size, char_embed_size=FLAGS.char_embed_size, batch_size=FLAGS.batch_size, num_highway_layers=FLAGS.highway_layers, num_rnn_layers=FLAGS.rnn_layers, rnn_size=FLAGS.rnn_size, max_word_length=max_word_length, kernels=eval(FLAGS.kernels), kernel_features=eval(FLAGS.kernel_features), num_unroll_steps=FLAGS.num_unroll_steps, dropout=0.0) valid_model.update(model.loss_graph(valid_model.logits, FLAGS.batch_size, FLAGS.num_unroll_steps)) with tf.variable_scope("Model", reuse=True): test_model = model.inference_graph( char_vocab_size=char_vocab.size, word_vocab_size=word_vocab.size, char_embed_size=FLAGS.char_embed_size, batch_size=1, num_highway_layers=FLAGS.highway_layers, num_rnn_layers=FLAGS.rnn_layers, rnn_size=FLAGS.rnn_size, max_word_length=max_word_length, kernels=eval(FLAGS.kernels), kernel_features=eval(FLAGS.kernel_features), num_unroll_steps=1, dropout=0.0) test_model.update(model.loss_graph(test_model.logits, 1, 1)) if FLAGS.load_model: saver.restore(session, FLAGS.load_model) print('Loaded model from', FLAGS.load_model, 'saved at global step', train_model.global_step.eval()) else: tf.initialize_all_variables().run() print('Created and initialized fresh model. Size:', model.model_size()) summary_writer = tf.train.SummaryWriter(FLAGS.train_dir, graph=session.graph) ''' take learning rate from CLI, not from saved graph ''' session.run( tf.assign(train_model.learning_rate, FLAGS.learning_rate), ) def clear_char_embedding_padding(): char_embedding = session.run(train_model.char_embedding) char_embedding[0,:] = 0.0 session.run(tf.assign(train_model.char_embedding, char_embedding)) char_embedding = session.run(train_model.char_embedding) clear_char_embedding_padding() run_test2(session, test_model, train_reader) #exit(1) ''' training starts here ''' best_valid_loss = None rnn_state = session.run(train_model.initial_rnn_state) for epoch in range(FLAGS.max_epochs): avg_train_loss = 0.0 count = 0 for x, y in train_reader.iter(): count += 1 start_time = time.time() print (x) exit(1) loss, _, rnn_state, gradient_norm, step = session.run([ train_model.loss, train_model.train_op, train_model.final_rnn_state, train_model.global_norm, train_model.global_step, ], { train_model.input : x, train_model.targets: y, train_model.initial_rnn_state: rnn_state }) clear_char_embedding_padding() avg_train_loss += 0.05 * (loss - avg_train_loss) time_elapsed = time.time() - start_time if count % FLAGS.print_every == 0: print('%6d: %d [%5d/%5d], train_loss/perplexity = %6.8f/%6.7f secs/batch = %.4fs, grad.norm=%6.8f' % (step, epoch, count, train_reader.length, loss, np.exp(loss), time_elapsed, gradient_norm)) # epoch done: time to evaluate avg_valid_loss = 0.0 count = 0 rnn_state = session.run(valid_model.initial_rnn_state) for x, y in valid_reader.iter(): count += 1 start_time = time.time() loss, rnn_state = session.run([ valid_model.loss, valid_model.final_rnn_state ], { valid_model.input : x, valid_model.targets: y, valid_model.initial_rnn_state: rnn_state, }) if count % FLAGS.print_every == 0: print("\t> validation loss = %6.8f, perplexity = %6.8f" % (loss, np.exp(loss))) avg_valid_loss += loss / valid_reader.length print("at the end of epoch:", epoch) print("train loss = %6.8f, perplexity = %6.8f" % (avg_train_loss, np.exp(avg_train_loss))) print("validation loss = %6.8f, perplexity = %6.8f" % (avg_valid_loss, np.exp(avg_valid_loss))) save_as = '%s/epoch%03d_%.4f.model' % (FLAGS.train_dir, epoch, avg_valid_loss) saver.save(session, save_as) print('Saved model', save_as) ''' write out summary events ''' summary = tf.Summary(value=[ tf.Summary.Value(tag="train_loss", simple_value=avg_train_loss), tf.Summary.Value(tag="valid_loss", simple_value=avg_valid_loss) ]) summary_writer.add_summary(summary, step) ''' decide if need to decay learning rate ''' if best_valid_loss is not None and np.exp(avg_valid_loss) > np.exp(best_valid_loss) - FLAGS.decay_when: print('** validation perplexity did not improve enough, decay learning rate') current_learning_rate = session.run(train_model.learning_rate) print('learning rate was:', current_learning_rate) current_learning_rate *= FLAGS.learning_rate_decay if current_learning_rate < 1.e-5: print('learning rate too small - stopping now') break session.run(train_model.learning_rate.assign(current_learning_rate)) print('new learning rate is:', current_learning_rate) else: best_valid_loss = avg_valid_loss run_test2(session, test_model, train_reader) print ("AGAIN") run_test2(session, test_model, train_reader)
def main(print): ''' Trains model from data ''' if not os.path.exists(FLAGS.train_dir): os.mkdir(FLAGS.train_dir) print('Created training directory' + FLAGS.train_dir) # CSV initialize df_train_params = pd.DataFrame(FLAGS.flag_values_dict(), index=range(1)) df_train_params['comment'] = '' df_train_params.to_csv(FLAGS.train_dir + '/train_parameters.csv') epochs_results = initialize_epoch_data_dict() fasttext_model_path = None if FLAGS.fasttext_model_path: fasttext_model_path = FLAGS.fasttext_model_path word_vocab, char_vocab, word_tensors, char_tensors, max_word_length, words_list, wers, acoustics = \ load_data(FLAGS.data_dir, FLAGS.max_word_length, num_unroll_steps=FLAGS.num_unroll_steps, eos=FLAGS.EOS, batch_size=FLAGS.batch_size) word_vocab_valid, char_vocab_valid, word_tensors_valid, char_tensors_valid, max_word_length_valid, words_list_valid, wers_valid,\ acoustics_valid, files_name_valid, kaldi_sents_index_valid = \ load_test_data(FLAGS.data_dir, FLAGS.max_word_length, num_unroll_steps=FLAGS.num_unroll_steps, eos=FLAGS.EOS, datas=['valid']) fasttext_model = None if 'fasttext' in FLAGS.embedding: fasttext_model = FasttextModel( fasttext_path=fasttext_model_path).get_fasttext_model() train_ft_reader = DataReaderFastText( words_list=words_list, batch_size=FLAGS.batch_size, num_unroll_steps=FLAGS.num_unroll_steps, model=fasttext_model, data='train', acoustics=acoustics) valid_ft_reader = DataReaderFastText( words_list=words_list, batch_size=FLAGS.batch_size, num_unroll_steps=FLAGS.num_unroll_steps, model=fasttext_model, data='valid', acoustics=acoustics) train_reader = DataReader(word_tensors['train'], char_tensors['train'], FLAGS.batch_size, FLAGS.num_unroll_steps, wers['train']) valid_reader = TestDataReader(word_tensors_valid['valid'], char_tensors_valid['valid'], FLAGS.batch_size, FLAGS.num_unroll_steps, wers_valid['valid'], files_name_valid['valid'], kaldi_sents_index_valid['valid']) # test_reader = DataReader(word_tensors['test'], char_tensors['test'], # FLAGS.batch_size, FLAGS.num_unroll_steps, wers['train'], word_vocab, char_vocab) print('initialized all dataset readers') with tf.Graph().as_default(), tf.Session() as session: # tensorflow seed must be inside graph tf.set_random_seed(FLAGS.seed) np.random.seed(seed=FLAGS.seed) ''' build training graph ''' initializer = tf.random_uniform_initializer(-FLAGS.param_init, FLAGS.param_init) with tf.variable_scope("Model", initializer=initializer): train_model = model.inference_graph( char_vocab_size=char_vocab.size, word_vocab_size=word_vocab.size, char_embed_size=FLAGS.char_embed_size, batch_size=FLAGS.batch_size, num_highway_layers=FLAGS.highway_layers, num_rnn_layers=FLAGS.rnn_layers, rnn_size=FLAGS.rnn_size, max_word_length=max_word_length, kernels=eval(FLAGS.kernels), kernel_features=eval(FLAGS.kernel_features), num_unroll_steps=FLAGS.num_unroll_steps, dropout=FLAGS.dropout, embedding=FLAGS.embedding, fasttext_word_dim=300, acoustic_features_dim=4) train_model.update( model.loss_graph(train_model.logits, FLAGS.batch_size)) # scaling loss by FLAGS.num_unroll_steps effectively scales gradients by the same factor. # we need it to reproduce how the original Torch code optimizes. Without this, our gradients will be # much smaller (i.e. 35 times smaller) and to get system to learn we'd have to scale learning rate and max_grad_norm appropriately. # Thus, scaling gradients so that this trainer is exactly compatible with the original train_model.update( model.training_graph(train_model.loss * FLAGS.num_unroll_steps, FLAGS.learning_rate, FLAGS.max_grad_norm)) ''' build graph for validation and testing (shares parameters with the training graph!) ''' with tf.variable_scope("Model", reuse=True): valid_model = model.inference_graph( char_vocab_size=char_vocab_valid.size, word_vocab_size=word_vocab_valid.size, char_embed_size=FLAGS.char_embed_size, batch_size=FLAGS.batch_size, num_highway_layers=FLAGS.highway_layers, num_rnn_layers=FLAGS.rnn_layers, rnn_size=FLAGS.rnn_size, max_word_length=max_word_length, kernels=eval(FLAGS.kernels), kernel_features=eval(FLAGS.kernel_features), num_unroll_steps=FLAGS.num_unroll_steps, dropout=0.0, embedding=FLAGS.embedding, fasttext_word_dim=300, acoustic_features_dim=4) valid_model.update( model.loss_graph(valid_model.logits, FLAGS.batch_size)) # create saver before creating more graph nodes, so that we do not save any vars defined below if FLAGS.load_model_for_training: # delete last layers (softmax) - SimpleLinear/Matrix + Bias variables = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES) subset_grpah_for_loading = variables[:29] + variables[31:] loader = tf.train.Saver(max_to_keep=50, var_list=subset_grpah_for_loading) saver = tf.train.Saver(max_to_keep=50) if FLAGS.load_model_for_training: loader.restore(session, FLAGS.load_model_for_training) string = str('Loaded model from' + str(FLAGS.load_model_for_training) + 'saved at global step' + str(train_model.global_step.eval())) print(string) session.run(tf.variables_initializer(var_list=variables[29:31])) string = str('initialized specific scope for fresh model. Size:' + str(model.model_size())) print(string) else: tf.global_variables_initializer().run() session.run(train_model.clear_char_embedding_padding) string = str('Created and initialized fresh model. Size:' + str(model.model_size())) print(string) summary_writer = tf.summary.FileWriter(FLAGS.train_dir, graph=session.graph) ''' take learning rate from CLI, not from saved graph ''' session.run(tf.assign(train_model.learning_rate, FLAGS.learning_rate), ) ''' training starts here ''' best_valid_loss = None rnn_state = session.run(train_model.initial_rnn_state) for epoch in range(FLAGS.max_epochs): epoch_start_time = time.time() avg_train_loss = 0.0 count = 0 for batch_kim, batch_ft in zip(train_reader.iter(), train_ft_reader.iter()): x, y = batch_kim count += 1 start_time = time.time() if fasttext_model: ft_vectors = fasttext_model.wv[ words_list['train'][count]].reshape( fasttext_model.wv.vector_size, 1) loss, _, rnn_state, gradient_norm, step, _, logits = session.run( [ train_model.loss, train_model.train_op, train_model.final_rnn_state, train_model.global_norm, train_model.global_step, train_model.clear_char_embedding_padding, train_model.logits ], { train_model.input2: batch_ft, train_model.input: x, train_model.targets: y, train_model.initial_rnn_state: rnn_state }) else: loss, _, rnn_state, gradient_norm, step, _, logits = session.run( [ train_model.loss, train_model.train_op, train_model.final_rnn_state, train_model.global_norm, train_model.global_step, train_model.clear_char_embedding_padding, train_model.logits ], { train_model.input: x, train_model.targets: y, train_model.initial_rnn_state: rnn_state }) avg_train_loss += 0.05 * (loss - avg_train_loss) time_elapsed = time.time() - start_time if count % FLAGS.print_every == 0: string = str( '%6d: %d [%5d/%5d], train_loss = %6.8f secs/batch = %.4fs' % (step, epoch, count, train_reader.length, loss, time_elapsed)) print(string) string = str('Epoch training time:' + str(time.time() - epoch_start_time)) print(string) epochs_results['epoch_training_time'].append( str(time.time() - epoch_start_time)) # epoch done: time to evaluate avg_valid_loss = 0. labels = [] predictions = [] files_name_list = [] kaldi_sents_index_list = [] count = 0 rnn_state = session.run(valid_model.initial_rnn_state) for batch_kim, batch_ft in zip(valid_reader.iter(), valid_ft_reader.iter()): x, y, files_name_batch, kaldi_sents_index_batch = batch_kim count += 1 start_time = time.time() loss, logits = session.run( [valid_model.loss, valid_model.logits], { valid_model.input2: batch_ft, valid_model.input: x, valid_model.targets: y, valid_model.initial_rnn_state: rnn_state, }) labels.append(y) predictions.append(logits) files_name_list.append(files_name_batch) kaldi_sents_index_list.append(kaldi_sents_index_batch) if count % FLAGS.print_every == 0: string = str("\t> validation loss = %6.8f" % (loss)) print(string) avg_valid_loss = get_valid_rescore_loss(labels, predictions, files_name_list, kaldi_sents_index_list) print("at the end of epoch:" + str(epoch)) epochs_results['epoch_number'].append(str(epoch)) print("train loss = %6.8f" % (avg_train_loss)) epochs_results['train_loss'].append(avg_train_loss) print("validation loss = %6.8f" % (avg_valid_loss)) epochs_results['validation_loss'].append(avg_valid_loss) save_as = '%s/epoch%03d_%.4f.model' % (FLAGS.train_dir, epoch, avg_valid_loss) saver.save(session, save_as) print('Saved model' + str(save_as)) epochs_results['model_name'].append(str(save_as)) epochs_results['learning_rate'].append( str(session.run(train_model.learning_rate))) current_learning_rate = session.run(train_model.learning_rate) ''' decide if need to decay learning rate ''' if best_valid_loss is not None and avg_valid_loss > best_valid_loss - FLAGS.decay_when: print( 'validation perplexity did not improve enough, decay learning rate' ) current_learning_rate = session.run(train_model.learning_rate) string = str('learning rate was:' + str(current_learning_rate)) print(string) current_learning_rate *= FLAGS.learning_rate_decay if current_learning_rate < 1.e-6: print('learning rate too small - stopping now') break session.run( train_model.learning_rate.assign(current_learning_rate)) string = str('new learning rate is:' + str(current_learning_rate)) print(string) else: best_valid_loss = avg_valid_loss ''' write out summary events ''' summary = tf.Summary(value=[ tf.Summary.Value(tag="train_loss", simple_value=avg_train_loss), tf.Summary.Value(tag="valid_loss", simple_value=avg_valid_loss), tf.Summary.Value(tag="learning_rate", simple_value=current_learning_rate) ]) summary_writer.add_summary(summary, step) # Save model performance data pd.DataFrame(epochs_results).to_csv(FLAGS.train_dir + '/train_results.csv')
def main(_): ''' Trains model from data ''' min = [1000, 1000, 1000, 1000] # [t_loss, t_ppl, v_loss, v_ppl] total_time = 0. if not os.path.exists(FLAGS.train_dir): os.mkdir(FLAGS.train_dir) print('Created training directory', FLAGS.train_dir) word_vocab, \ char_vocab, \ word_tensors, \ char_tensors, \ max_word_length = load_data(FLAGS.data_dir, FLAGS.max_word_length, flist = FILE_NAME_LIST, eos=FLAGS.EOS) train_reader = DataReader(word_tensors[FILE_NAME_LIST[0]], FLAGS.batch_size, FLAGS.num_unroll_steps) valid_reader = DataReader(word_tensors[FILE_NAME_LIST[1]], FLAGS.batch_size, FLAGS.num_unroll_steps) test_reader = DataReader(word_tensors[FILE_NAME_LIST[2]], FLAGS.batch_size, FLAGS.num_unroll_steps) print('initialized all dataset readers') with tf.Graph().as_default(), tf.Session() as session: # tensorflow seed must be inside graph tf.set_random_seed(FLAGS.seed) np.random.seed(seed=FLAGS.seed) ''' build training graph ''' initializer = tf.random_uniform_initializer(-FLAGS.param_init, FLAGS.param_init) with tf.variable_scope("Model", initializer=initializer): train_model = model.inference_graph( word_vocab_size=word_vocab.size, word_embed_size=FLAGS.word_embed_size, batch_size=FLAGS.batch_size, num_highway_layers=FLAGS.highway_layers, num_rnn_layers=FLAGS.rnn_layers, rnn_size=FLAGS.rnn_size, num_unroll_steps=FLAGS.num_unroll_steps, dropout=FLAGS.dropout) train_model.update( model.loss_graph(train_model.logits, FLAGS.batch_size, FLAGS.num_unroll_steps)) # scaling loss by FLAGS.num_unroll_steps effectively scales gradients by the same factor. # we need it to reproduce how the original Torch code optimizes. Without this, our gradients will be # much smaller (i.e. 35 times smaller) and to get system to learn we'd have to scale learning rate and max_grad_norm appropriately. # Thus, scaling gradients so that this trainer is exactly compatible with the original train_model.update( model.training_graph(train_model.loss * FLAGS.num_unroll_steps, FLAGS.learning_rate, FLAGS.max_grad_norm)) # create saver before creating more graph nodes, so that we do not save any vars defined below saver = tf.train.Saver(max_to_keep=5) ''' build graph for validation and testing (shares parameters with the training graph!) ''' with tf.variable_scope("Model", reuse=True): valid_model = model.inference_graph( word_vocab_size=word_vocab.size, word_embed_size=FLAGS.word_embed_size, batch_size=FLAGS.batch_size, num_highway_layers=FLAGS.highway_layers, num_rnn_layers=FLAGS.rnn_layers, rnn_size=FLAGS.rnn_size, num_unroll_steps=FLAGS.num_unroll_steps, dropout=0.0) valid_model.update( model.loss_graph(valid_model.logits, FLAGS.batch_size, FLAGS.num_unroll_steps)) if FLAGS.load_model: saver.restore(session, FLAGS.load_model) print('Loaded model from', FLAGS.load_model, 'saved at global step', train_model.global_step.eval()) else: tf.global_variables_initializer().run() session.run(train_model.clear_char_embedding_padding) print('Created and initialized fresh model. Size:', model.model_size()) summary_writer = tf.summary.FileWriter(FLAGS.train_dir, graph=session.graph) ''' take learning rate from CLI, not from saved graph ''' session.run(tf.assign(train_model.learning_rate, FLAGS.learning_rate)) print("=" * 89) print("=" * 89) all_weights = {v.name: v for v in tf.trainable_variables()} total_size = 0 pi = 1 # 0 is for sum of grad_sses for v_name in list(all_weights): # sorted() v = all_weights[v_name] v_size = int(np.prod(np.array(v.shape.as_list()))) print("%02d-Weight %s\tshape %s\ttsize %d" % (pi, v.name[:-2].ljust(80), str(v.shape).ljust(20), v_size)) total_size += v_size pi += 1 print("Total size %d, %.3fMiB" % (total_size, (total_size * 4) / (1024 * 1024))) print("-" * 89) ''' training starts here ''' best_valid_loss = None rnn_state = session.run(train_model.initial_rnn_state) for epoch in range(1, FLAGS.max_epochs + 1): epoch_start_time = time.time() avg_train_loss = 0.0 count = 0 for x, y in train_reader.iter(): count += 1 start_time = time.time() loss, _, rnn_state, gradient_norm, step, _ = session.run( [ train_model.loss, train_model.train_op, train_model.final_rnn_state, train_model.global_norm, train_model.global_step, train_model.clear_char_embedding_padding ], { train_model.input: x, train_model.targets: y, train_model.initial_rnn_state: rnn_state }) avg_train_loss += 0.05 * (loss - avg_train_loss) time_elapsed = time.time() - start_time if count % FLAGS.print_every == 0: cur_lr = session.run(train_model.learning_rate) print( '%6d: -%d- [%5d/%5d], train_loss/ppl = %6.8f/%6.7f batch/secs = %.1fb/s, cur_lr = %2.5f, grad.norm=%6.8f' % (step, epoch, count, train_reader.length, loss, np.exp(loss), FLAGS.print_every / time_elapsed, cur_lr, gradient_norm)) print('Epoch training time:', time.time() - epoch_start_time) total_time += (time.time() - epoch_start_time) # epoch done: time to evaluate avg_valid_loss = 0.0 count = 0 rnn_state = session.run(valid_model.initial_rnn_state) for x, y in valid_reader.iter(): count += 1 start_time = time.time() loss, rnn_state = session.run( [valid_model.loss, valid_model.final_rnn_state], { valid_model.input: x, valid_model.targets: y, valid_model.initial_rnn_state: rnn_state, }) if count % FLAGS.print_every == 0: print("\t> validation loss = %6.8f, perplexity = %6.8f" % (loss, np.exp(loss))) avg_valid_loss += loss / valid_reader.length print("at the end of epoch:", epoch) print("train loss = %6.8f, perplexity = %6.8f" % (avg_train_loss, np.exp(avg_train_loss))) print("validation loss = %6.8f, perplexity = %6.8f" % (avg_valid_loss, np.exp(avg_valid_loss))) if min[2] > avg_valid_loss: min[0] = avg_train_loss min[1] = np.exp(avg_train_loss) min[2] = avg_valid_loss min[3] = np.exp(avg_valid_loss) save_as = '%s/epoch%03d_%.4f.model' % (FLAGS.train_dir, epoch, avg_valid_loss) saver.save(session, save_as) print('Saved model', save_as) ''' write out summary events ''' summary = tf.Summary(value=[ tf.Summary.Value(tag="train_loss", simple_value=avg_train_loss), tf.Summary.Value(tag="valid_loss", simple_value=avg_valid_loss) ]) summary_writer.add_summary(summary, step) ''' decide if need to decay learning rate ''' if best_valid_loss is not None and np.exp(avg_valid_loss) > np.exp( best_valid_loss) - FLAGS.decay_when: print( 'validation perplexity did not improve enough, decay learning rate' ) current_learning_rate = session.run(train_model.learning_rate) print('learning rate was:', current_learning_rate) current_learning_rate *= FLAGS.learning_rate_decay if current_learning_rate < 1.e-5: print('learning rate too small - stopping now') break session.run( train_model.learning_rate.assign(current_learning_rate)) print('new learning rate is:', current_learning_rate) else: best_valid_loss = avg_valid_loss ''' test on the test set ''' ave_test_loss = 0. trnn_state = session.run(valid_model.initial_rnn_state) for x, y in test_reader.iter(): loss, trnn_state = session.run( [valid_model.loss, valid_model.final_rnn_state], { valid_model.input: x, valid_model.targets: y, valid_model.initial_rnn_state: trnn_state }) disp_loss = loss ave_test_loss += disp_loss / test_reader.length print("=" * 89) print("=" * 89) print("Total training time(not included the valid time): %f" % total_time) print("The best result:") print("train loss = %.3f, ppl = %.4f" % (min[0], min[1])) print("valid loss = %.3f, ppl = %.4f" % (min[2], min[3])) print("test loss = %.3f, ppl = %.4f" % (ave_test_loss, np.exp(ave_test_loss))) print("=" * 89)
def main(): pretrain_word2id, pretrain_id2word, pretrain_emb = reader.load_pretrain( FLAGS.pretrain_path, [FLAGS.train_path, FLAGS.validate_path, FLAGS.test_path]) vocabs = reader.build_vocab(FLAGS.train_path) traindata = reader.DataSet(FLAGS.train_path, FLAGS.max_word_len, pretrain_word2id, pretrain_id2word, pretrain_emb, vocabs) traindata.load_data() validate = reader.DataSet(FLAGS.validate_path, FLAGS.max_word_len, pretrain_word2id, pretrain_id2word, pretrain_emb, vocabs) validate.load_data() test = reader.DataSet(FLAGS.test_path, FLAGS.max_word_len, pretrain_word2id, pretrain_id2word, pretrain_emb, vocabs) test.load_data() seq_lens = FLAGS.num_steps * np.ones(FLAGS.batch_size) with tf.Graph().as_default(), tf.Session() as sess: with tf.variable_scope("Model"): train_model = model.inference_graph( char_vocab_size=len(traindata.char2id), pretrain_embedding=traindata.pretrain_emb, max_word_len=FLAGS.max_word_len, ntags=len(traindata.tag2id), batch_size=FLAGS.batch_size, num_steps=FLAGS.num_steps, char_emb_size=FLAGS.char_emb_size, lstm_state_size=FLAGS.lstm_state_size, num_rnn_layers=FLAGS.num_rnn_layers, dropout=FLAGS.dropout, filter_sizes=[FLAGS.filter_size], nfilters=[FLAGS.nfilter]) train_model.update(model.loss_graph(train_model.logits, FLAGS.batch_size, FLAGS.num_steps, FLAGS.crf, seq_lens)) train_model.update(model.training_graph(train_model.loss * FLAGS.num_steps, FLAGS.learning_rate, FLAGS.max_grad_norm)) #train_model.update(model.training_graph(train_model.loss)) saver = tf.train.Saver() '''Validate model''' with tf.variable_scope("Model", reuse=True): validate_model=model.inference_graph( char_vocab_size=len(validate.char2id), pretrain_embedding=validate.pretrain_emb, max_word_len=FLAGS.max_word_len, ntags=len(validate.tag2id), batch_size=FLAGS.batch_size, num_steps=FLAGS.num_steps, char_emb_size=FLAGS.char_emb_size, lstm_state_size=FLAGS.lstm_state_size, num_rnn_layers=FLAGS.num_rnn_layers, dropout=0, #No dropout when testing! filter_sizes=[FLAGS.filter_size], nfilters=[FLAGS.nfilter]) validate_model.update(model.loss_graph(validate_model.logits, FLAGS.batch_size, FLAGS.num_steps, FLAGS.crf, seq_lens)) validate_model.update(model.adict(name="validation")) '''Test model''' with tf.variable_scope("Model", reuse=True): test_model=model.inference_graph( char_vocab_size=len(test.char2id), pretrain_embedding=test.pretrain_emb, max_word_len=FLAGS.max_word_len, ntags=len(test.tag2id), batch_size=FLAGS.batch_size, num_steps=FLAGS.num_steps, char_emb_size=FLAGS.char_emb_size, lstm_state_size=FLAGS.lstm_state_size, num_rnn_layers=FLAGS.num_rnn_layers, dropout=0, filter_sizes=[FLAGS.filter_size], nfilters=[FLAGS.nfilter]) test_model.update(model.loss_graph(test_model.logits, FLAGS.batch_size, FLAGS.num_steps, FLAGS.crf, seq_lens)) test_model.update(model.adict(name="test")) init_op = tf.global_variables_initializer() sess.run(init_op) lstm_state_fw = sess.run(train_model.initial_lstm_state_fw) lstm_state_bw = sess.run(train_model.initial_lstm_state_bw) print "Start Training..." current_best_Fscore = 0.0 for epoch in range(FLAGS.total_epoch): print "epoch", epoch start_time = time.time() loss = run_epoch(sess, traindata, train_model, lstm_state_fw, lstm_state_bw, FLAGS.batch_size, FLAGS.num_steps) if FLAGS.crf: Fscore = crf_eval(sess, validate, validate_model, FLAGS.batch_size, FLAGS.num_steps, FLAGS.eval_path, FLAGS.eval_script_path) else: Fscore = evaluate(sess, validate, validate_model, FLAGS.batch_size, FLAGS.num_steps, FLAGS.eval_path) if Fscore > current_best_Fscore: current_best_Fscore = Fscore print "**Results on test set with current best F:", current_best_Fscore crf_eval(sess, test, test_model, FLAGS.batch_size, FLAGS.num_steps, FLAGS.eval_path, FLAGS.eval_script_path) saver.save(sess, FLAGS.checkpoint_path) print "Model saved!" new_learning_rate = FLAGS.learning_rate / (1 + FLAGS.decay_rate * (epoch + 1)) sess.run(train_model.learning_rate.assign(new_learning_rate)) end_time = time.time() print "Epoch training time:", end_time - start_time