def __init__(self, hidden_size, num_layers, grid_size, dim): # super(neighborhood_stat_enc, self).__init__() self.hidden_size = hidden_size self.input = tf.placeholder(name='input', shape=(dim, 8), dtype=tf.float64) self.hidden_state = tf.placeholder(name='hidden_state', shape=(dim, self.hidden_size), dtype=tf.float64) # ctxt_img = tf.convert_to_tensor(imread(ctxt_path[0]), dtype=tf.float64) # ctxt_img = tf.convert_to_tensor(tf.pad(ctxt_img, paddings=tf.constant([[1, 1, ], [0, 1], [0, 0]])), # dtype=tf.float64) # # ctxt_img = tf.expand_dims(ctxt_img, axis=0) # self._2dconv = tf.nn.conv2d(input=ctxt_img, filter=tf.random_normal(shape=[561, 711, 3, 1],dtype=tf.float64), # padding='VALID', strides=[1, 1, 1, 1]) # self._2dconv = tf.squeeze(self._2dconv) # in gridLSTM frequency blocks are the units of lstm stacking vertically # while time LSTM spans horizontally self.rnn = rnn.GridLSTMCell(num_units=num_layers, feature_size=grid_size, frequency_skip=grid_size, use_peepholes=False, num_frequency_blocks=[int(grid_size / 2)], share_time_frequency_weights=True, state_is_tuple=False, couple_input_forget_gates=True, reuse=True) self.output, self.c_hidden_states = self.rnn(self.input, self.hidden_state)
def testGridLSTMCellWithFrequencyBlocks(self): with self.test_session() as sess: num_units = 8 batch_size = 3 input_size = 4 feature_size = 2 frequency_skip = 1 num_frequency_blocks = [1, 1] total_blocks = num_frequency_blocks[0] + num_frequency_blocks[1] start_freqindex_list = [0, 2] end_freqindex_list = [2, 4] with variable_scope.variable_scope( "root", initializer=init_ops.constant_initializer(0.5)): cell = rnn_cell.GridLSTMCell( num_units=num_units, feature_size=feature_size, frequency_skip=frequency_skip, forget_bias=1.0, num_frequency_blocks=num_frequency_blocks, start_freqindex_list=start_freqindex_list, end_freqindex_list=end_freqindex_list, couple_input_forget_gates=True, state_is_tuple=True) inputs = constant_op.constant( np.array( [[1., 1., 1., 1.], [2., 2., 2., 2.], [3., 3., 3., 3.]], dtype=np.float32), dtype=dtypes.float32) state_value = constant_op.constant( 0.1 * np.ones( (batch_size, num_units), dtype=np.float32), dtype=dtypes.float32) init_state = cell.state_tuple_type( *([state_value, state_value] * total_blocks)) output, state = cell(inputs, init_state) sess.run([variables.global_variables_initializer()]) res = sess.run([output, state]) self.assertEqual(len(res), 2) # The numbers in results were not calculated, this is mostly just a # smoke test. self.assertEqual(res[0].shape, (batch_size, num_units * total_blocks * 2)) for ss in res[1]: self.assertEqual(ss.shape, (batch_size, num_units)) # Different inputs so different outputs and states for i in range(1, batch_size): self.assertTrue( float(np.linalg.norm((res[0][0, :] - res[0][i, :]))) > 1e-6) self.assertTrue( float( np.linalg.norm((res[1].state_f00_b00_c[0, :] - res[1] .state_f00_b00_c[i, :]))) > 1e-6)
def __init__(self, hidden_size,hidden_len, num_layers, grid_size, embedding_size,dropout=0): # super(neighborhood_vis_loc_encoder, self).__init__() # tf.Variable() reg_w = tf.contrib.layers.l2_regularizer(scale=0.1) self.hidden_size = hidden_size self.embedding_size = embedding_size self.input = tf.placeholder(dtype=tf.float64, shape=[hidden_len,hidden_len], name="inputs") self.state_f00_b00_c = tf.placeholder(name='state_f00_b00_c', shape=(hidden_len, self.hidden_size), dtype=tf.float64) self.c_hidden_state = tf.placeholder(name='c_hidden_state', shape=(hidden_len, self.hidden_size), dtype=tf.float64) self.state_f00_b00_m = tf.placeholder(name='state_f00_b00_m', shape=(hidden_len, (grid_size * (grid_size/2))), dtype=tf.float64) self.num_freq_blocks = tf.placeholder(name='num_freq_blocks', dtype=tf.float32) self.rnn = rnn.GridLSTMCell(num_units=num_layers, feature_size=grid_size, frequency_skip=grid_size, use_peepholes=True, num_frequency_blocks=[int(grid_size/2)], share_time_frequency_weights=True, state_is_tuple=False, couple_input_forget_gates=True, reuse=tf.AUTO_REUSE) # self.rnn = rnn_t.LSTMCell(num_units=num_layers, name='nghood_lstm', use_peepholes=True, # initializer='normal', dynamic=True, # dtype=tf.float64) self.output = tf.placeholder(dtype=tf.float64, shape=[hidden_len, (grid_size * (grid_size/2))], name="output") # .add_weight(name='weight', shape=(2,hidden_size)) # initial_value=init_w(shape=(2,hidden_size)), # trainable=True #regularizer= reg_w.l2(weights=init_w(shape=(2,hidden_size))) # self.rnn = nn.GRU(input_size, hidden_size, num_layers, # batch_first=True, bidirectional=False, dropout=dropout) # self.rnn.add_weight(name='weight', shape=(2,hidden_size), # trainable=True,initializer=init_w(shape=(2,hidden_size))) self.forward()
def __init__(self, hidden_size, num_layers,grid_size, dim): # super(neighborhood_stat_enc, self).__init__() self.hidden_size = hidden_size self.input = tf.placeholder(name='input', shape=(dim, dim), dtype=tf.float64) self.hidden_state = tf.placeholder(name='hidden_state', shape=(dim, self.hidden_size), dtype=tf.float64) # in gridLSTM frequency blocks are the units of lstm stacking vertically # while time LSTM spans horizontally self.rnn = rnn.GridLSTMCell(num_units=num_layers, feature_size=grid_size, frequency_skip=grid_size, use_peepholes=False, num_frequency_blocks=[int(grid_size/2)], share_time_frequency_weights=True, state_is_tuple=False, couple_input_forget_gates=True, reuse=True) self.output, self.c_hidden_states = self.rnn(self.input, self.hidden_state)
def testGridLstmCellWithCoupledInputForgetGates(self): num_units = 2 batch_size = 3 input_size = 4 feature_size = 2 frequency_skip = 1 num_shifts = int((input_size - feature_size) / frequency_skip + 1) expected_output = np.array( [[0.416383, 0.416383, 0.403238, 0.403238, 0.524020, 0.524020, 0.565425, 0.565425, 0.557865, 0.557865, 0.609699, 0.609699], [0.627331, 0.627331, 0.622393, 0.622393, 0.688342, 0.688342, 0.708078, 0.708078, 0.694245, 0.694245, 0.715171, 0.715171], [0.711050, 0.711050, 0.709197, 0.709197, 0.736533, 0.736533, 0.744264, 0.744264, 0.737390, 0.737390, 0.745250, 0.745250]], dtype=np.float32) expected_state = np.array( [[0.625556, 0.625556, 0.416383, 0.416383, 0.759134, 0.759134, 0.524020, 0.524020, 0.798795, 0.798795, 0.557865, 0.557865], [0.875488, 0.875488, 0.627331, 0.627331, 0.936432, 0.936432, 0.688342, 0.688342, 0.941961, 0.941961, 0.694245, 0.694245], [0.957327, 0.957327, 0.711050, 0.711050, 0.979522, 0.979522, 0.736533, 0.736533, 0.980245, 0.980245, 0.737390, 0.737390]], dtype=np.float32) for state_is_tuple in [False, True]: with self.test_session() as sess: with variable_scope.variable_scope( "state_is_tuple" + str(state_is_tuple), initializer=init_ops.constant_initializer(0.5)): cell = rnn_cell.GridLSTMCell( num_units=num_units, feature_size=feature_size, frequency_skip=frequency_skip, forget_bias=1.0, num_frequency_blocks=[num_shifts], couple_input_forget_gates=True, state_is_tuple=state_is_tuple) inputs = constant_op.constant( np.array([[1., 1., 1., 1.], [2., 2., 2., 2.], [3., 3., 3., 3.]], dtype=np.float32), dtype=dtypes.float32) if state_is_tuple: state_value = constant_op.constant( 0.1 * np.ones( (batch_size, num_units), dtype=np.float32), dtype=dtypes.float32) init_state = cell.state_tuple_type( *([state_value, state_value] * num_shifts)) else: init_state = constant_op.constant( 0.1 * np.ones( (batch_size, num_units * num_shifts * 2), dtype=np.float32), dtype=dtypes.float32) output, state = cell(inputs, init_state) sess.run([variables.global_variables_initializer()]) res = sess.run([output, state]) # This is a smoke test: Only making sure expected values not change. self.assertEqual(len(res), 2) self.assertAllClose(res[0], expected_output) if not state_is_tuple: self.assertAllClose(res[1], expected_state) else: # There should be num_shifts * 2 states in the tuple. self.assertEqual(len(res[1]), num_shifts * 2) # Checking the shape of each state to be batch_size * num_units for ss in res[1]: self.assertEqual(ss.shape[0], batch_size) self.assertEqual(ss.shape[1], num_units) self.assertAllClose(np.concatenate(res[1], axis=1), expected_state)
def __init__(self, hidden_size, hidden_len, num_layers, grid_size, embedding_size, dim, dropout=0): # super(neighborhood_vis_loc_encoder, self).__init__() # tf.Variable() # reg_w = tf.contrib.layers.l2_regularizer(scale=0.1) self.hidden_size = hidden_size self.embedding_size = embedding_size self.input = tf.placeholder(dtype=tf.float64, shape=[hidden_len + 2, hidden_len + 2], name="inputs") # TODO: shape 4D self.state_f00_b00_c = tf.placeholder(name='state_f00_b00_c', shape=(hidden_len + 2, self.hidden_size), dtype=tf.float64) self.c_hidden_state = tf.placeholder(name='c_hidden_state', shape=(hidden_len, self.hidden_size), dtype=tf.float64) self.state_f00_b00_m = tf.placeholder( name='state_f00_b00_m', shape=(hidden_len, (grid_size * (grid_size / 2))), dtype=tf.float64) self.num_freq_blocks = tf.placeholder(name='num_freq_blocks', dtype=tf.float32) self.hidden_size = hidden_size # self.input = tf.placeholder(name='input', shape=(dim, 8), # dtype=tf.float64) self.stat_input = tf.placeholder(name='stat_input', shape=(dim + 2, 8), dtype=tf.float64) self.hidden_state = tf.placeholder(name='hidden_state', shape=(dim + 2, self.hidden_size), dtype=tf.float64) self.output = tf.placeholder( dtype=tf.float64, shape=[hidden_len, hidden_len], # (grid_size * (grid_size/2))], name="output") self.rnn = rnn.GridLSTMCell( num_units=num_layers, feature_size=grid_size, frequency_skip=grid_size, use_peepholes=True, num_frequency_blocks=[int(hidden_len / grid_size) ], #int(grid_size/2) share_time_frequency_weights=True, state_is_tuple=False, couple_input_forget_gates=True, reuse=tf.AUTO_REUSE) self.stat_rnn = rnn.GridLSTMCell( num_units=num_layers, feature_size=grid_size, frequency_skip=grid_size, use_peepholes=False, num_frequency_blocks=[int(grid_size / 2)], share_time_frequency_weights=True, state_is_tuple=False, couple_input_forget_gates=True, reuse=tf.AUTO_REUSE) # self.rnn = rnn_t.LSTMCell(num_units=num_layers, name='nghood_lstm', use_peepholes=True, # initializer='normal', dynamic=True, # dtype=tf.float64) self.forward()