def predict(): def _get_test_dataset(): with open(TEST_DATASET_PATH) as test_fh: test_sentences = [s.strip() for s in test_fh.readlines()] return test_sentences results_filename = '_'.join(['results', str(FLAGS.num_layers), str(FLAGS.size), str(FLAGS.vocab_size)]) results_path = os.path.join(FLAGS.results_dir, results_filename) with tf.Session() as sess, open(results_path, 'w') as results_fh: # Create model and load parameters. model = create_model(sess, forward_only=True) model.batch_size = 1 # We decode one sentence at a time. # Load vocabularies. vocab_path = os.path.join(FLAGS.data_dir, "vocab%d.in" % FLAGS.vocab_size) vocab, rev_vocab = data_utils.initialize_vocabulary(vocab_path) test_dataset = _get_test_dataset() for sentence in test_dataset: # Get token-ids for the input sentence. predicted_sentence = get_predicted_sentence(sentence, vocab, rev_vocab, model, sess) print(sentence, ' -> ', predicted_sentence) results_fh.write(predicted_sentence + '\n')
def predict(): def _get_test_dataset(): with open(TEST_DATASET_PATH) as test_fh: test_sentences = [s.strip() for s in test_fh.readlines()] return test_sentences results_filename = '_'.join([ 'results', str(FLAGS.num_layers), str(FLAGS.size), str(FLAGS.vocab_size) ]) results_path = os.path.join(FLAGS.results_dir, results_filename) with tf.Session() as sess, open(results_path, 'w') as results_fh: # Create model and load parameters. model = create_model(sess, forward_only=True) model.batch_size = 1 # We decode one sentence at a time. # Load vocabularies. vocab_path = os.path.join(FLAGS.data_dir, "vocab%d.in" % FLAGS.vocab_size) vocab, rev_vocab = data_utils.initialize_vocabulary(vocab_path) test_dataset = _get_test_dataset() for sentence in test_dataset: # Get token-ids for the input sentence. predicted_sentence = get_predicted_sentence( sentence, vocab, rev_vocab, model, sess) print(sentence) print('->') print(predicted_sentence) results_fh.write(predicted_sentence + '\n')
def tsne(): with tf.Session() as sess: # Create model and load parameters. from sklearn import manifold vocab_path = os.path.join(FLAGS.data_dir, "vocab%d.in" % FLAGS.vocab_size) vocab, rev_vocab = data_utils.initialize_vocabulary(vocab_path) # labels = [] # rows = [] # for emote in words: # if emote in vocab: # labels.append(emote) # rows.append(vocab[emote]) rows = [i for i in xrange(500)] labels = [rev_vocab[i] for i in xrange(500)] # labels = emotes tsne = manifold.TSNE(perplexity=30, n_components=2, init='pca', n_iter=5000) model = create_model(sess, forward_only=True) model.batch_size = 1 # We decode one sentence at a time. embeddings = tf.get_variable( "embedding_attention_seq2seq/embedding_attention_decoder/embedding" ) reduced_embeddings = tf.gather(embeddings, rows) num_embeddings = reduced_embeddings.eval() print num_embeddings.shape low_dim_embs = tsne.fit_transform(num_embeddings) plot_with_labels(low_dim_embs, labels)
def tsne(): with tf.Session() as sess: # Create model and load parameters. from sklearn import manifold vocab_path = os.path.join(FLAGS.data_dir, "vocab%d.in" % FLAGS.vocab_size) vocab, rev_vocab = data_utils.initialize_vocabulary(vocab_path) # labels = [] # rows = [] # for emote in words: # if emote in vocab: # labels.append(emote) # rows.append(vocab[emote]) rows = [i for i in xrange(500)] labels = [rev_vocab[i] for i in xrange(500)] # labels = emotes tsne = manifold.TSNE(perplexity=30, n_components=2, init='pca', n_iter=5000) model = create_model(sess, forward_only=True) model.batch_size = 1 # We decode one sentence at a time. embeddings = tf.get_variable("embedding_attention_seq2seq/embedding_attention_decoder/embedding") reduced_embeddings = tf.gather(embeddings,rows) num_embeddings = reduced_embeddings.eval() print num_embeddings.shape low_dim_embs = tsne.fit_transform(num_embeddings) plot_with_labels(low_dim_embs, labels)
def predict(): def _get_test_dataset(): with open(TEST_DATASET_PATH) as test_fh: test_sentences = [s.strip() for s in test_fh.readlines()] return test_sentences results_filename = '_'.join([ 'results', str(FLAGS.num_layers), str(FLAGS.size), str(FLAGS.vocab_size) ]) results_path = os.path.join(FLAGS.results_dir, results_filename) with tf.Session() as sess, open(results_path, 'w') as results_fh: # Create model and load parameters. model = create_model(sess, forward_only=True) model.batch_size = 1 # We decode one sentence at a time. # Load vocabularies. vocab_path = os.path.join(FLAGS.data_dir, "vocab%d.in" % FLAGS.vocab_size) vocab, rev_vocab = data_utils.initialize_vocabulary(vocab_path) test_dataset = _get_test_dataset() i = 0 allright = 0 for sentence in test_dataset: # Get token-ids for the input sentence. if i % 2 == 0: predicted_sentence = get_predicted_sentence( sentence, vocab, rev_vocab, model, sess) item = sentence.strip().split(',') predicted_sentence = item[ 0] + ',' + predicted_sentence + ',' + item[1] print(sentence, ' -> ', predicted_sentence) # results_fh.write(sentence + ' -> ' + predicted_sentence + '\n') if i % 2 == 1: item = predicted_sentence.strip().split(',') sentence = item[0] + ',' + sentence + ',' + item[-1] if sentence == predicted_sentence: allright += 1 print('^ is allright' + '\n') results_fh.write(sentence + '\n' + predicted_sentence + '\n') # results_fh.write('^ is allright'+'\n') else: # print('Error~right is %s' %sentence) # results_fh.write('Error~right is %s' %sentence+'\n') results_fh.write(sentence + '\n' + predicted_sentence + '\n') i = i + 1 print 'traj=', i / 2, ',allright=', allright, ',accuracy=', allright * 1.0 / ( i * 1.0 / 2) results_fh.write('traj=%d,allright=%d,accuracy=%f' % (i / 2, allright, allright * 1.0 / (i * 1.0 / 2)))
def chat(): with tf.Session() as sess: # Create model and load parameters. model = create_model(sess, forward_only=True) model.batch_size = 1 # We decode one sentence at a time. # Load vocabularies. vocab_path = os.path.join(FLAGS.data_dir, "vocab%d.in" % FLAGS.vocab_size) vocab, rev_vocab = data_utils.initialize_vocabulary(vocab_path) # Decode from standard input. # sys.stdout.write("> ") sys.stdout.flush() # sentence = sys.stdin.readline() past = collections.deque(maxlen=3) # past.extendleft([sentence]) s = socket.socket() s.connect((cfg.HOST, cfg.PORT)) s.send("PASS {}\r\n".format(cfg.PASS).encode("utf-8")) s.send("NICK {}\r\n".format(cfg.NICK).encode("utf-8")) s.send("JOIN {}\r\n".format(cfg.CHAN).encode("utf-8")) s.setblocking(1) last_sentence = "" while True: try: response = s.recv(1024).decode("utf-8") if response == "PING :tmi.twitch.tv\r\n": s.send("PONG :tmi.twitch.tv\r\n".encode("utf-8",'ignore')) else: text = re.findall('PRIVMSG.+?(?=\:)\:(.+?(?=\r))',response) for msg in text: past.extendleft([msg.encode('utf-8')]) # print past except: pass new=[] for t in past: new.append(t.decode("utf-8",'ignore')) # new.append( t.encode('ascii','ignore') ) sentence= u' '.join(new) # print sentence predicted_sentence = _get_predicted_sentence(sentence.encode('utf-8','replace'), vocab, rev_vocab, model, sess) i = 0 while ("_UNK" in predicted_sentence or predicted_sentence == "") and i<10: i+=1 predicted_sentence = _get_predicted_sentence(sentence.encode('utf-8','replace'), vocab, rev_vocab, model, sess) # predicted_sentence ='Kappa' print(predicted_sentence) send_chat(s,predicted_sentence) sys.stdout.flush() past.extendleft([predicted_sentence]) # print sentence sleep(2)
def chat(): with tf.Session() as sess: # Create model and load parameters. model = create_model(sess, forward_only=True) model.batch_size = 1 # We decode one sentence at a time. # Load vocabularies. vocab_path = os.path.join(FLAGS.data_dir, "vocab%d.in" % FLAGS.vocab_size) vocab, rev_vocab = data_utils.initialize_vocabulary(vocab_path) # Decode from standard input. sys.stdout.write("> ") sys.stdout.flush() sentence = sys.stdin.readline() while sentence: predicted_sentence = get_predicted_sentence(sentence, vocab, rev_vocab, model, sess) print(predicted_sentence) print("> ") sys.stdout.flush() sentence = sys.stdin.readline()
def chat(): with tf.Session() as sess: # Create model and load parameters. model = create_model(sess, forward_only=True) model.batch_size = 1 # We decode one sentence at a time. # Load vocabularies. vocab_path = os.path.join(FLAGS.data_dir, "vocab%d.in" % FLAGS.vocab_size) vocab, rev_vocab = data_utils.initialize_vocabulary(vocab_path) # Decode from standard input. sys.stdout.write("> ") sys.stdout.flush() sentence = sys.stdin.readline() while sentence: predicted_sentence = _get_predicted_sentence(sentence, vocab, rev_vocab, model, sess) print(predicted_sentence) print("> ") sys.stdout.flush() sentence = sys.stdin.readline()
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) # 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, loss = 0.0, 0.0 current_step = 0 previous_losses = [] 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) _, step_loss, _ = model.step(sess, encoder_inputs, decoder_inputs, target_weights, bucket_id, forward_only=False, step=current_step) step_time += (time.time() - start_time) / FLAGS.steps_per_checkpoint loss += step_loss / FLAGS.steps_per_checkpoint current_step += 1 # Once in a while, we save checkpoint, print statistics, and run evals. if current_step % FLAGS.steps_per_checkpoint == 0: # 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" % (model.global_step.eval(), model.learning_rate.eval(), step_time, perplexity)) # 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(FLAGS.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(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, step=current_step) 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: # Create model. print("Creating %d layers of %d units." % (FLAGS.num_layers, FLAGS.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, loss = 0.0, 0.0 current_step = 0 previous_losses = [] 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) _, 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 # Once in a while, we save checkpoint, print statistics, and run evals. if current_step % FLAGS.steps_per_checkpoint == 0: # 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" % (model.global_step.eval(), model.learning_rate.eval(), step_time, perplexity)) # 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(FLAGS.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(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()
try: s.bind((HOST, PORT)) except socket.error: #print ('Bind failed. Error Code : ' + str(msg[0]) + ' Message ' + msg[1]) sys.exit() print('Socket bind complete') s.listen(10) print('Socket now listening') #now keep talking with the client with tf.Session() as sess: # Create model and load parameters. model = create_model(sess, forward_only=True) model.batch_size = 1 # We decode one sentence at a time. # Load vocabularies. vocab_path = os.path.join(FLAGS.data_dir, "vocab%d.in" % FLAGS.vocab_size) vocab, rev_vocab = data_utils.initialize_vocabulary(vocab_path) #wait to accept a connection - blocking call conn, addr = s.accept() print('Connected with ' + addr[0] + ':' + str(addr[1])) while 1: data, address = conn.recvfrom(1024) # reply = 'OK...' + data if not data: continue sentence = data.decode("utf-8", "ignore")