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