def step1(args): # training variational autoencoder train_id_path, dev_id_path, vocab_path = data_utils.prepare_diologue(args.works_dir, args.vocab_size) checkpoint_step = 200 gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=1) with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess: print () print ('-------loading model-------') model = v_autoencoder(sess, args, feed_previous=False) ckpt = tf.train.get_checkpoint_state(args.model_dir) if ckpt and ckpt.model_checkpoint_path: print("Reading model parameters from %s @ %s" % (ckpt.model_checkpoint_path, datetime.now())) sess.run(tf.global_variables_initializer()) model.saver.restore(sess, ckpt.model_checkpoint_path) print("Model reloaded @ %s" % (datetime.now())) else: print("Created model with fresh parameters.") sess.run(tf.global_variables_initializer()) print ('loading dictionary...') vocab, rev_vocab = data_utils.initialize_vocab(vocab_path) print ('loading dev set form %s...' %dev_id_path) dev_set = data_utils.read_data(dev_id_path) print ('loading train set form %s...' %train_id_path) train_set = data_utils.read_data(train_id_path) print ('-------start training-------') seq_loss, kl_loss = 0.0, 0.0 current_step = 0 previous_losses = [] while True: encoder_inputs, decoder_inputs, weights = model.train_get_batch(train_set) step_seq_loss, step_kl_loss = model.ae_step(sess, encoder_inputs, decoder_inputs, weights, False) sess.run(model.kl_weight_op) sess.run(model.sample_rate_op) seq_loss += step_seq_loss / checkpoint_step kl_loss += step_kl_loss / checkpoint_step current_step += 1 if current_step % checkpoint_step == 0: print ("global step %d seq_loss %.4f kl_loss %.4f @ %s" %(model.global_step.eval(), math.exp(seq_loss), kl_loss, datetime.now())) checkpoint_path = os.path.join(args.model_dir, "model.ckpt") model.saver.save(sess, checkpoint_path ) seq_loss, kl_loss = 0.0, 0.0 encoder_inputs, decoder_inputs, weights = model.train_get_batch(dev_set) step_seq_loss, step_kl_loss = model.ae_step(sess, encoder_inputs, decoder_inputs, weights, True) print (" eval: seq_loss %.2f" %(math.exp(step_seq_loss))) sys.stdout.flush()
def test(self): print ('---------prepare data---------') data_id_path, vocab_path = data_utils.prepare_test_data(self.works_dir, self.data_path, self.vocab_size) print ('loading dictionary...') vocab, rev_vocab = data_utils.initialize_vocab(vocab_path) self.sess.run(tf.global_variables_initializer()) ckpt = tf.train.get_checkpoint_state(self.works_dir) if ckpt and ckpt.model_checkpoint_path: print("Reading model parameters from %s @ %s" % (ckpt.model_checkpoint_path, datetime.now())) self.saver.restore(self.sess, ckpt.model_checkpoint_path) print("Model reloaded @ %s" % (datetime.now())) else: raise ValueError("can't find the path" ) print ('loading data set form %s...' %data_id_path) data_set = data_utils.read_data(data_id_path, 1.0) fout = open(os.path.join(self.works_dir, 'seq2seq_pos.txt'), 'w') for batch_encoder_inputs, _, i in self.get_batch_epoch(data_set, data_set): _, _, fake_pos_id, _ = self.get_sentence(self.sess, batch_encoder_inputs) data_size = self.batch_size if i + self.batch_size > len(data_set): data_size = len(data_set) - i print ('\r', data_size, i, end='') for t in range(data_size): fout.write(self.print_sentence(fake_pos_id, rev_vocab, t)+'\n')
def train(args): print("[%s] Preparing dialog data in %s" % (args.model_name, args.data_dir)) setup_workpath(workspace=args.workspace) train_data, dev_data, _ = data_utils.prepare_dialog_data( args.data_dir, args.vocab_size) #### GET DATA ###### inti beer def get_gold(workspace=args.workspace): data_dir = "%s/data" % (workspace) full_path = str(sys.path[-1]) + "/" + data_dir + "/train/chat.txt.gz" print(full_path) with gzip.open(full_path, 'rb') as zi: test_sentences = zi.read() test_sentences = test_sentences.decode().split("\n") zi.close() return test_sentences ######get data data_ = get_gold() if args.reinforce_learn: args.batch_size = 1 # We decode one sentence at a time. gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=args.gpu_usage) with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess: # Create model. print("Creating %d layers of %d units." % (args.num_layers, args.size)) model = seq2seq_model_utils.create_model(sess, args, forward_only=False) # Read data into buckets and compute their sizes. print("Reading development and training data (limit: %d)." % args.max_train_data_size) dev_set = data_utils.read_data(dev_data, args.buckets, reversed=args.rev_model) train_set = data_utils.read_data(train_data, args.buckets, args.max_train_data_size, reversed=args.rev_model) train_bucket_sizes = [ len(train_set[b]) for b in xrange(len(args.buckets)) ] train_total_size = float(sum(train_bucket_sizes)) # A bucket scale is a list of increasing numbers from 0 to 1 that we'll use # to select a bucket. Length of [scale[i], scale[i+1]] is proportional to # the size if i-th training bucket, as used later. train_buckets_scale = [ sum(train_bucket_sizes[:i + 1]) / train_total_size for i in xrange(len(train_bucket_sizes)) ] # This is the training loop. step_time, loss = 0.0, 0.0 current_step = 0 previous_losses = [] # Load vocabularies. vocab_path = os.path.join(args.data_dir, "vocab%d.in" % args.vocab_size) vocab, rev_vocab = data_utils.initialize_vocabulary(vocab_path) while True: # Choose a bucket according to data distribution. We pick a random number # in [0, 1] and use the corresponding interval in train_buckets_scale. random_number_01 = np.random.random_sample() bucket_id = min([ i for i in xrange(len(train_buckets_scale)) if train_buckets_scale[i] > random_number_01 ]) # Get a batch and make a step. start_time = time.time() encoder_inputs, decoder_inputs, target_weights, encoder_input, decoder_input = model.get_batch( train_set, bucket_id) print("[shape]", np.shape(encoder_inputs), np.shape(decoder_inputs), np.shape(target_weights)) if args.reinforce_learn: _, step_loss, _ = model.step_rf(args, sess, encoder_inputs, decoder_inputs, target_weights, bucket_id, data_, encoder_input, decoder_input, rev_vocab=rev_vocab, forward_only=False) else: _, step_loss, _ = model.step(sess, encoder_inputs, decoder_inputs, target_weights, bucket_id, forward_only=False, force_dec_input=True) step_time += (time.time() - start_time) / args.steps_per_checkpoint loss += step_loss / args.steps_per_checkpoint current_step += 1 print("Current step: " + str(current_step)) # Once in a while, we save checkpoint, print statistics, and run evals. if current_step % args.steps_per_checkpoint == 0: #and (not args.reinforce_learn): # Print statistics for the previous epoch. perplexity = math.exp(loss) if loss < 300 else float('inf') print( "global step %d learning rate %.4f step-time %.2f perplexity %.2f @ %s" % (model.global_step.eval(), model.learning_rate.eval(), step_time, perplexity, datetime.now())) # Decrease learning rate if no improvement was seen over last 3 times. if len(previous_losses) > 2 and loss > max( previous_losses[-3:]): sess.run(model.learning_rate_decay_op) previous_losses.append(loss) # # Save checkpoint and zero timer and loss. checkpoint_path = os.path.join(args.model_dir, "model.ckpt") model.saver.save(sess, checkpoint_path, global_step=model.global_step) step_time, loss = 0.0, 0.0 # Run evals on development set and print their perplexity. for bucket_id in xrange(len(args.buckets)): encoder_inputs, decoder_inputs, target_weights, _, _ = model.get_batch( dev_set, bucket_id) _, eval_loss, _ = model.step(sess, encoder_inputs, decoder_inputs, target_weights, bucket_id, forward_only=True, force_dec_input=False) eval_ppx = math.exp( eval_loss) if eval_loss < 300 else float('inf') print(" eval: bucket %d perplexity %.2f" % (bucket_id, eval_ppx)) sys.stdout.flush()
def train(): print("Preparing dialog data in %s" % FLAGS.data_dir) train_data, dev_data, _ = data_utils.prepare_dialog_data( FLAGS.data_dir, FLAGS.vocab_size) with tf.Session() as sess: # Create model. print("Creating %d layers of %d units." % (FLAGS.num_layers, FLAGS.size)) model = create_model(sess, forward_only=False) print("Reading development and training data (limit: %d)." % FLAGS.max_train_data_size) dev_set = read_data(dev_data) train_set = read_data(train_data, FLAGS.max_train_data_size) train_bucket_sizes = [len(train_set[b]) for b in xrange(len(BUCKETS))] train_total_size = float(sum(train_bucket_sizes)) train_buckets_scale = [ sum(train_bucket_sizes[:i + 1]) / train_total_size for i in xrange(len(train_bucket_sizes)) ] # This is the training loop. print("Start training ...") step_time, loss = 0.0, 0.0 current_step = 0 previous_losses = [] while True: random_number_01 = np.random.random_sample() bucket_id = min([ i for i in xrange(len(train_buckets_scale)) if train_buckets_scale[i] > random_number_01 ]) # Get a batch and make a step. start_time = time.time() encoder_inputs, decoder_inputs, target_weights = model.get_batch( train_set, bucket_id) _, step_loss, _ = model.step(sess, encoder_inputs, decoder_inputs, target_weights, bucket_id, forward_only=False) step_time += (time.time() - start_time) / FLAGS.steps_per_checkpoint loss += step_loss / FLAGS.steps_per_checkpoint current_step += 1 if current_step % FLAGS.steps_per_checkpoint == 0: perplexity = math.exp(loss) if loss < 300 else float('inf') print( "global step %d learning rate %.4f step-time %.2f perplexity %.2f" % (model.global_step.eval(), model.learning_rate.eval(), step_time, perplexity)) if len(previous_losses) > 2 and loss > max( previous_losses[-3:]): sess.run(model.learning_rate_decay_op) previous_losses.append(loss) checkpoint_path = os.path.join(FLAGS.model_dir, "model.ckpt") model.saver.save(sess, checkpoint_path, global_step=model.global_step) step_time, loss = 0.0, 0.0 for bucket_id in xrange(len(BUCKETS)): encoder_inputs, decoder_inputs, target_weights = model.get_batch( dev_set, bucket_id) _, eval_loss, _ = model.step(sess, encoder_inputs, decoder_inputs, target_weights, bucket_id, True) eval_ppx = math.exp( eval_loss) if eval_loss < 300 else float('inf') print(" eval: bucket %d perplexity %.2f" % (bucket_id, eval_ppx)) sys.stdout.flush()
def train(): print("Preparing dialog data in %s" % FLAGS.data_dir) train_data, dev_data, _ = data_utils.prepare_dialog_data( FLAGS.data_dir, FLAGS.vocab_size) config = tf.ConfigProto() config.gpu_options.allow_growth = True with tf.Session(config=config) as sess: record_file_name = "seq2seq_loss" record_file = open(pjoin(FLAGS.results_dir, record_file_name), mode="ab", buffering=0) # Create model. print("Creating %d layers of %d units." % (FLAGS.num_layers, FLAGS.hidden_size)) model = create_model(sess, forward_only=False) # Read data into buckets and compute their sizes. print("Reading development and training data (limit: %d)." % FLAGS.max_train_data_size) dev_set = read_data(dev_data) train_set = read_data(train_data, FLAGS.max_train_data_size) train_bucket_sizes = [len(train_set[b]) for b in xrange(len(BUCKETS))] train_total_size = float(sum(train_bucket_sizes)) # A bucket scale is a list of increasing numbers from 0 to 1 that we'll use # to select a bucket. Length of [scale[i], scale[i+1]] is proportional to # the size if i-th training bucket, as used later. train_buckets_scale = [ sum(train_bucket_sizes[:i + 1]) / train_total_size for i in xrange(len(train_bucket_sizes)) ] # This is the training loop. step_time, total_time, loss = 0.0, 0.0, 0.0 previous_losses = [] print("start train...") while (True): # Choose a bucket according to data distribution. We pick a random number # in [0, 1] and use the corresponding interval in train_buckets_scale. random_number_01 = np.random.random_sample() bucket_id = min([ i for i in xrange(len(train_buckets_scale)) if train_buckets_scale[i] > random_number_01 ]) # Get a batch and make a step. start_time = time.time() encoder_inputs, decoder_inputs, target_weights = model.get_batch( train_set, bucket_id, "train") _, step_loss, _ = model.step(sess, encoder_inputs, decoder_inputs, target_weights, bucket_id, forward_only=False) step_time += (time.time() - start_time) / FLAGS.steps_per_checkpoint loss += step_loss / FLAGS.steps_per_checkpoint # Once in a while, we save checkpoint, print statistics, and run evals. if model.global_step.eval() % FLAGS.steps_per_checkpoint == 0: print("\nTraining...") if loss > 6: print("inf !!!") sys.exit(0) total_time = step_time * FLAGS.steps_per_checkpoint print( "global step %d learning rate %.4f step-time %.2f total_time %.4f, loss %0.7f" % (model.global_step.eval(), model.learning_rate.eval(), step_time, total_time, loss)) # Decrease learning rate if no improvement was seen over last 3 times. if len(previous_losses) > 2 and loss > max( previous_losses[-3:]): sess.run(model.learning_rate_decay_op) previous_losses.append(loss) # Run evals on development set and print their perplexity. for bucket_id in xrange(len(BUCKETS)): print("Testing...") encoder_inputs, decoder_inputs, target_weights = model.get_batch( dev_set, bucket_id, "train") _, eval_loss, _ = model.step(sess, encoder_inputs, decoder_inputs, target_weights, bucket_id, True) if eval_loss > 6: print("inf !!!") sys.exit(0) print("eval: bucket %d, loss %0.5f" % (bucket_id, eval_loss)) sys.stdout.flush() record_file.write("%d\t%.5f\t%.5f\n" % (model.global_step.eval(), loss, eval_loss)) # Save checkpoint and zero timer and loss. if model.global_step.eval( ) % FLAGS.steps_per_predictpoint == 0: checkpoint_path = os.path.join(FLAGS.model_dir, "model.ckpt") model.saver.save(sess, checkpoint_path, global_step=model.global_step) step_time, loss = 0.0, 0.0
def train(args): print("[%s] Preparing dialog data in %s" % (args.model_name, args.data_dir)) setup_workpath(workspace=args.workspace) train_data, dev_data, _ = data_utils.prepare_dialog_data(args.data_dir, args.vocab_size) if args.reinforce_learn: args.batch_size = 1 # We decode one sentence at a time. gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=args.gpu_usage) with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess: # Create model. print("Creating %d layers of %d units." % (args.num_layers, args.size)) model = seq2seq_model_utils.create_model(sess, args, forward_only=False) # Read data into buckets and compute their sizes. print("Reading development and training data (limit: %d)." % args.max_train_data_size) dev_set = data_utils.read_data(dev_data, args.buckets, reversed=args.rev_model) train_set = data_utils.read_data(train_data, args.buckets, args.max_train_data_size, reversed=args.rev_model) train_bucket_sizes = [len(train_set[b]) for b in xrange(len(args.buckets))] train_total_size = float(sum(train_bucket_sizes)) # A bucket scale is a list of increasing numbers from 0 to 1 that we'll use # to select a bucket. Length of [scale[i], scale[i+1]] is proportional to # the size if i-th training bucket, as used later. train_buckets_scale = [sum(train_bucket_sizes[:i + 1]) / train_total_size for i in xrange(len(train_bucket_sizes))] # This is the training loop. step_time, loss = 0.0, 0.0 current_step = 0 previous_losses = [] # Load vocabularies. vocab_path = os.path.join(args.data_dir, "vocab%d.in" % args.vocab_size) vocab, rev_vocab = data_utils.initialize_vocabulary(vocab_path) while True: # Choose a bucket according to data distribution. We pick a random number # in [0, 1] and use the corresponding interval in train_buckets_scale. random_number_01 = np.random.random_sample() bucket_id = min([i for i in xrange(len(train_buckets_scale)) if train_buckets_scale[i] > random_number_01]) # Get a batch and make a step. start_time = time.time() encoder_inputs, decoder_inputs, target_weights = model.get_batch( train_set, bucket_id) # print("[shape]", np.shape(encoder_inputs), np.shape(decoder_inputs), np.shape(target_weights)) if args.reinforce_learn: _, step_loss, _ = model.step_rf(args, sess, encoder_inputs, decoder_inputs, target_weights, bucket_id, rev_vocab=rev_vocab) else: _, step_loss, _ = model.step(sess, encoder_inputs, decoder_inputs, target_weights, bucket_id, forward_only=False, force_dec_input=True) step_time += (time.time() - start_time) / args.steps_per_checkpoint loss += step_loss / args.steps_per_checkpoint current_step += 1 # Once in a while, we save checkpoint, print statistics, and run evals. if (current_step % args.steps_per_checkpoint == 0) and (not args.reinforce_learn): # Print statistics for the previous epoch. perplexity = math.exp(loss) if loss < 300 else float('inf') print ("global step %d learning rate %.4f step-time %.2f perplexity %.2f @ %s" % (model.global_step.eval(), model.learning_rate.eval(), step_time, perplexity, datetime.now())) # Decrease learning rate if no improvement was seen over last 3 times. if len(previous_losses) > 2 and loss > max(previous_losses[-3:]): sess.run(model.learning_rate_decay_op) previous_losses.append(loss) # # Save checkpoint and zero timer and loss. checkpoint_path = os.path.join(args.model_dir, "model.ckpt") model.saver.save(sess, checkpoint_path, global_step=model.global_step) step_time, loss = 0.0, 0.0 # Run evals on development set and print their perplexity. for bucket_id in xrange(len(args.buckets)): encoder_inputs, decoder_inputs, target_weights = model.get_batch(dev_set, bucket_id) _, eval_loss, _ = model.step(sess, encoder_inputs, decoder_inputs, target_weights, bucket_id, forward_only=True, force_dec_input=False) eval_ppx = math.exp(eval_loss) if eval_loss < 300 else float('inf') print(" eval: bucket %d perplexity %.2f" % (bucket_id, eval_ppx)) sys.stdout.flush()
def train(self): print ('---------prepare data---------') pos_id_path, neg_id_path, vocab_path = data_utils.prepare_diologue(self.works_dir, self.data_path, self.vocab_size) print ('loading dictionary...') vocab, rev_vocab = data_utils.initialize_vocab(vocab_path) print ('loading pos set form %s...' %pos_id_path) pos_set = data_utils.read_data(pos_id_path, 1.0) print ('loading neg set from %s...' %neg_id_path) neg_set = data_utils.read_data(neg_id_path, 0.0) print ('---------building model---------') self.sess.run(tf.global_variables_initializer()) ckpt = tf.train.get_checkpoint_state(self.works_dir) if ckpt and ckpt.model_checkpoint_path: print("Reading model parameters from %s @ %s" % (ckpt.model_checkpoint_path, datetime.now())) self.saver.restore(self.sess, ckpt.model_checkpoint_path) print("Model reloaded @ %s" % (datetime.now())) else: print ('Creating new parameters @ %s' % (datetime.now())) pos_seq_loss, neg_seq_loss = 0.0, 0.0 if self.pretrain: print ('--------start pretraining-------') for i in range(2000): batch_encoder_inputs, batch_target_weights = self.get_batch(pos_set, neg_set) pos_sequence_loss, neg_sequence_loss = self.pretrain_step(self.sess, batch_encoder_inputs, batch_target_weights) pos_seq_loss += pos_sequence_loss / self.checkpoint_step neg_seq_loss += neg_sequence_loss / self.checkpoint_step if (i+1) % self.checkpoint_step == 0: print ("iter: ", i, "pos_perplexity %.4f neg_d_loss %.4f @ %s" %(math.exp(pos_seq_loss), math.exp(neg_seq_loss), datetime.now())) pos_seq_loss, neg_seq_loss = 0.0, 0.0 g_loss, pos_d_loss, neg_d_loss, pos_seq_loss, neg_seq_loss = 0.0, 0.0, 0.0, 0.0, 0.0 current_step = 0 print ('---------start training---------') while True: if current_step == 200000: break batch_encoder_inputs, batch_target_weights = self.get_batch(pos_set, neg_set) gen_loss, pos_adv_loss, neg_adv_loss, pos_sequence_loss, neg_sequence_loss = self.g_step(self.sess, batch_encoder_inputs, batch_target_weights, train=True) pos_dis_loss, neg_dis_loss, pos_adv_loss, neg_adv_loss = self.d_step(self.sess, batch_encoder_inputs, train=True) g_loss += gen_loss / self.checkpoint_step pos_d_loss += pos_dis_loss / self.checkpoint_step neg_d_loss += neg_dis_loss / self.checkpoint_step pos_seq_loss += pos_sequence_loss / self.checkpoint_step neg_seq_loss += neg_sequence_loss / self.checkpoint_step # print (current_step) current_step += 1 if current_step % self.checkpoint_step == 0: print ('global step', self.sess.run(self.global_step), end='') print (" g_loss %.4f pos_d_loss %.4f neg_d_loss %.4f " %(g_loss, pos_d_loss, neg_d_loss), end='') print ("pos_perplexity %.4f neg_d_loss %.4f @ %s" %(math.exp(pos_seq_loss), math.exp(neg_seq_loss), datetime.now())) g_loss, pos_d_loss, neg_d_loss, pos_seq_loss, neg_seq_loss = 0.0, 0.0, 0.0, 0.0, 0.0 if current_step % (5*self.checkpoint_step) == 0: checkpoint_path = os.path.join(self.works_dir, "model.ckpt") self.saver.save(self.sess, checkpoint_path) true_pos_id, true_neg_id, fake_pos_id, fake_neg_id = self.get_sentence(self.sess, batch_encoder_inputs) print ('fake_pos:', self.print_sentence(fake_pos_id, rev_vocab, 0)) print ('fake_neg:', self.print_sentence(fake_neg_id, rev_vocab, 0)) print ('true_pos:', self.print_sentence(true_pos_id, rev_vocab, 0)) print ('true_neg:', self.print_sentence(true_neg_id, rev_vocab, 0))