我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用tensorflow.contrib.rnn.BasicLSTMCell()。
def inference(self): """main computation graph here: 1. embeddding layer, 2.Bi-LSTM layer, 3.concat, 4.FC layer 5.softmax """ #1.get emebedding of words in the sentence self.embedded_words = tf.nn.embedding_lookup(self.Embedding,self.input_x) #shape:[None,sentence_length,embed_size] #2. Bi-lstm layer # define lstm cess:get lstm cell output lstm_fw_cell=rnn.BasicLSTMCell(self.hidden_size) #forward direction cell lstm_bw_cell=rnn.BasicLSTMCell(self.hidden_size) #backward direction cell if self.dropout_keep_prob is not None: lstm_fw_cell=rnn.DropoutWrapper(lstm_fw_cell,output_keep_prob=self.dropout_keep_prob) lstm_bw_cell=rnn.DropoutWrapper(lstm_bw_cell,output_keep_prob=self.dropout_keep_prob) # bidirectional_dynamic_rnn: input: [batch_size, max_time, input_size] # output: A tuple (outputs, output_states) # where:outputs: A tuple (output_fw, output_bw) containing the forward and the backward rnn output `Tensor`. outputs,_=tf.nn.bidirectional_dynamic_rnn(lstm_fw_cell,lstm_bw_cell,self.embedded_words,dtype=tf.float32) #[batch_size,sequence_length,hidden_size] #creates a dynamic bidirectional recurrent neural network print("outputs:===>",outputs) #outputs:(<tf.Tensor 'bidirectional_rnn/fw/fw/transpose:0' shape=(?, 5, 100) dtype=float32>, <tf.Tensor 'ReverseV2:0' shape=(?, 5, 100) dtype=float32>)) #3. concat output output_rnn=tf.concat(outputs,axis=2) #[batch_size,sequence_length,hidden_size*2] self.output_rnn_last=tf.reduce_mean(output_rnn,axis=1) #[batch_size,hidden_size*2] #output_rnn_last=output_rnn[:,-1,:] ##[batch_size,hidden_size*2] #TODO print("output_rnn_last:", self.output_rnn_last) # <tf.Tensor 'strided_slice:0' shape=(?, 200) dtype=float32> #4. logits(use linear layer) with tf.name_scope("output"): #inputs: A `Tensor` of shape `[batch_size, dim]`. The forward activations of the input network. logits = tf.matmul(self.output_rnn_last, self.W_projection) + self.b_projection # [batch_size,num_classes] return logits
def rnn_model(self): cell = rnn.BasicLSTMCell(num_units=self.n_units) multi_cell = rnn.MultiRNNCell([cell]*self.n_layers) # we only need one output so get it wrapped to out one value which is next word index cell_wrapped = rnn.OutputProjectionWrapper(multi_cell, output_size=1) # get input embed embedding = tf.Variable(initial_value=tf.random_uniform([self.vocab_size, self.n_units], -1.0, 1.0)) inputs = tf.nn.embedding_lookup(embedding, self.inputs) # what is inputs dim?? outputs, states = tf.nn.dynamic_rnn(cell_wrapped, inputs=inputs, dtype=tf.float32) outputs = tf.reshape(outputs, [int(outputs.get_shape()[0]), int(inputs.get_shape()[1])]) w = tf.Variable(tf.truncated_normal([int(inputs.get_shape()[1]), self.vocab_size])) b = tf.Variable(tf.zeros([self.vocab_size])) logits = tf.nn.bias_add(tf.matmul(outputs, w), b) return logits
def test_build_nn(build_nn): with tf.Graph().as_default(): test_input_data_shape = [128, 5] test_input_data = tf.placeholder(tf.int32, test_input_data_shape) test_rnn_size = 256 test_rnn_layer_size = 2 test_vocab_size = 27 test_cell = rnn.MultiRNNCell([rnn.BasicLSTMCell(test_rnn_size)] * test_rnn_layer_size) logits, final_state = build_nn(test_cell, test_rnn_size, test_input_data, test_vocab_size) # Check name assert hasattr(final_state, 'name'), \ 'Final state doesn\'t have the "name" attribute. Are you using build_rnn?' assert final_state.name == 'final_state:0', \ 'Final state doesn\'t have the correct name. Found the name {}. Are you using build_rnn?'.format(final_state.name) # Check Shape assert logits.get_shape().as_list() == test_input_data_shape + [test_vocab_size], \ 'Outputs has wrong shape. Found shape {}'.format(logits.get_shape()) assert final_state.get_shape().as_list() == [test_rnn_layer_size, 2, None, test_rnn_size], \ 'Final state wrong shape. Found shape {}'.format(final_state.get_shape()) _print_success_message()
def create_network(self,state_dim,action_dim,scope): with tf.variable_scope(scope,reuse=False) as s: state_input = tf.placeholder("float",[None,None,state_dim]) # creating the recurrent part lstm_cell=rnn.BasicLSTMCell(LSTM_HIDDEN_UNIT) lstm_output,lstm_state=tf.nn.dynamic_rnn(cell=lstm_cell,inputs=state_input,dtype=tf.float32) W3 = tf.Variable(tf.random_uniform([lstm_cell.state_size,action_dim],-3e-3,3e-3)) b3 = tf.Variable(tf.random_uniform([action_dim],-3e-3,3e-3)) action_output = tf.tanh(tf.matmul(lstm_state,W3) + b3) net = [v for v in tf.trainable_variables() if scope in v.name] return state_input,action_output,net
def build_lstm(x, size, name, step_size): lstm = rnn.BasicLSTMCell(size, state_is_tuple=True) c_init = np.zeros((1, lstm.state_size.c), np.float32) h_init = np.zeros((1, lstm.state_size.h), np.float32) state_init = [c_init, h_init] c_in = tf.placeholder(tf.float32, shape=[1, lstm.state_size.c], name='c_in') h_in = tf.placeholder(tf.float32, shape=[1, lstm.state_size.h], name='h_in') state_in = [c_in, h_in] state_in = rnn.LSTMStateTuple(c_in, h_in) lstm_outputs, lstm_state = tf.nn.dynamic_rnn( lstm, x, initial_state=state_in, sequence_length=step_size, time_major=False) lstm_outputs = tf.reshape(lstm_outputs, [-1, size]) lstm_c, lstm_h = lstm_state state_out = [lstm_c[:1, :], lstm_h[:1, :]] return lstm_outputs, state_init, state_in, state_out
def build_lstm_inner(H, lstm_input): ''' build lstm decoder ''' lstm_cell = rnn_cell.BasicLSTMCell(H['lstm_size'], forget_bias=0.0, state_is_tuple=False) if H['num_lstm_layers'] > 1: lstm = rnn_cell.MultiRNNCell([lstm_cell] * H['num_lstm_layers'], state_is_tuple=False) else: lstm = lstm_cell batch_size = H['batch_size'] * H['grid_height'] * H['grid_width'] state = tf.zeros([batch_size, lstm.state_size]) outputs = [] with tf.variable_scope('RNN', initializer=tf.random_uniform_initializer(-0.1, 0.1)): for time_step in range(H['rnn_len']): if time_step > 0: tf.get_variable_scope().reuse_variables() output, state = lstm(lstm_input, state) outputs.append(output) return outputs
def test_build_rnn(build_rnn): with tf.Graph().as_default(): test_rnn_size = 256 test_rnn_layer_size = 2 test_cell = rnn.MultiRNNCell([rnn.BasicLSTMCell(test_rnn_size)] * test_rnn_layer_size) test_inputs = tf.placeholder(tf.float32, [None, None, test_rnn_size]) outputs, final_state = build_rnn(test_cell, test_inputs) # Check name assert hasattr(final_state, 'name'),\ 'Final state doesn\'t have the "name" attribute. Try using `tf.identity` to set the name.' assert final_state.name == 'final_state:0',\ 'Final state doesn\'t have the correct name. Found the name {}'.format(final_state.name) # Check shape assert outputs.get_shape().as_list() == [None, None, test_rnn_size],\ 'Outputs has wrong shape. Found shape {}'.format(outputs.get_shape()) assert final_state.get_shape().as_list() == [test_rnn_layer_size, 2, None, test_rnn_size],\ 'Final state wrong shape. Found shape {}'.format(final_state.get_shape()) _print_success_message()
def RNN(x, weights, biases): # reshape to [1, n_input] x = tf.reshape(x, [-1, n_input]) # Generate a n_input-element sequence of inputs # (eg. [had] [a] [general] -> [20] [6] [33]) x = tf.split(x,n_input,1) # 2-layer LSTM, each layer has n_hidden units. # Average Accuracy= 95.20% at 50k iter rnn_cell = rnn.MultiRNNCell([rnn.BasicLSTMCell(n_hidden),rnn.BasicLSTMCell(n_hidden)]) # 1-layer LSTM with n_hidden units but with lower accuracy. # Average Accuracy= 90.60% 50k iter # Uncomment line below to test but comment out the 2-layer rnn.MultiRNNCell above # rnn_cell = rnn.BasicLSTMCell(n_hidden) # generate prediction outputs, states = rnn.static_rnn(rnn_cell, x, dtype=tf.float32) # there are n_input outputs but # we only want the last output return tf.matmul(outputs[-1], weights['out']) + biases['out']
def model(X, W, B, lstm_size): # X, input shape: (batch_size, time_step_size, input_vec_size) XT = tf.transpose(X, [1, 0, 2]) # permute time_step_size and batch_size # XT shape: (time_step_size, batch_size, input_vec_size) XR = tf.reshape(XT, [-1, lstm_size]) # each row has input for each lstm cell (lstm_size=input_vec_size) # XR shape: (time_step_size * batch_size, input_vec_size) X_split = tf.split(XR, time_step_size, 0) # split them to time_step_size (28 arrays) # Each array shape: (batch_size, input_vec_size) # Make lstm with lstm_size (each input vector size) lstm = rnn.BasicLSTMCell(lstm_size, forget_bias=1.0, state_is_tuple=True) # Get lstm cell output, time_step_size (28) arrays with lstm_size output: (batch_size, lstm_size) outputs, _states = rnn.static_rnn(lstm, X_split, dtype=tf.float32) # Linear activation # Get the last output return tf.matmul(outputs[-1], W) + B, lstm.state_size # State size to initialize the stat ############################## model definition end ######################################
def BiRNN(x, weights, biases): # Prepare data shape to match `bidirectional_rnn` function requirements # Current data input shape: (batch_size, n_steps, n_input) # Required shape: 'n_steps' tensors list of shape (batch_size, n_input) # Unstack to get a list of 'n_steps' tensors of shape (batch_size, n_input) x = tf.unstack(x, n_steps, 1) # Define lstm cells with tensorflow # Forward direction cell lstm_fw_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0) # Backward direction cell lstm_bw_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0) # Get lstm cell output try: outputs, _, _ = rnn.static_bidirectional_rnn(lstm_fw_cell, lstm_bw_cell, x, dtype=tf.float32) except Exception: # Old TensorFlow version only returns outputs not states outputs = rnn.static_bidirectional_rnn(lstm_fw_cell, lstm_bw_cell, x, dtype=tf.float32) # Linear activation, using rnn inner loop last output return tf.matmul(outputs[-1], weights['out']) + biases['out']
def RNN(x, weights, biases): # Prepare data shape to match `rnn` function requirements # Current data input shape: (batch_size, n_steps, n_input) # Required shape: 'n_steps' tensors list of shape (batch_size, n_input) # Unstack to get a list of 'n_steps' tensors of shape (batch_size, n_input) x = tf.unstack(x, n_steps, 1) # Define a lstm cell with tensorflow lstm_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0) # Get lstm cell output outputs, states = rnn.static_rnn(lstm_cell, x, dtype=tf.float32) # Linear activation, using rnn inner loop last output return tf.matmul(outputs[-1], weights['out']) + biases['out']
def lstm(X): batch_size = tf.shape(X)[0] w_in = tf.Variable(tf.random_normal([NUM_FEATURES, FLAGS.rnn_hidden_nodes], seed=SEED)) b_in = tf.Variable(tf.constant(0.1, shape=[FLAGS.rnn_hidden_nodes])) input = tf.reshape(X, [-1, NUM_FEATURES]) input_rnn = tf.matmul(input, w_in) + b_in input_rnn = tf.reshape(input_rnn, [-1, FLAGS.rnn_num_steps, FLAGS.rnn_hidden_nodes]) cell = rnn.BasicLSTMCell(FLAGS.rnn_hidden_nodes, state_is_tuple=True) init_state = cell.zero_state(batch_size, dtype=tf.float32) output_rnn, final_states = tf.nn.dynamic_rnn(cell, input_rnn, initial_state=init_state, dtype=tf.float32) output = output_rnn[:, -1, :] w_out = tf.Variable(tf.random_normal([FLAGS.rnn_hidden_nodes, 1], seed=SEED)) b_out = tf.Variable(tf.constant(0.1, shape=[1])) pred = tf.matmul(output, w_out) + b_out return pred
def _shared_layer(self, input_data, config, is_training): """Build the model up until decoding. Args: input_data = size batch_size X num_steps X embedding size Returns: output units """ with tf.variable_scope('encoder'): lstm_cell = rnn.BasicLSTMCell(config.encoder_size, reuse=tf.get_variable_scope().reuse, forget_bias=1.0) if is_training and config.keep_prob < 1: lstm_cell = rnn.DropoutWrapper( lstm_cell, output_keep_prob=config.keep_prob) encoder_outputs, encoder_states = tf.nn.dynamic_rnn(lstm_cell, input_data, dtype=tf.float32, scope="encoder_rnn") return encoder_outputs
def buildRNN(self,x,scope): print(x) x = tf.transpose(x, [1, 0, 2]) #print(x) x = tf.reshape(x, [-1,self.nfeatures]) #print(x) x = tf.split(x, self.n_steps, 0) print(x) #lstm_cell = rnn.MultiRNNCell([rnn.BasicLSTMCell(self.n_hidden, forget_bias=1.0) for _ in range(self.n_layers)], state_is_tuple=True) #outputs, states = tf.nn.dynamic_rnn(lstm_cell, x, dtype=tf.float64) with tf.name_scope("fw"+scope),tf.variable_scope("fw"+scope): fw_cell_array = [] print(tf.get_variable_scope().name) for _ in range(self.n_layers): fw_cell = rnn.BasicLSTMCell(self.n_hidden, forget_bias=1.0, state_is_tuple=True) #fw_cell = rnn.DropoutWrapper(fw_cell,output_keep_prob=self.dropout) fw_cell_array.append(fw_cell) fw_cell = rnn.MultiRNNCell(fw_cell_array, state_is_tuple=True) with tf.name_scope("bw"+scope),tf.variable_scope("bw"+scope): bw_cell_array = [] print(tf.get_variable_scope().name) for _ in range(self.n_layers): bw_cell = rnn.BasicLSTMCell(self.n_hidden, forget_bias=1.0, state_is_tuple=True) #bw_cell = rnn.DropoutWrapper(bw_cell,output_keep_prob=self.dropout) bw_cell_array.append(bw_cell) bw_cell = rnn.MultiRNNCell(bw_cell_array, state_is_tuple=True) outputs, _,_ = tf.contrib.rnn.static_bidirectional_rnn(fw_cell, bw_cell, x, dtype=tf.float64) #outputs, = tf.nn.bidirectional_dynamic_rnn(fw_cell, bw_cell, x, dtype=tf.float64) print(outputs) print(outputs[-1]) return outputs[-1]
def RNN(x, weights, biases): # Prepare data shape to match `rnn` function requirements # Current data input shape: (batch_size, n_steps, n_input) # Required shape: 'n_steps' tensors list of shape (batch_size, n_input) # Permuting batch_size and n_steps x = tf.transpose(x, [1, 0, 2]) # Reshaping to (n_steps*batch_size, n_input) x = tf.reshape(x, [-1, n_input]) # Split to get a list of 'n_steps' tensors of shape (batch_size, n_input) x = tf.split(x, n_steps, 0) # Define a lstm cell with tensorflow lstm_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0) # Get lstm cell output outputs, states = rnn.static_rnn(lstm_cell, x, dtype=tf.float32) # Linear activation, using rnn inner loop last output return tf.matmul(outputs[-1], weights['out']) + biases['out']
def questionLSTM(self, q, q_real_len, reuse = False, scope= "questionLSTM"): """ Args q: zero padded qeustions, shape=[batch_size, q_max_len] q_real_len: original question length, shape = [batch_size, 1] Returns embedded_q: embedded questions, shape = [batch_size, q_hidden(32)] """ embedded_q_word = tf.nn.embedding_lookup(self.q_word_embed_matrix, q) q_input = tf.unstack(embedded_q_word, num = self.q_max_len, axis=1) lstm_cell = rnn.BasicLSTMCell(self.q_hidden, reuse = reuse) outputs, _ = rnn.static_rnn(lstm_cell, q_input, dtype = tf.float32, scope = scope) outputs = tf.stack(outputs) outputs = tf.transpose(outputs, [1,0,2]) index = tf.range(0, self.batch_size) * (self.q_max_len) + (q_real_len - 1) outputs = tf.gather(tf.reshape(outputs, [-1, self.s_hidden]), index) return outputs
def __init__(self,config): self.c_bp_lstm=context_bottom_up_lstm(config) self.inputs=self.c_bp_lstm.sentences_root_states self.inputs=tf.expand_dims(self.inputs, 0) #[1 , sentence_num, hidden_dim] self.sentence_num=tf.gather(tf.shape(self.inputs),1) self.sentence_num_batch=tf.expand_dims(self.sentence_num, 0) #[1] with tf.variable_scope('context_lstm_forward'): self.fwcell=rnn.BasicLSTMCell(config.hidden_dim, activation=tf.nn.tanh) with tf.variable_scope('context_lstm_backward'): self.bwcell=rnn.BasicLSTMCell(config.hidden_dim, activation=tf.nn.tanh) with tf.variable_scope('context_bidirectional_chain_lstm'): self._fw_initial_state=self.fwcell.zero_state(1,dtype=tf.float32) self._bw_initial_state=self.bwcell.zero_state(1,dtype=tf.float32) chain_outputs, chain_state=tf.nn.bidirectional_dynamic_rnn(self.fwcell, self.bwcell, self.inputs, self.sentence_num_batch, initial_state_fw=self._fw_initial_state, initial_state_bw=self._bw_initial_state) chain_outputs=tf.concat(chain_outputs, 2) #[1, sentence_num, 2*hidden_dim] chain_outputs=tf.gather(chain_outputs, 0) #[sentence_num, 2*hidden_dim] self.c_td_lstm=context_top_down_lstm(config, self.c_bp_lstm, chain_outputs) self.sentences_final_states=self.get_tree_states(self.c_bp_lstm.sentences_hidden_states, self.c_td_lstm.sentences_hidden_states)
def __init__(self, config): self.q_encoding=question_encoding(config) self.c_encoding=context_encoding(config) self.config=config self.sentence_num=self.c_encoding.sentence_num ##to do list self.att_layer=attentioned_layer(config, self.q_encoding, self.c_encoding) self.scope_index=0 #every constituency has a representation [ 4* hidden_dim] with tf.variable_scope('candidate_answer_generation_forward'): self.fwcell=rnn.BasicLSTMCell(self.config.hidden_dim, activation=tf.nn.tanh) with tf.variable_scope('candidate_answer_generation_backword'): self.bwcell=rnn.BasicLSTMCell(self.config.hidden_dim, activation=tf.nn.tanh) self._fw_initial_state=self.fwcell.zero_state(1,dtype=tf.float32) self._bw_initial_state=self.bwcell.zero_state(1,dtype=tf.float32) self.add_placeholders() self.candidate_answer_representations=self.get_candidate_answer_representations() assert tf.gather(tf.shape(self.candidate_answer_representations),0)==self.candidate_answer_overall_number self.loss=self.get_loss(self.candidate_answer_representations,self.correct_answer_idx) self.train_op=self.add_training_op()
def get_candidate_answer_final_representations(self, candidate_answer_hidden_list): inputs=tf.expand_dims(candidate_answer_hidden_list,axis=0) sequence_length=tf.gather(tf.shape(inputs),1) sequence_length=tf.expand_dims(sequence_length, 0) #with tf.variable_scope('candidate_answer_generation_forward',reuse=True): # fwcell=rnn.BasicLSTMCell(self.config.hidden_dim, activation=tf.nn.tanh) #with tf.variable_scope('candidate_answer_generation_backward',reuse=True): # bwcell=rnn.BasicLSTMCell(self.config.hidden_dim, activation=tf.nn.tanh) chain_outputs, chain_state=tf.nn.bidirectional_dynamic_rnn(self.fwcell, self.bwcell, inputs, sequence_length, initial_state_fw=self._fw_initial_state, initial_state_bw=self._bw_initial_state,scope='candidate_answer_{}'.format(self.scope_index)) self.scope_index+=1 chain_outputs=tf.concat(chain_outputs, 2) chain_outputs=tf.gather(chain_outputs, 0) output=tf.gather(chain_outputs, tf.subtract(tf.gather(tf.shape(chain_outputs),0),1)) return output #[2*hidden_dim]
def convertLayerWithRNN(self): ''' use BI-LSTM to get contenxt ''' lstm_fw_cell = rnn.BasicLSTMCell(self.context_size) lstm_bw_cell = rnn.BasicLSTMCell(self.context_size) if self.dropout_keep_prob is not None: lstm_fw_cell = rnn.DropoutWrapper(lstm_fw_cell, output_keep_prob = self.dropout_keep_prob) lstm_bw_cell = rnn.DropoutWrapper(lstm_bw_cell, output_keep_prob = self.dropout_keep_prob) outputs,output_states = tf.nn.bidirectional_dynamic_rnn(lstm_fw_cell, lstm_bw_cell,self.embedded_words,dtype = tf.float32) output_fw,output_bw = outputs result_presentation = tf.concat([output_fw,self.embedded_words,output_bw],axis = 2) return result_presentation
def __init__(self,x,size,step_size): lstm = rnn.BasicLSTMCell(size, state_is_tuple=True) c_init = np.zeros((1, lstm.state_size.c), np.float32) h_init = np.zeros((1, lstm.state_size.h), np.float32) self.state_init = [c_init, h_init] c_in = tf.placeholder(tf.float32, shape=[1, lstm.state_size.c], name='c_in') h_in = tf.placeholder(tf.float32, shape=[1, lstm.state_size.h], name='h_in') self.state_in = [c_in, h_in] state_in = rnn.LSTMStateTuple(c_in, h_in) lstm_outputs, lstm_state = tf.nn.dynamic_rnn( lstm, x, initial_state=state_in, sequence_length=step_size, time_major=False) lstm_outputs = tf.reshape(lstm_outputs, [-1, size]) lstm_c, lstm_h = lstm_state self.state_out = [lstm_c[:1, :], lstm_h[:1, :]] self.output = lstm_outputs
def __init__(self, ob_space, ac_space, lstm_size=256, use_categorical_max=False, **kwargs): self.x = x = tf.placeholder(tf.float32, [None] + list(ob_space)) rank = len(ob_space) if rank == 3: # pixel input for i in range(4): x = tf.nn.elu(conv2d(x, 32, "l{}".format(i + 1), [3, 3], [2, 2])) elif rank == 1: # plain features #x = tf.nn.elu(linear(x, 256, "l1", normalized_columns_initializer(0.01))) pass else: raise TypeError("observation space must have rank 1 or 3, got %d" % rank) # introduce a "fake" batch dimension of 1 after flatten so that we can do LSTM over time dim x = tf.expand_dims(flatten(x), [0]) size = lstm_size lstm = rnn.BasicLSTMCell(size, state_is_tuple=True) self.state_size = lstm.state_size step_size = tf.shape(self.x)[:1] c_init = np.zeros((1, lstm.state_size.c), np.float32) h_init = np.zeros((1, lstm.state_size.h), np.float32) self.state_init = [c_init, h_init] c_in = tf.placeholder(tf.float32, [1, lstm.state_size.c]) h_in = tf.placeholder(tf.float32, [1, lstm.state_size.h]) self.state_in = [c_in, h_in] state_in = rnn.LSTMStateTuple(c_in, h_in) lstm_outputs, lstm_state = tf.nn.dynamic_rnn( lstm, x, initial_state=state_in, sequence_length=step_size, time_major=False) lstm_c, lstm_h = lstm_state x = tf.reshape(lstm_outputs, [-1, size]) self.logits = linear(x, ac_space, "action", normalized_columns_initializer(0.01)) self.vf = tf.reshape(linear(x, 1, "value", normalized_columns_initializer(1.0)), [-1]) self.state_out = [lstm_c[:1, :], lstm_h[:1, :]] self.sample = categorical_max(self.logits, ac_space)[0, :] \ if use_categorical_max else categorical_sample(self.logits, ac_space)[0, :] self.var_list = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, tf.get_variable_scope().name)
def inference(self): """main computation graph here: 1. embeddding layer, 2.Bi-LSTM layer, 3.mean pooling, 4.FC layer, 5.softmax """ #1.get emebedding of words in the sentence self.embedded_words = tf.nn.embedding_lookup(self.Embedding,self.input_x) #shape:[None,sentence_length,embed_size] #2. Bi-lstm layer # define lstm cess:get lstm cell output lstm_fw_cell=rnn.BasicLSTMCell(self.hidden_size) #forward direction cell lstm_bw_cell=rnn.BasicLSTMCell(self.hidden_size) #backward direction cell if self.dropout_keep_prob is not None: lstm_fw_cell=rnn.DropoutWrapper(lstm_fw_cell,output_keep_prob=self.dropout_keep_prob) lstm_bw_cell==rnn.DropoutWrapper(lstm_bw_cell,output_keep_prob=self.dropout_keep_prob) # bidirectional_dynamic_rnn: input: [batch_size, max_time, input_size] # output: A tuple (outputs, output_states) # where:outputs: A tuple (output_fw, output_bw) containing the forward and the backward rnn output `Tensor`. outputs,_=tf.nn.bidirectional_dynamic_rnn(lstm_fw_cell,lstm_bw_cell,self.embedded_words,dtype=tf.float32) #[batch_size,sequence_length,hidden_size] #creates a dynamic bidirectional recurrent neural network print("outputs:===>",outputs) #outputs:(<tf.Tensor 'bidirectional_rnn/fw/fw/transpose:0' shape=(?, 5, 100) dtype=float32>, <tf.Tensor 'ReverseV2:0' shape=(?, 5, 100) dtype=float32>)) #3. concat output output_rnn=tf.concat(outputs,axis=2) #[batch_size,sequence_length,hidden_size*2] output_rnn_pooled=tf.reduce_mean(output_rnn,axis=1) #[batch_size,hidden_size*2] #output_rnn_last=output_rnn[:,-1,:] ##[batch_size,hidden_size*2] #TODO print("output_rnn_pooled:", output_rnn_pooled) # <tf.Tensor 'strided_slice:0' shape=(?, 200) dtype=float32> #4. logits(use linear layer) with tf.name_scope("output"): #inputs: A `Tensor` of shape `[batch_size, dim]`. The forward activations of the input network. logits = tf.matmul(output_rnn_pooled, self.W_projection) + self.b_projection # [batch_size,num_classes] return logits
def input_encoder_bi_lstm(self): """use bi-directional lstm to encode query_embedding:[batch_size,sequence_length,embed_size] and story_embedding:[batch_size,story_length,sequence_length,embed_size] output:query_embedding:[batch_size,hidden_size*2] story_embedding:[batch_size,self.story_length,self.hidden_size*2] """ #1. encode query: bi-lstm layer lstm_fw_cell = rnn.BasicLSTMCell(self.hidden_size) # forward direction cell lstm_bw_cell = rnn.BasicLSTMCell(self.hidden_size) # backward direction cell if self.dropout_keep_prob is not None: lstm_fw_cell = rnn.DropoutWrapper(lstm_fw_cell, output_keep_prob=self.dropout_keep_prob) lstm_bw_cell == rnn.DropoutWrapper(lstm_bw_cell, output_keep_prob=self.dropout_keep_prob) query_hidden_output, _ = tf.nn.bidirectional_dynamic_rnn(lstm_fw_cell, lstm_bw_cell, self.query_embedding,dtype=tf.float32,scope="query_rnn") # [batch_size,sequence_length,hidden_size] #creates a dynamic bidirectional recurrent neural network query_hidden_output = tf.concat(query_hidden_output, axis=2) #[batch_size,sequence_length,hidden_size*2] self.query_embedding=tf.reduce_sum(query_hidden_output,axis=1) #[batch_size,hidden_size*2] print("input_encoder_bi_lstm.self.query_embedding:",self.query_embedding) #2. encode story # self.story_embedding:[batch_size,story_length,sequence_length,embed_size] self.story_embedding=tf.reshape(self.story_embedding,shape=(-1,self.story_length*self.sequence_length,self.embed_size)) #[self.story_length*self.sequence_length,self.embed_size] lstm_fw_cell_story = rnn.BasicLSTMCell(self.hidden_size) # forward direction cell lstm_bw_cell_story = rnn.BasicLSTMCell(self.hidden_size) # backward direction cell if self.dropout_keep_prob is not None: lstm_fw_cell_story = rnn.DropoutWrapper(lstm_fw_cell_story, output_keep_prob=self.dropout_keep_prob) lstm_bw_cell_story == rnn.DropoutWrapper(lstm_bw_cell_story, output_keep_prob=self.dropout_keep_prob) story_hidden_output, _ = tf.nn.bidirectional_dynamic_rnn(lstm_fw_cell_story, lstm_bw_cell_story, self.story_embedding,dtype=tf.float32,scope="story_rnn") story_hidden_output=tf.concat(story_hidden_output,axis=2) #[batch_size,story_length*sequence_length,hidden_size*2] story_hidden_output=tf.reshape(story_hidden_output,shape=(-1,self.story_length,self.sequence_length,self.hidden_size*2)) self.story_embedding = tf.reduce_sum(story_hidden_output, axis=2) # [batch_size,self.story_length,self.hidden_size*2]
def __init__(self,n_classes,rnn_size = 256,n_chunks=75): global gru_cell_units self._name = "star_platinum" self._hidden_layer_1 = {'weights': tf.Variable(tf.random_uniform([rnn_size,1024]),name = "weight1"), 'biases': tf.Variable(tf.random_uniform([1024]),name = "biases1")} self._hidden_layer_2 = {'weights': tf.Variable(tf.random_uniform([1024,n_chunks * 10]),name = "weight2"), 'biases': tf.Variable(tf.random_uniform([n_chunks * 10]),name = "biases2")} self._lstm_cell = rnn.BasicLSTMCell(rnn_size) self._gru_cell = rnn.GRUCell(gru_cell_units) self._output = {'weights': tf.Variable(tf.random_uniform([gru_cell_units,n_classes]),name = "weight3"), 'biases': tf.Variable(tf.random_uniform([n_classes]),name = "biases3")}
def __init__(self,n_classes,rnn_size = 256): self._name = "little_pony" self._layer_weights = tf.Variable(tf.random_uniform([rnn_size,n_classes]), name="weights") self._layer_biases = tf.Variable(tf.random_uniform([n_classes]), name="biases") self._lstm_cell = rnn.BasicLSTMCell(rnn_size)
def __init__(self,n_classes,rnn_size = 256): self._name = "big_boy" self._layer_weights_1 = tf.Variable(tf.random_uniform([rnn_size,64]), name="weights") self._layer_biases_1 = tf.Variable(tf.random_uniform([64]), name="biases") self._layer_weights_2 = tf.Variable(tf.random_uniform([64,n_classes]), name="weights") self._layer_biases_2 = tf.Variable(tf.random_uniform([n_classes]), name="biases") self._lstm_cell = rnn.BasicLSTMCell(rnn_size)
def _get_rnn_unit(self, rnn_unit): if rnn_unit == 'lstm': fw_cell = rnn.BasicLSTMCell(self._nb_hidden, forget_bias=1., state_is_tuple=True) bw_cell = rnn.BasicLSTMCell(self._nb_hidden, forget_bias=1., state_is_tuple=True) elif rnn_unit == 'gru': fw_cell = rnn.GRUCell(self._nb_hidden) bw_cell = rnn.GRUCell(self._nb_hidden) else: raise ValueError('rnn_unit must in (lstm, gru)!') return fw_cell, bw_cell
def create_q_network(self,state_dim,action_dim,scope): # the layer size could be changed with tf.variable_scope(scope,reuse=False) as s: state_input = tf.placeholder("float",[None,None,state_dim]) action_input = tf.placeholder("float",[None,None,action_dim]) # creating the recurrent part lstm_cell=rnn.BasicLSTMCell(LSTM_HIDDEN_UNIT) lstm_output,lstm_state=tf.nn.dynamic_rnn(cell=lstm_cell,inputs=tf.concat([state_input,action_input],2),dtype=tf.float32) W3 = tf.Variable(tf.random_uniform([lstm_cell.output_size,1],-3e-3,3e-3)) b3 = tf.Variable(tf.random_uniform([1],-3e-3,3e-3)) q_value_output = tf.identity(tf.matmul(layer2,W3) + b3) net = [v for v in tf.trainable_variables() if scope in v.name] return state_input,action_input,q_value_output,net
def lstm_cell(): cell = rnn.BasicLSTMCell(hidden_dim, state_is_tuple= True) return cell #stacked LSTM
def lstm_cell(): cell = rnn.BasicLSTMCell(hidden_dim, state_is_tuple=True, activation=tf.tanh) return cell #stacked LSTM
def __init__(self, cell, zoneout_prob, is_training=True): if not isinstance(cell, RNNCell): raise TypeError("The parameter cell is not an RNNCell.") if isinstance(cell, BasicLSTMCell): self._tuple = lambda x: LSTMStateTuple(*x) else: self._tuple = lambda x: tuple(x) if (isinstance(zoneout_prob, float) and not (zoneout_prob >= 0.0 and zoneout_prob <= 1.0)): raise ValueError("Parameter zoneout_prob must be between 0 and 1: %d" % zoneout_prob) self._cell = cell self._zoneout_prob = zoneout_prob self.is_training = is_training
def RNN(x, weights, biases): x = tf.unstack(x, n_steps, 1) # Define a lstm cell lstem_cell = rnn.BasicLSTMCell(n_hidden,forget_bias = 1.0) outputs, states = rnn.static_rnn(lstem_cell,x,dtype=tf.float32) return tf.matmul(outputs[-1],weights['out'])+biases['out']
def build_sentence_encoder(vocabulary_size, embeddings_matrix): """ build the computational graph for the lstm sentence encoder. Return only the palceholders and tensors that are called from other methods """ sentence_oh_placeholder = tf.placeholder(shape=[None, vocabulary_size], dtype=tf.float32, name="sentence_placeholder") word_embeddings_matrix = tf.get_variable("W_we", # shape=[vocabulary_size, WORD_EMB_SIZE] initializer=tf.constant(embeddings_matrix, dtype=tf.float32)) sentence_embedded = tf.expand_dims(tf.matmul(sentence_oh_placeholder, word_embeddings_matrix), 0) # placeholders for sentence and it's length sent_lengths = tf.placeholder(dtype=tf.int32, name="sent_length_placeholder") # Forward cell lstm_fw_cell = BasicLSTMCell(LSTM_HIDDEN_SIZE, forget_bias=1.0) # Backward cell lstm_bw_cell = BasicLSTMCell(LSTM_HIDDEN_SIZE, forget_bias=1.0) # stack cells together in RNN outputs, _ = tf.nn.bidirectional_dynamic_rnn(lstm_fw_cell, lstm_bw_cell, sentence_embedded, sent_lengths, dtype=tf.float32) # outputs: A tuple (output_fw, output_bw) containing the forward and the backward rnn output `Tensor`. # both output_fw, output_bw will be a `Tensor` shaped: [batch_size, max_time, cell_fw.output_size]` # outputs is a (output_forward,output_backwards) tuple. concat them together to receive h vector lstm_outputs = tf.concat(outputs, 2)[0] # shape: [max_time, 2 * hidden_layer_size ] final_fw = outputs[0][:, -1, :] final_bw = outputs[1][:, 0, :] e_m = tf.concat((final_fw, final_bw), axis=1) sentence_words_bow = tf.placeholder(tf.float32, [None, len(words_vocabulary)], name="sentence_words_bow") e_m_with_bow = tf.concat([e_m, sentence_words_bow], axis=1) return sentence_oh_placeholder, sent_lengths, sentence_words_bow, lstm_outputs, e_m_with_bow
def build_sentence_encoder(vocabulary_size): """ build the computational graph for the lstm sentence encoder. Return only the palceholders and tensors that are called from other methods """ sentence_oh_placeholder = tf.placeholder(shape=[None, vocabulary_size], dtype=tf.float32, name="sentence_placeholder") word_embeddings_matrix = tf.get_variable("W_we", # shape=[vocabulary_size, WORD_EMB_SIZE] initializer=tf.constant(embeddings_matrix, dtype=tf.float32)) sentence_embedded = tf.expand_dims(tf.matmul(sentence_oh_placeholder, word_embeddings_matrix), 0) # placeholders for sentence and it's length sent_lengths = tf.placeholder(dtype=tf.int32, name="sent_length_placeholder") # Forward cell lstm_fw_cell = BasicLSTMCell(LSTM_HIDDEN_SIZE, forget_bias=1.0) # Backward cell lstm_bw_cell = BasicLSTMCell(LSTM_HIDDEN_SIZE, forget_bias=1.0) # stack cells together in RNN outputs, _ = tf.nn.bidirectional_dynamic_rnn(lstm_fw_cell, lstm_bw_cell, sentence_embedded, sent_lengths, dtype=tf.float32) # outputs: A tuple (output_fw, output_bw) containing the forward and the backward rnn output `Tensor`. # both output_fw, output_bw will be a `Tensor` shaped: [batch_size, max_time, cell_fw.output_size]` # outputs is a (output_forward,output_backwards) tuple. concat them together to receive h vector lstm_outputs = tf.concat(outputs, 2)[0] # shape: [max_time, 2 * hidden_layer_size ] final_fw = outputs[0][:, -1, :] final_bw = outputs[1][:, 0, :] e_m = tf.concat((final_fw, final_bw), axis=1) sentence_words_bow = tf.placeholder(tf.float32, [None, len(words_vocabulary)], name="sentence_words_bow") e_m_with_bow = tf.concat([e_m, sentence_words_bow], axis=1) return sentence_oh_placeholder, sent_lengths, sentence_words_bow, lstm_outputs, e_m_with_bow # TODO return sentence_oh_placeholder, sent_lengths, sentence_words_bow, lstm_outputs, e_m
def build_sentence_encoder2(vocabulary_size, embeddings_matrix): """ build the computational graph for the lstm sentence encoder. Return only the palceholders and tensors that are called from other methods """ sentence_oh_placeholder2 = tf.placeholder(shape=[None, vocabulary_size], dtype=tf.float32, name="sentence_placeholder") word_embeddings_matrix2 = tf.get_variable("W_we", # shape=[vocabulary_size, WORD_EMB_SIZE] initializer=tf.constant(embeddings_matrix, dtype=tf.float32)) sentence_embedded2 = tf.expand_dims(tf.matmul(sentence_oh_placeholder2, word_embeddings_matrix2), 0) # placeholders for sentence and it's length sent_lengths2 = tf.placeholder(dtype=tf.int32, name="sent_length_placeholder") # Forward cell lstm_fw_cell2 = BasicLSTMCell(LSTM_HIDDEN_SIZE, forget_bias=1.0) # Backward cell lstm_bw_cell2 = BasicLSTMCell(LSTM_HIDDEN_SIZE, forget_bias=1.0) # stack cells together in RNN outputs2, _ = tf.nn.bidirectional_dynamic_rnn(lstm_fw_cell2, lstm_bw_cell2, sentence_embedded2, sent_lengths2, dtype=tf.float32) # outputs: A tuple (output_fw, output_bw) containing the forward and the backward rnn output `Tensor`. # both output_fw, output_bw will be a `Tensor` shaped: [batch_size, max_time, cell_fw.output_size]` # outputs is a (output_forward,output_backwards) tuple. concat them together to receive h vector lstm_outputs2 = tf.concat(outputs2, 2)[0] # shape: [max_time, 2 * hidden_layer_size ] final_fw2 = outputs2[0][:, -1, :] final_bw2 = outputs2[1][:, 0, :] e_m2 = tf.concat((final_fw2, final_bw2), axis=1) sentence_words_bow2 = tf.placeholder(tf.float32, [None, len(words_vocabulary)], name="sentence_words_bow") e_m_with_bow2 = tf.concat([e_m2, sentence_words_bow2], axis=1) return sentence_oh_placeholder2, sent_lengths2, sentence_words_bow2, lstm_outputs2, e_m_with_bow2
def RNN(x, weights, biases): x = tf.transpose(x, [1, 0, 2]) x = tf.reshape(x, [-1, n_input]) x = tf.split(axis=0, num_or_size_splits=n_steps, value=x) lstm_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0) outputs, states = rnn.static_rnn(lstm_cell, x, dtype=tf.float32) return tf.matmul(outputs[-1], weights['out']) + biases['out']
def BiRNN(x, weights, biases): x = tf.transpose(x, [1, 0, 2]) x = tf.reshape(x, [-1, n_input]) x = tf.split(axis=0, num_or_size_splits=n_steps, value=x) lstm_fw_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0) lstm_bw_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0) try: outputs, _, _ = rnn.static_bidirectional_rnn(lstm_fw_cell, lstm_bw_cell, x, dtype=tf.float32) except Exception: # Old TensorFlow version only returns outputs not states outputs = rnn.static_bidirectional_rnn(lstm_fw_cell, lstm_bw_cell, x, dtype=tf.float32) return tf.matmul(outputs[-1], weights['out']) + biases['out']
def lstm_model(time_steps, rnn_layers, dense_layers=None, learning_rate=0.01, optimizer='Adagrad',learning_rate_decay_fn = None): # [Ftrl, Adam, Adagrad, Momentum, SGD, RMSProp] print(time_steps) #exit(0) """ Creates a deep model based on: * stacked lstm cells * an optional dense layers :param num_units: the size of the cells. :param rnn_layers: list of int or dict * list of int: the steps used to instantiate the `BasicLSTMCell` cell * list of dict: [{steps: int, keep_prob: int}, ...] :param dense_layers: list of nodes for each layer :return: the model definition """ def lstm_cells(layers): print('-------------------------sdsdsdsdssd---------------------------------------------',layers) if isinstance(layers[0], dict): return [rnn.DropoutWrapper(rnn.BasicLSTMCell(layer['num_units'],state_is_tuple=True),layer['keep_prob']) if layer.get('keep_prob') else rnn.BasicLSTMCell(layer['num_units'], state_is_tuple=True) for layer in layers] return [rnn.BasicLSTMCell(steps, state_is_tuple=True) for steps in layers] def dnn_layers(input_layers, layers): if layers and isinstance(layers, dict): return tflayers.stack(input_layers, tflayers.fully_connected, layers['layers'], activation=layers.get('activation'), dropout=layers.get('dropout')) elif layers: return tflayers.stack(input_layers, tflayers.fully_connected, layers) else: return input_layers def _lstm_model(X, y): stacked_lstm = rnn.MultiRNNCell(lstm_cells(rnn_layers), state_is_tuple=True) x_ = tf.unstack(X, num=time_steps, axis=1) output, layers = rnn.static_rnn(stacked_lstm, x_, dtype=dtypes.float32) output = dnn_layers(output[-1], dense_layers) prediction, loss = tflearn.models.linear_regression(output, y) train_op = tf.contrib.layers.optimize_loss( loss, tf.contrib.framework.get_global_step(), optimizer=optimizer, learning_rate = tf.train.exponential_decay(learning_rate, tf.contrib.framework.get_global_step(), decay_steps = 1000, decay_rate = 0.9, staircase=False, name=None)) print('learning_rate',learning_rate) return prediction, loss, train_op # https://www.tensorflow.org/versions/r0.10/api_docs/python/train/decaying_the_learning_rate return _lstm_model
def _build_lstm(self, input_state): initial_lstm_state = tf.placeholder( tf.float32, [None, 2*self.hidden_state_size], name='initital_state') lstm_cell = BasicLSTMCell(self.hidden_state_size, forget_bias=1.0, state_is_tuple=True) batch_size = tf.shape(self.step_size)[0] ox_reshaped = tf.reshape(input_state, batch_size, -1, input_state.get_shape().as_list()[-1]]) lstm_outputs, lstm_state = tf.nn.dynamic_rnn( lstm_cell, ox_reshaped, initial_state=initial_lstm_state, sequence_length=self.step_size, time_major=False)
def __init__(self, inputs, initial_state, hidden_state_size ,max_steps, num_cores=10, pool_size=10): self.shared_cell = BasicLSTMCell(hidden_state_size) self.initial_state = initial_state self.max_steps = max_steps self.num_cores = num_cores self.pool_size = pool_size self.inputs = inputs self._build_ops()
def __init__(self, ob_space, ac_space): self.x = x = tf.placeholder(tf.float32, [None] + list(ob_space)) for i in range(4): x = tf.nn.elu(conv2d(x, 32, "l{}".format(i + 1), [3, 3], [2, 2])) # introduce a "fake" batch dimension of 1 after flatten so that we can do LSTM over time dim x = tf.expand_dims(flatten(x), [0]) size = 256 if use_tf100_api: lstm = rnn.BasicLSTMCell(size, state_is_tuple=True) else: lstm = rnn.rnn_cell.BasicLSTMCell(size, state_is_tuple=True) self.state_size = lstm.state_size step_size = tf.shape(self.x)[:1] c_init = np.zeros((1, lstm.state_size.c), np.float32) h_init = np.zeros((1, lstm.state_size.h), np.float32) self.state_init = [c_init, h_init] c_in = tf.placeholder(tf.float32, [1, lstm.state_size.c]) h_in = tf.placeholder(tf.float32, [1, lstm.state_size.h]) self.state_in = [c_in, h_in] if use_tf100_api: state_in = rnn.LSTMStateTuple(c_in, h_in) else: state_in = rnn.rnn_cell.LSTMStateTuple(c_in, h_in) lstm_outputs, lstm_state = tf.nn.dynamic_rnn( lstm, x, initial_state=state_in, sequence_length=step_size, time_major=False) lstm_c, lstm_h = lstm_state x = tf.reshape(lstm_outputs, [-1, size]) self.logits = linear(x, ac_space, "action", normalized_columns_initializer(0.01)) self.vf = tf.reshape(linear(x, 1, "value", normalized_columns_initializer(1.0)), [-1]) self.state_out = [lstm_c[:1, :], lstm_h[:1, :]] self.sample = categorical_sample(self.logits, ac_space)[0, :] self.var_list = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, tf.get_variable_scope().name)
def __init__(self, sent_length, class_num, embedding_size, initial_embedding_dict, l2_lambda, hidden_size): self.input_x = tf.placeholder(tf.int32, [None, sent_length], name="input_x") self.input_y = tf.placeholder(tf.float32, [None, class_num], name="input_y") self.dropout_keep_prob_1 = tf.placeholder(tf.float32, name="dropout_keep_prob_1") self.dropout_keep_prob_2 = tf.placeholder(tf.float32, name="dropout_keep_prob_2") l2_loss = tf.constant(0.0) with tf.name_scope("embedding"): self.embedding_dict = tf.Variable(initial_embedding_dict, name="Embedding", dtype=tf.float32) self.embedded_chars = tf.nn.embedding_lookup(self.embedding_dict, self.input_x) # unstack embedded input self.unstacked = tf.unstack(self.embedded_chars, sent_length, 1) with tf.name_scope("lstm"): # create a LSTM network lstm_cell = rnn.BasicLSTMCell(hidden_size) self.output, self.states = rnn.static_rnn(lstm_cell, self.unstacked, dtype=tf.float32) self.pooling = tf.reduce_mean(self.output, 0) with tf.name_scope("linear"): weights = tf.get_variable( "W", shape=[hidden_size, class_num], initializer=tf.contrib.layers.xavier_initializer()) bias = tf.Variable(tf.constant(0.1, shape=[class_num]), name="b") l2_loss += tf.nn.l2_loss(weights) l2_loss += tf.nn.l2_loss(bias) self.linear_result = tf.nn.xw_plus_b(self.pooling, weights, bias, name="linear") self.predictions = tf.arg_max(self.linear_result, 1, name="predictions") with tf.name_scope("loss"): losses = tf.nn.softmax_cross_entropy_with_logits(logits=self.linear_result, labels=self.input_y) self.loss = tf.reduce_mean(losses) + l2_lambda * l2_loss with tf.name_scope("accuracy"): correct_predictions = tf.equal(self.predictions, tf.argmax(self.input_y, 1)) self.accuracy = tf.reduce_mean(tf.cast(correct_predictions, "float"), name="accuracy")
def _init(self, inputs, num_outputs, options): use_tf100_api = (distutils.version.LooseVersion(tf.VERSION) >= distutils.version.LooseVersion("1.0.0")) self.x = x = inputs for i in range(4): x = tf.nn.elu(conv2d(x, 32, "l{}".format(i + 1), [3, 3], [2, 2])) # Introduce a "fake" batch dimension of 1 after flatten so that we can # do LSTM over the time dim. x = tf.expand_dims(flatten(x), [0]) size = 256 if use_tf100_api: lstm = rnn.BasicLSTMCell(size, state_is_tuple=True) else: lstm = rnn.rnn_cell.BasicLSTMCell(size, state_is_tuple=True) step_size = tf.shape(self.x)[:1] c_init = np.zeros((1, lstm.state_size.c), np.float32) h_init = np.zeros((1, lstm.state_size.h), np.float32) self.state_init = [c_init, h_init] c_in = tf.placeholder(tf.float32, [1, lstm.state_size.c]) h_in = tf.placeholder(tf.float32, [1, lstm.state_size.h]) self.state_in = [c_in, h_in] if use_tf100_api: state_in = rnn.LSTMStateTuple(c_in, h_in) else: state_in = rnn.rnn_cell.LSTMStateTuple(c_in, h_in) lstm_out, lstm_state = tf.nn.dynamic_rnn(lstm, x, initial_state=state_in, sequence_length=step_size, time_major=False) lstm_c, lstm_h = lstm_state x = tf.reshape(lstm_out, [-1, size]) logits = linear(x, num_outputs, "action", normc_initializer(0.01)) self.state_out = [lstm_c[:1, :], lstm_h[:1, :]] return logits, x
def RNN(x,weights,biases): #x = tf.transpose(x,[1,0,2]) #x = tf.unstack(x,n_steps,1) # x = tf.reshape(x, [-1, n_input]) x = tf.unstack(x, n_steps, 1) lstm_cell = rnn.BasicLSTMCell(n_hidden,forget_bias=1.0) outputs,states = rnn.static_rnn(lstm_cell,x,dtype=tf.float32) return tf.matmul(outputs[-1],weights['out']) + biases['out']
def BiRNN(x,weights,biases): x = tf.unstack(x,n_steps,1) lstm_fw_cell = rnn.BasicLSTMCell(n_hidden,forget_bias=1.0) lstm_bw_cell = rnn.BasicLSTMCell(n_hidden,forget_bias=1.0) outputs,_,_ = rnn.static_bidirectional_rnn(lstm_fw_cell,lstm_bw_cell,x,dtype=tf.float32) return tf.matmul(outputs[-1],weights['out']) + biases['out']
