def main(_):
if not FLAGS.data_path:
raise ValueError("Must set --data_path to PTB data directory")
raw_data = ptb_reader.ptb_raw_data(FLAGS.data_path)
train_data, valid_data, test_data, _ = raw_data
config = get_config()
eval_config = get_config()
eval_config.batch_size = 1
eval_config.num_steps = 1
with tf.Graph().as_default():
initializer = tf.random_uniform_initializer(-config.init_scale,
config.init_scale)
with tf.name_scope("Train"):
train_input = PTBInput(config=config, data=train_data, name="TrainInput")
with tf.variable_scope("Model", reuse=None, initializer=initializer):
m = PTBModel(is_training=True, config=config, input_=train_input)
tf.summary.scalar("Training Loss", m.cost)
tf.summary.scalar("Learning Rate", m.lr)
with tf.name_scope("Valid"):
valid_input = PTBInput(config=config, data=valid_data, name="ValidInput")
with tf.variable_scope("Model", reuse=True, initializer=initializer):
mvalid = PTBModel(is_training=False, config=config, input_=valid_input)
tf.summary.scalar("Validation Loss", mvalid.cost)
with tf.name_scope("Test"):
test_input = PTBInput(config=eval_config, data=test_data, name="TestInput")
with tf.variable_scope("Model", reuse=True, initializer=initializer):
mtest = PTBModel(is_training=False, config=eval_config,
input_=test_input)
sv = tf.train.Supervisor(logdir=FLAGS.save_path)
with sv.managed_session() as session:
for i in range(config.max_max_epoch):
lr_decay = config.lr_decay ** max(i + 1 - config.max_epoch, 0.0)
m.assign_lr(session, config.learning_rate * lr_decay)
print("Epoch: %d Learning rate: %.3f" % (i + 1, session.run(m.lr)))
train_perplexity = run_epoch(session, m, eval_op=m.train_op,
verbose=True)
print("Epoch: %d Train Perplexity: %.3f" % (i + 1, train_perplexity))
valid_perplexity = run_epoch(session, mvalid)
print("Epoch: %d Valid Perplexity: %.3f" % (i + 1, valid_perplexity))
test_perplexity = run_epoch(session, mtest)
print("Test Perplexity: %.3f" % test_perplexity)
if FLAGS.save_path:
print("Saving model to %s." % FLAGS.save_path)
sv.saver.save(session, FLAGS.save_path, global_step=sv.global_step)
def ptb_prepare(self):
# Data loading code
# =====================================
# num_workers=NUM_CPU_THREADS num_workers=1
# batch_size=self.batch_size
# num_steps = 35
# hidden_size = 1500
# =================================
raw_data = ptb_reader.ptb_raw_data(data_path=self.data_dir)
train_data, valid_data, test_data, word_to_id, id_2_word = raw_data
self.vocab_size = len(word_to_id)
self._input_shape = (self.batch_size, self.num_steps)
self._output_shape = (self.batch_size, self.num_steps)
print('Vocabluary size: {}'.format(self.vocab_size))
print('load data')
epoch_size = (
(len(train_data) // self.batch_size) - 1) // self.num_steps
train_set = ptb_reader.TrainDataset(train_data, self.batch_size,
self.num_steps)
self.trainset = train_set
train_sampler = None
shuffle = True
if self.nworkers > 1:
train_sampler = torch.utils.data.distributed.DistributedSampler(
self.trainset, num_replicas=self.nworkers, rank=self.rank)
train_sampler.set_epoch(0)
shuffle = False
self.train_sampler = train_sampler
self.trainloader = torch.utils.data.DataLoader(
train_set,
batch_size=self.batch_size,
shuffle=shuffle,
num_workers=NUM_CPU_THREADS,
pin_memory=True,
sampler=train_sampler)
test_set = ptb_reader.TestDataset(valid_data, self.batch_size,
self.num_steps)
self.testset = test_set
self.testloader = torch.utils.data.DataLoader(
test_set,
batch_size=self.batch_size,
shuffle=False,
num_workers=1,
pin_memory=True)
print('=========****** finish getting ptb data===========')
def main(args):
if FLAGS.model == 'latent_hiddens':
model = LatentHiddensVRNNModel
elif FLAGS.model == 'latent_fe':
model = LatentFEVRNNModel
elif FLAGS.model == 'latent_fe_prior':
model = LatentFEPriorVRNNModel
elif FLAGS.model == 'latent_lstm':
model = LatentLSTMVRNNModel
print('Training %s model' % FLAGS.model)
raw_data = reader.ptb_raw_data(FLAGS.data_dir)
train_data, valid_data, test_data, _ = raw_data
with tf.Graph().as_default(), tf.Session() as session:
initializer = tf.random_uniform_initializer(-FLAGS.init_scale,
FLAGS.init_scale)
with tf.variable_scope('model', reuse=None, initializer=initializer):
m = model(args=FLAGS)
with tf.variable_scope('model', reuse=True, initializer=initializer):
mvalid = model(args=FLAGS)
mtest = model(args=FLAGS)
tf.initialize_all_variables().run()
saver = tf.train.Saver(tf.all_variables())
for i in range(FLAGS.num_epochs):
lr_decay = FLAGS.decay_rate**max(i - FLAGS.decay_start, 0.0)
m.assign_lr(session, FLAGS.learning_rate * lr_decay)
print('Epoch: %d Learning rate: %.3f' % (i + 1, session.run(m.lr)))
train_perplexity = run_epoch(session,
m,
train_data,
m.train_op,
verbose=True)
print('Epoch: %d Train Perplexity: %.3f' %
(i + 1, train_perplexity))
valid_perplexity = run_epoch(session, mvalid, valid_data,
tf.no_op())
print('Epoch: %d Valid Perplexity: %.3f' %
(i + 1, valid_perplexity))
checkpoint_path = os.path.join(FLAGS.save_dir,
FLAGS.model + '.ckpt')
saver.save(session, checkpoint_path, global_step=i + 1)
print('Model saved to {}'.format(checkpoint_path))
test_perplexity = run_epoch(session, mtest, test_data, tf.no_op())
print('Test perplexity: %.3f' % test_perplexity)
def main(_):
data_path = 'simple-examples/data/'
raw_data = reader.ptb_raw_data(data_path)
train_data, _, _, _ = raw_data
config = SmallConfig()
with tf.Graph().as_default(), tf.Session() as session:
tf.initialize_all_variables().run()
for i in range(config.max_max_epoch):
lr_decay = config.lr_decay**max(i - config.max_epoch, 0.0)
m.assign_lr(session, config.learning_rate * lr_decay)
train_perplexity = run_epoch(session,
m,
train_data,
m.train_op,
verbose=True)
print("Epoch: %d Train Perplexity: %.3f" %
(i + 1, train_perplexity))
def main(_):
train_config = Config()
eval_config = Config()
eval_config.num_steps = 1
eval_config.batch_size = 1
num_epochs = 10
#if not FLAGS.test:
#print(FLAGS.test)
train_data, valid_data, test_data, _ = ptb_reader.ptb_raw_data("../data")
with tf.Graph().as_default() and tf.Session() as session:
with tf.variable_scope("Model", reuse=None):
train_model = LSTM(is_training=True, config=train_config)
with tf.variable_scope("Model", reuse=True):
valid_model = LSTM(is_training=False, config=train_config)
with tf.variable_scope("Model", reuse=True):
test_model = LSTM(is_training=False, config=eval_config)
if not os.path.exists('saved_model_rnn'):
os.makedirs('saved_model_rnn')
else:
shutil.rmtree('saved_model_rnn')
os.makedirs('saved_model_rnn')
session.run(tf.global_variables_initializer())
for i in range(num_epochs):
lr_decay = train_config.lr_decay**max(i + 1 - 4, 0.0)
train_model.assign_lr(session, train_config.lr_decay * lr_decay)
train_cost, train_perp = run_epoch(session, train_model,
train_data)
print("Epoch: %i Training Perplexity: %.3f (Cost: %.3f)" %
(i + 1, train_perp, train_cost))
valid_cost, valid_perp = run_epoch(session, valid_model,
valid_data)
print("Epoch: %i Valid Perplexity: %.3f (Cost: %.3f)" %
(i + 1, valid_perp, valid_cost))
test_cost, test_perp = test_epoch(session, test_model, test_data)
print("Test Perplexity: %.3f (Cost: %.3f)" % (test_perp, test_cost))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--reg',
type=str,
help='none, static or adaptive',
required=True)
parser.add_argument('--size',
type=str,
help='small, medium or large',
required=True)
args = parser.parse_args()
X_train, X_valid, X_test, vocab = ptb_raw_data()
print("\nData loaded")
print("Training set: %d words" % len(X_train))
print("Validation set: %d words" % len(X_valid))
print("Test set: %d words" % len(X_test))
print("Vocab size: %d words\n" % len(vocab))
if args.size == 'small':
c = SmallConfig()
elif args.size == 'medium':
c = MediumConfig()
elif args.size == 'large':
c = LargeConfig()
else:
raise ValueError("Invalid value for size argument")
assert args.reg in ['none', 'static', 'adaptive']
c.reg_type = args.reg
m = PTBModel(c)
sess = tf.Session()
sess.run(tf.global_variables_initializer())
m.fit(X_train, X_valid, sess)
m.run_epoch(X_test, False, True, sess)
import ptb_reader as pr
source = "C:\\ptb\\ptb\\data"
train_data, valid_data, test_data, word_to_id, id_to_word = pr.ptb_raw_data(
source)
for step, (x, y) in enumerate(pr.ptb_iterator(train_data, 40, 20)):
print("y!!!!!!!!!!!!!!!!!!!!!!!")
print(step)
print(x)
print(y)
def my_main(_):
# 读取训练数据、验证数据和测试数据等
if not FLAGS.data_path:
raise ValueError('Must set --data_path to PTM data directory.')
raw_data = reader.ptb_raw_data(data_path=FLAGS.data_path)
train_data, valid_data, test_data, _ = raw_data
config = get_config()
eval_config = get_config()
eval_config.batch_size = 1
eval_config.num_steps = 1
# 主体训练部分
with tf.Graph().as_default():
initializer = tf.random_uniform_initializer(minval=-config.init_scale,
maxval=config.init_scale)
'''
设置训练、验证和测试model，使用不同的数据和配置生成自己的模型进行训练
'''
with tf.name_scope('Train'):
train_input = PTBInput(config=config,
data=train_data,
name='TrainInput')
with tf.variable_scope('Model',
initializer=initializer,
reuse=None):
m = PTBModel(is_training=True,
config=config,
input_=train_input)
tf.summary.scalar('training loss', m.cost)
tf.summary.scalar('learning rate', m.lr)
with tf.name_scope('Valid'):
valid_input = PTBInput(config=config,
data=valid_data,
name='ValidInput')
with tf.variable_scope("Model",
reuse=True,
initializer=initializer):
mvalid = PTBModel(is_training=False,
config=config,
input_=valid_input)
tf.summary.scalar("Validation Loss", mvalid.cost)
with tf.name_scope('Test'):
test_input = PTBInput(config=eval_config,
data=test_data,
name='TestInput')
with tf.variable_scope('Model',
reuse=True,
initializer=initializer):
mtest = PTBModel(is_training=False,
config=eval_config,
input_=test_input)
# 训练结果
supervisor = tf.train.Supervisor(logdir=FLAGS.save_path)
with supervisor.managed_session() as session:
for i in range(config.max_max_epoch):
lr_decay = config.lr_decay**max(i + 1 - config.max_epoch, 0.0)
m.assign_lr(session, config.learning_rate * lr_decay)
print('Epoch {} Learning rate: {:.3f}'.format(
i + 1, session.run(m.lr)))
train_perplexity = run_epoch(session,
m,
eval_op=m.train_op,
verbose=True)
print('Epoch {} Learning perplexity: {:.3f}'.format(
i + 1, train_perplexity))
valid_perplexity = run_epoch(session, mvalid)
print('Epoch {} Valid perplexity: {:.3f}'.format(
i + 1, valid_perplexity))
test_perlexity = run_epoch(session, mtest)
print('Test perplexity: {:.3f}'.format(test_perlexity))
# 模型保存
if FLAGS.save_path:
print('Save model to {}'.format(FLAGS.save_path))
supervisor.saver.save(session,
FLAGS.save_path,
global_step=supervisor.global_step)
def main(argv):
k = int(argv[1])
tf.reset_default_graph()
raw_data = ptb_reader.ptb_raw_data(DATA_DIR)
train_data, valid_data, test_data, _ = raw_data
train_input = PTBInput(train_data,
BATCH_SIZE,
TIME_STEPS,
k,
name="TrainInput")
test_input = PTBInput(test_data,
BATCH_SIZE,
TIME_STEPS,
k,
name='TestInput')
VOCAB_SIZE = 10000
EMBEDDING_SIZE = 100
# setup input and embedding
embedding_matrix = tf.get_variable('embedding_matrix',
dtype=tf.float32,
shape=[VOCAB_SIZE, EMBEDDING_SIZE],
trainable=True)
word_embeddings = tf.nn.embedding_lookup(embedding_matrix,
train_input.input_data)
print("The output of the word embedding: " + str(word_embeddings))
LSTM_SIZE = 200 # number of units in the LSTM layer, this number taken from a "small" language model
lstm_cell = tf.contrib.rnn.BasicLSTMCell(LSTM_SIZE)
# Initial state of the LSTM memory.
initial_state = lstm_cell.zero_state(BATCH_SIZE, tf.float32)
print("Initial state of the LSTM: " + str(initial_state))
# setup RNN
outputs, state = tf.nn.dynamic_rnn(lstm_cell,
word_embeddings,
initial_state=initial_state,
dtype=tf.float32)
logits = tf.layers.dense(outputs, VOCAB_SIZE)
LEARNING_RATE = 1e-2
# loss = tf.contrib.seq2seq.sequence_loss(
# logits,
# train_input.targets,
# tf.ones([BATCH_SIZE, TIME_STEPS], dtype=tf.float32),
# average_across_timesteps=True,
# average_across_batch=True)
optimizer = tf.train.RMSPropOptimizer(
LEARNING_RATE) # better than Adam for RNN networks
train_op = optimizer.minimize(loss(logits, train_input.targets))
with tf.Session() as session:
session.run(tf.global_variables_initializer())
# start queue runners
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=session, coord=coord)
# retrieve some data to look at
# examples = session.run([train_input.input_data, train_input.targets])
# we can run the train op as usual
train_loss = loss(logits, train_input.targets)
test_loss = loss(logits, test_input.targets)
train_losses = []
test_losses = []
for epoch in range(100):
print('Epoch: ' + str(epoch))
_, train_loss_val = session.run([train_op, train_loss])
train_losses.append(train_loss_val)
print('Training loss for epoch ' + str(epoch) + ' is ' +
str(train_loss_val))
test_loss_val = session.run(test_loss)
test_losses.append(test_loss_val)
print('Testing loss for epoch: ' + str(epoch) + ' is ' +
str(test_loss_val))
save('train_data', train_losses)
save('test_data', test_losses)
training_epochs = 13 # total number of epochs for training
lr_decay = 0.5 # the decay of the learning rate for each epoch after max_epoch
max_grad_norm = 5.0 # the maximum permissible norm of the gradient
# network parameters
lstm_size = 200 # number of LSTM units
n_layers = 2 # number of LSTM layers
n_steps = 20 # number of unrolled steps of LSTM
keep_prob = 1.0 # probability of keeping weights in the dropout layer
#############
# Load data #
#############
train, valid, test, vocab = ptb_raw_data('datasets/ptb/')
x_batches, y_batches = ptb_batches(train, batch_size, n_steps)
# vocabulary size
vocab_size = vocab
#########
# Graph #
#########
words = tf.placeholder(tf.int32, [batch_size, n_steps], name='words_in_input')
targets = tf.placeholder(tf.int32, [batch_size, n_steps], name='target_words')
lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(lstm_size, forget_bias=0.0)
lstm_cell = tf.nn.rnn_cell.DropoutWrapper(
""" Created on 24 Jul, 2019 Module to test LSTM @author: Huang Zewen """ import tensorflow as tf import ptb_reader DATA_PATH = "./data/simple-examples/data" lstm_hidden_size = 10 batch_size = 100 num_steps = 50 train_data, valid_data, test_data, vocabulary = ptb_reader.ptb_raw_data(DATA_PATH) print(train_data) print(valid_data) print(test_data) print(vocabulary)
from variants.nfg import NFGLSTMCell
from variants.nog import NOGLSTMCell
from variants.niaf import NIAFLSTMCell
from variants.noaf import NOAFLSTMCell
from variants.np import NPLSTMCell
from variants.cifg import CIFGLSTMCell
from variants.fgr import FGRLSTMCell
# define artifact directories where results from the session can be saved
model_path = os.environ.get('MODEL_PATH', 'models/')
checkpoint_path = os.environ.get('CHECKPOINT_PATH', 'checkpoints/')
summary_path = os.environ.get('SUMMARY_PATH', 'logs/')
# load dataset
train_data, valid_data, test_data, _ = ptb_reader.ptb_raw_data(
"/Users/jiashu/Documents/LAB/LSTM/lstm-odyssey-master/simple-examples/data"
)
def write_csv(arr, path):
df = pd.DataFrame(arr)
df.to_csv(path)
class PTBModel(object):
def __init__(self, CellType, is_training, config):
self.batch_size = batch_size = config.batch_size
self.num_steps = num_steps = config.num_steps
size = config.hidden_size
vocab_size = config.vocab_size
def main(unused_args):
if not FLAGS.data_path:
raise ValueError("Must set --data_path to PTB data directory")
raw_data = ptb_reader.ptb_raw_data(FLAGS.data_path)
global id_to_word, word_to_id
train_data, valid_data, test_data, word_dict, reverse_dict = raw_data
id_to_word = reverse_dict
word_to_id = word_dict
#print(word_dict.keys()[1],reverse_dict.keys()[1])
config = get_config()
eval_config = get_config()
eval_config.batch_size = 1
eval_config.num_steps = 1
#pdb.set_trace()
with tf.Graph().as_default(), tf.Session() as session:
initializer = tf.random_uniform_initializer(-config.init_scale,
config.init_scale)
if FLAGS.interactive:
print("right")
print(FLAGS.interactive)
if FLAGS.interactive:
with tf.variable_scope("model",
reuse=None,
initializer=initializer):
#the input of model
PTBModel(is_training=False, config=eval_config, is_query=True)
print(FLAGS.data_path)
path = FLAGS.data_path
# reloader = tf.train.import_meta_graph("/Users/cassini/Documents/final_ptb/ptb/ptb/data/-ptb.ckpt.meta")
# reloader.restore(session,tf.train.latest_checkpoint("data/"))
#reloader = tf.train.Saver().restore(session,"/Users/cassini/Documents/final_ptb/ptb/ptb/data/")
model_path = os.path.join(FLAGS.data_path, "-ptb.ckpt")
reloader = tf.train.Saver().restore(session, model_path)
print("interactive")
print(FLAGS.interactive)
# module_file = tf.train.latest_checkpoint("-ptb.ckpt")
# print("recent_module")
# print(module_file)
# svaer_1 = tf.train.Saver(tf.global_variables())
# module_file = tf.train.latest_checkpoint()
# tf.train.Saver().restore(session,path)
#with tf.variable_scope("model',reuse=True,initializer = initializer"):
#mvalid = PTBModel(is_training=False,config=confdig)
#valid_perplexity = run_epoch(session,mvalid,valid_data,tf.no_op())
#print("Valid Perplexity of trained model:%.3f"%(valid_perplexity))
#ptb.set_trace()
if FLAGS.interactive == "server":
#ptb_server.start_server(lamda x: run_input(session,x,30))
print("we are now in the server")
ptb_server.ThreadHTTPServer.start_server(
lambda i, x: run_input(session, x, 30))
else:
print("we are now in the shell")
entered_words = input("enter your input:")
while entered_words != "end":
print(run_input(session, entered_words, 30))
entered_words = input("enter your input:")
sys.exit(0)
#print("wrong!!!!!!!")
with tf.variable_scope("model", reuse=None, initializer=initializer):
m = PTBModel(is_training=True, config=config)
with tf.variable_scope("model", reuse=True, initializer=initializer):
mvalid = PTBModel(is_training=False, config=config)
mtest = PTBModel(is_training=False, config=eval_config)
tf.initialize_all_variables().run()
for i in range(config.max_epoch):
lr_decay = config.lr_decay**max(i - config.max_epoch, 0.0)
m.assign_lr(session, config.learning_rate * lr_decay)
print("Epoch: %d Learning rate: %.3f" % (i + 1, session.run(m.lr)))
train_perplexity = run_epoch(session,
m,
train_data,
m.train_op,
verbose=True)
print("Epoch: %d Train Perplexity: %.3f" %
(i + 1, train_perplexity))
valid_perplexity = run_epoch(session, mvalid, valid_data,
tf.no_op())
print("Epoch: %d Valid Perplexity: %.3f" %
(i + 1, valid_perplexity))
print("Saving model")
tf.train.Saver().save(
session, "/Users/cassini/Documents/final_ptb/ptb/ptb")
test_perplexity = run_epoch(session, mtest, test_data, tf.no_op())
print("Test Perplexity: %.3f" % test_perplexity)
print("Training Complete, saving model ... ")
model_path = os.path.join(FLAGS.data_path, "-ptb.ckpt")
tf.train.Saver().save(session, model_path)
"""The input data.
Code sourced from https://github.com/tensorflow/models/blob/master/tutorials/rnn/ptb/ptb_word_lm.py
"""
def __init__(self, data, batch_size, num_steps, name=None):
self.batch_size = batch_size
self.num_steps = num_steps
self.epoch_size = ((len(data) // batch_size) - 1) // num_steps
self.input_data, self.targets = ptb_producer(data,
batch_size,
num_steps,
k=1,
name=name)
raw_data = ptb_reader.ptb_raw_data(DATA_DIR)
train_data, valid_data, test_data, _ = raw_data
train_input = PTBInput(train_data, batch_size, TIME_STEPS, name="TrainInput")
valid_input = PTBInput(valid_data, batch_size, TIME_STEPS, name="ValidInput")
test_input = PTBInput(test_data, batch_size, TIME_STEPS, name="TestInput")
print("The time distributed training data: " + str(train_input.input_data))
print("The similarly distributed targets: " + str(train_input.targets))
VOCAB_SIZE = 10000
EMBEDDING_SIZE = 100
counter = 0
epoch = 0
grace = 10
# setup input and embedding
from variants.nig import NIGLSTMCell
from variants.nfg import NFGLSTMCell
from variants.nog import NOGLSTMCell
from variants.niaf import NIAFLSTMCell
from variants.noaf import NOAFLSTMCell
from variants.np import NPLSTMCell
from variants.cifg import CIFGLSTMCell
from variants.fgr import FGRLSTMCell
# define artifact directories where results from the session can be saved
model_path = os.environ.get('MODEL_PATH', 'models/')
checkpoint_path = os.environ.get('CHECKPOINT_PATH', 'checkpoints/')
summary_path = os.environ.get('SUMMARY_PATH', 'logs/')
# load dataset
train_data, valid_data, test_data, _ = ptb_reader.ptb_raw_data("ptb")
def write_csv(arr, path):
df = pd.DataFrame(arr)
df.to_csv(path)
class PTBModel(object):
def __init__(self, CellType, is_training, config):
self.batch_size = batch_size = config.batch_size
self.num_steps = num_steps = config.num_steps
size = config.hidden_size
vocab_size = config.vocab_size
self.input_data = tf.placeholder(tf.int32, [batch_size, num_steps],
from variants.nig import NIGLSTMCell
from variants.nfg import NFGLSTMCell
from variants.nog import NOGLSTMCell
from variants.niaf import NIAFLSTMCell
from variants.noaf import NOAFLSTMCell
from variants.np import NPLSTMCell
from variants.cifg import CIFGLSTMCell
from variants.fgr import FGRLSTMCell
# define artifact directories where results from the session can be saved
model_path = os.environ.get('MODEL_PATH', 'models/')
checkpoint_path = os.environ.get('CHECKPOINT_PATH', 'checkpoints/')
summary_path = os.environ.get('SUMMARY_PATH', 'logs/')
# load dataset
train_data, valid_data, test_data, _ = ptb_reader.ptb_raw_data("ptb")
def write_csv(arr, path):
df = pd.DataFrame(arr)
df.to_csv(path)
class PTBModel(object):
def __init__(self, CellType, is_training, config):
self.batch_size = batch_size = config.batch_size
self.num_steps = num_steps = config.num_steps
size = config.hidden_size
vocab_size = config.vocab_size
self.input_data = tf.placeholder(tf.int32, [batch_size, num_steps], name="input_data")
self.targets = tf.placeholder(tf.int32, [batch_size, num_steps], name="targets")
from tensorflow.contrib import legacy_seq2seq
# parses the dataset
import ptb_reader
import argparse
parser = argparse.ArgumentParser(description='Program Description')
parser.add_argument('-t', '--test', help='Test Path Argument', required=False)
args = vars(parser.parse_args())
# define artifact directories where results from the session can be saved
model_path = "./model.ckpt"
# load dataset
train_data, valid_data, test_data, _ = ptb_reader.ptb_raw_data("../data")
if args['test']:
train_path = "../data/ptb.train.txt"
test_path = args['test']
word_to_id = ptb_reader._build_vocab(train_path)
test_data = ptb_reader._file_to_word_ids(test_path, word_to_id)
class PTBModel(object):
def __init__(self, is_training, config):
self.batch_size = batch_size = config.batch_size
self.num_steps = num_steps = config.num_steps
size = config.hidden_size
vocab_size = config.vocab_size
self.input_data = tf.placeholder(tf.int32, [batch_size, num_steps], name="input_data")
self.targets = tf.placeholder(tf.int32, [batch_size, num_steps], name="targets")
import tensorflow as tf
import ptb_reader
from models.dilated_rnn import DilatedRNN
import numpy as np
import math
import time
import pandas as pd
from tensorflow.python import debug as tf_debug
train_data, valid_data, test_data, vocab_size = ptb_reader.ptb_raw_data(
"./PTB_dataset/")
tf.reset_default_graph()
# Define some hyperparameters
unrolled_dim = 100
num_of_layers = 5
num_input = 1
number_of_classes = vocab_size # number of different characters
cell_type_list = ["VanillaRNN", "LSTM", "GRU"]
hidden_units = 256 # hidden layer num of features
dilations = [2**j for j in range(num_of_layers)]
batch_size = 128
l_rate = 0.001
number_of_epochs = 4
experiment = "PTB"
decay = 0.9
dropout = 0.1
X_train, y_train = ptb_reader.ptb_producer(train_data, unrolled_dim,
