def transform_x(self, x):
#print x
#for toy problem
#trans_x = np.zeros(self.size_x(), dtype=np.int8)
#for vrep problem
trans_x = np.zeros(self.size_x(),
dtype=config.get_problem_config(PROBLEM_NAME)
['input_data_type_np'])
if x == STUMP:
trans_x[-2] = 1
elif x == PAD:
trans_x[-1] = 1
else:
act = x[0]
if PROBLEM_NAME.split('/')[0] in ['vrep', 'toy']:
obs = x[1]
trans_x[0:self.len_obs] = obs
if PROBLEM_NAME.split('/')[0] in ['pocman']:
obs = int(x[1][0])
index_obs = [
i for i, c in enumerate(reversed('{0:b}'.format(obs)))
if c == '1'
]
trans_x[index_obs] = 1
if act == STUMP:
trans_x[-2] = 1
else:
trans_x[self.len_obs + int(act)] = 1
#print trans_x
return trans_x
def handle_learning_server_request(req):
global h_to_a_model
from learning_ros_server.srv import LearningServerResponse
prob_config = config.get_problem_config(rnn_model.PROBLEM_NAME)
my_seq_length = prob_config['max_sequence_length'] + 1
data_generator = rnn_model.DataGenerator(1, req.input, my_seq_length)
x, y = data_generator.next_batch()
ans_index = len(data_generator.seqs[0]) - 1
probs, outputs, new_rnn_state, image_summary = h_to_a_model.predict_and_return_state(
x, None, summary=False
) #probs = batch size*seq length * output length #output = seqlength*batch size* hiddenunits
#summary_writer.add_summary(image_summary)
probs_without_dummy_actions = [i[:-2] for i in probs[0]]
prediction = np.argmax([probs_without_dummy_actions], axis=2)
prediction_outputs = []
ans = LearningServerResponse()
ans.last_activation = []
for i in xrange(len(outputs)):
if (not rnn_model.is_stump(x[0][i])) and (not rnn_model.is_pad(
x[0][i])): #not stump nd pad
prediction_outputs.append(outputs[i][0])
if len(prediction_outputs) > 0:
ans.last_activation = prediction_outputs[-1]
ans.prediction = prediction[0]
ans.ans_index = ans_index
print data_generator.yseqs
return ans
def parse_data(fileName, my_seq_length):
if (fileName is None) or (fileName.endswith('log')) or (','
not in fileName):
if PROBLEM_NAME.split('/')[0] in ['pocman']:
import pocman_data_generator as traces
else:
import deepLearning_data_generator as traces
seqs = traces.parse(fileName)
else:
seqs = [[]]
for act_obs_string in fileName.split('*'):
values = act_obs_string.split(",")
act = values[0]
obs = [float(x) for x in values[1:]]
seqs[0].append((act, obs))
#print seqs
#seqs = traces.parse('canadian_bridge_trace', 'canadian_bridge')
st = [STUMP]
xseqs = [(st + seq)[:-1] if (not seq or seq[0][0] != STUMP) else seq[:-1]
for seq in seqs]
yseqs = [[t[0] for t in seq] for seq in seqs]
yseqs = [seq[1:] if (seq and seq[0] == STUMP) else seq for seq in yseqs]
'''
xseqs = seqs
yseqs = [[t[0] for t in seq][1:]+st for seq in seqs]
'''
maxlen = max(map(len, xseqs)) + 1
if my_seq_length is not None:
maxlen = my_seq_length
# extend to maxlen
xseqs = [seq + [PAD] * (maxlen - len(seq)) for seq in xseqs]
yseqs = [seq + [PAD] * (maxlen - len(seq)) for seq in yseqs]
#encoder = Encoder(*get_problem_info(problem, size, number))
#print xseqs[0]
#print yseqs[0]
#for toy problem
#encoder = Encoder(10, 26)
#for old vrep problem
#encoder = Encoder(19, 8)
#for vrep problem
encoder = Encoder(
config.get_problem_config(PROBLEM_NAME)['output_length'],
config.get_problem_config(PROBLEM_NAME)['input_length'])
return (seqs, xseqs, yseqs, encoder, maxlen)
def load_model(model_name, sess, seq_length=None):
model_dir = os.path.dirname(model_name + '.meta')
model_config_file = './output/' + model_dir + "/params.yaml"
import yaml
with open(model_config_file, 'r') as stream:
model_params = yaml.load(stream)
model = model_params['model']
hidden_units = model_params['hidden_units']
num_layers = model_params['num_layers']
### TODO: Get this information from a separate config
prob_config = config.get_problem_config(rnn_model.PROBLEM_NAME)
if seq_length is None:
seq_length = prob_config['max_sequence_length']
observation_length = prob_config['input_length']
action_length = prob_config['output_length']
encoder = rnn_model.Encoder(action_length, observation_length)
input_length = encoder.size_x()
output_length = encoder.size_y()
start = time.time()
model = Seq2SeqModelExt(session=sess,
hidden_units=hidden_units,
model=model,
num_layers=num_layers,
seq_length=seq_length,
input_length=input_length,
output_length=output_length,
batch_size=1,
scope="model")
end = time.time()
model_create_time = end - start
#model.load('vrep/version1/model.ckpt-967')
model.load(model_name)
start = time.time()
model_load_time = start - end
return model
def __init__(
self,
is_training=False,
hidden_units=128,
model='lstm',
num_layers=1,
seq_length=10,
input_length=10,
output_length=10,
keep_prob=0.6, #dropout keep probability
learning_rate=0.002,
weight_amplitude=0.08,
batch_size=32):
self.inputs = []
self.outputs = []
self.state_placeholder = None
self.batch_size = batch_size
self.output_length = output_length
tf.constant(seq_length, name='seq_length')
# sequence data
for i in xrange(seq_length):
#for toy problem
#self.inputs.append(tf.placeholder(tf.int8, shape=(None, input_length), name="input_{0}".format(i)))
#for vrep problem
self.inputs.append(
tf.placeholder(
config.get_problem_config(PROBLEM_NAME)['input_data_type'],
shape=(None, input_length),
name="input_{0}".format(i)))
self.outputs.append(
tf.placeholder(tf.bool,
shape=(None, output_length),
name="output_{0}".format(i)))
### for c++ calling
# valid action mask for action filtering in sampling
self.valid_actions = tf.placeholder(tf.bool,
shape=(None, self.output_length),
name='valid')
### end for c++ calling
def random_uniform():
return tf.random_uniform_initializer(-weight_amplitude,
weight_amplitude)
def rnn_placeholders(state):
#Convert RNN state tensors to placeholders with the zero state as default.
if isinstance(state, tf.nn.rnn_cell.LSTMStateTuple):
c, h = state
c = tf.placeholder_with_default(c, c.get_shape(), c.op.name)
h = tf.placeholder_with_default(h, h.get_shape(), h.op.name)
return tf.nn.rnn_cell.LSTMStateTuple(c, h)
elif isinstance(state, tf.Tensor):
h = state
h = tf.placeholder_with_default(h, h.get_shape(), h.op.name)
return h
else:
structure = [rnn_placeholders(x) for x in state]
return tuple(structure)
if model == 'rnn':
cell_fn = rnn_cell.BasicRNNCell
elif model == 'gru':
cell_fn = rnn_cell.GRUCell
elif model == 'lstm':
cell_fn = rnn_cell.BasicLSTMCell
if model == 'lstm':
cell = cell_fn(hidden_units, state_is_tuple=True)
self.cells = rnn_cell.MultiRNNCell([cell] * num_layers,
state_is_tuple=True)
else:
cell = cell_fn(hidden_units)
self.cells = rnn_cell.MultiRNNCell([cell] * num_layers)
self.softmax_w = tf.get_variable('softmax_w',
shape=(hidden_units, output_length),
initializer=random_uniform())
self.softmax_b = tf.get_variable('softmax_b',
shape=(output_length, ),
initializer=random_uniform())
#print self.cells.state_size
state = self.cells.zero_state(batch_size=batch_size, dtype=tf.float32)
self.state_placeholder = rnn_placeholders(state)
#print self.state_placeholder
#self.zero_state_var = state
inputs = [tf.cast(inp, tf.float32) for inp in self.inputs]
#_outputs, _ = rnn.rnn(self.cells, inputs, state)
self._outputs, self.rnn_states = rnn.rnn(self.cells, inputs,
self.state_placeholder)
if hidden_units == 128:
image_summaries = []
for i in xrange(seq_length):
image_summaries.append(
tf.summary.image(
'rnn_output_' + repr(i),
tf.reshape(self._outputs[i], [-1, 16, 8, 1])))
self.merged = tf.summary.merge(image_summaries)
self.output_logits = [
tf.matmul(_output, self.softmax_w) + self.softmax_b
for _output in self._outputs
]
self.probs = [
tf.nn.softmax(logit, name='prob_{}'.format(i))
for i, logit in enumerate(self.output_logits)
]
#self.tops = [tf.argmax(prob, 1, name='top_{}'.format(i)) for i, prob in enumerate(self.probs)]
#self.samples = [self.batch_sample_with_temperature(prob, i) for i, prob in enumerate(self.probs)]
#compact variable for cpp
self.tensor_probs = tf.pack(self.probs, 0, 'probs')
#self.tensor_tops = tf.pack(self.tops, 0, 'tops')
#self.tensor_samples = tf.pack(self.samples, 0, 'samples')
if is_training:
self.cells = tf.nn.rnn_cell.DropoutWrapper(
self.cells, output_keep_prob=keep_prob)
self.targets = [tf.cast(oup, tf.float32)
for oup in self.outputs] #[1:]
#tf.Print(self.targets, [self.targets], message="testing tf print")
#print output_logits
self.losses = [
tf.nn.softmax_cross_entropy_with_logits(logit, target)
for logit, target in zip(self.output_logits, self.targets)
]
#self.losses = [tf.nn.sparse_softmax_cross_entropy_with_logits(logit, target) for logit, target in zip(self.output_logits, self.targets)]
self.loss = tf.reduce_sum(tf.add_n(self.losses))
self.cost = self.loss / seq_length / batch_size
self.lr = tf.Variable(learning_rate, trainable=False)
#train_vars = tf.trainable_variables()
#grads = tf.gradients(self.cost, train_vars)
#optimizer = tf.train.AdamOptimizer(self.lr)
#self.train_op = optimizer.apply_gradients(zip(grads, train_vars))
optimizer = tf.train.GradientDescentOptimizer(self.lr)
self.train_op = optimizer.minimize(self.cost)
def debug(model_name, model_input):
hidden_units = 128
model = 'rnn'
num_layers = 2
prob_config = config.get_problem_config(rnn_model.PROBLEM_NAME)
observation_length = prob_config['input_length']
action_length = prob_config['output_length']
encoder = rnn_model.Encoder(action_length, observation_length)
input_length = encoder.size_x()
output_length = encoder.size_y()
batch_size = 3
seq_length = 1
#data_generator = rnn_model.DataGenerator(batch_size, model_input)
#seq_length = data_generator.seq_length
#print len(data_generator.xseqs)
#print data_generator.seq_length
#print 'data number of batches', data_generator.num_batches
x1 = np.ones((batch_size, seq_length, input_length), dtype=np.int8)
x2 = 2 * x1
x = np.concatenate((x1, x2), axis=1)
print x1.shape
print x2.shape
print x.shape
with tf.Session(config=config.get_tf_config()) as sess:
#h_to_a_model = load_model(model_name, sess, seq_length, data_generator.batch_size)
print "Before creating model"
h_to_a_model_1 = Seq2SeqModelExt(session=sess,
hidden_units=hidden_units,
model=model,
num_layers=num_layers,
seq_length=seq_length,
input_length=input_length,
output_length=output_length,
batch_size=batch_size,
scope="model")
print "model_rceated"
h_to_a_model_1.init_variables()
tf.train.Saver(max_to_keep=0).save(sess, "output/" + model_name)
#x, y = data_generator.next_batch()
#target = np.argmax(y, axis=2) #target = batch size*seq length *1
#probs, outputs, image_summary = h_to_a_model.predict_and_return_state(x, summary = False) #output = seqlength*batch size* hiddenunits
#print probs
state_size, rnn_state_1 = h_to_a_model_1.get_rnn_state_info(
x1) #output = seqlength*batch size* hiddenunits
print np.array(rnn_state_1).shape
print rnn_state_1
print "Querying again"
state_size, rnn_state_2 = h_to_a_model_1.get_rnn_state_info(
x2, rnn_state_1)
#print state_size
print np.array(rnn_state_2).shape
print rnn_state_2
#for i in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='model'):
# print i
tf.reset_default_graph()
#for i in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='model'):
# print i
with tf.Session(config=config.get_tf_config()) as sess:
#h_to_a_model = load_model(model_name, sess, seq_length, data_generator.batch_size)
print "Before creating model"
h_to_a_model_2 = Seq2SeqModelExt(session=sess,
hidden_units=hidden_units,
model=model,
num_layers=num_layers,
seq_length=2 * seq_length,
input_length=input_length,
output_length=output_length,
batch_size=batch_size,
scope="model")
h_to_a_model_2.load(model_name)
state_size, rnn_state_3 = h_to_a_model_2.get_rnn_state_info(x)
print rnn_state_3
assert np.array_equal(rnn_state_3, rnn_state_2)