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)