我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用tensorflow.scan()。
def omniglot(): sess = tf.InteractiveSession() """ def wrapper(v): return tf.Print(v, [v], message="Printing v") v = tf.Variable(initial_value=np.arange(0, 36).reshape((6, 6)), dtype=tf.float32, name='Matrix') sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) temp = tf.Variable(initial_value=np.arange(0, 36).reshape((6, 6)), dtype=tf.float32, name='temp') temp = wrapper(v) #with tf.control_dependencies([temp]): temp.eval() print 'Hello'""" def update_tensor(V, dim2, val): # Update tensor V, with index(:,dim2[:]) by val[:] val = tf.cast(val, V.dtype) def body(_, (v, d2, chg)): d2_int = tf.cast(d2, tf.int32) return tf.slice(tf.concat_v2([v[:d2_int],[chg] ,v[d2_int+1:]], axis=0), [0], [v.get_shape().as_list()[0]]) Z = tf.scan(body, elems=(V, dim2, val), initializer=tf.constant(1, shape=V.get_shape().as_list()[1:], dtype=tf.float32), name="Scan_Update") return Z
def __call__(self, inputs, steps): def fn(zv, x): """ Transition for training, without Metropolis-Hastings. `z` is the input state. `v` is created as a dummy variable to allow output of v_, for training p(v). :param x: variable only for specifying the number of steps :return: next state `z_`, and the corresponding auxiliary variable `v_`. """ z, v = zv v = tf.random_normal(shape=tf.stack([tf.shape(z)[0], self.network.v_dim])) z_, v_ = self.network.forward([z, v]) return z_, v_ elems = tf.zeros([steps]) return tf.scan(fn, elems, inputs, back_prop=True)
def _cumprod(tensor, axis=0): """A custom version of cumprod to prevent NaN gradients when there are zeros in `tensor` as reported here: https://github.com/tensorflow/tensorflow/issues/3862 :param tensor: tf.Tensor :return: tf.Tensor """ transpose_permutation = None n_dim = len(tensor.get_shape()) if n_dim > 1 and axis != 0: if axis < 0: axis += n_dim transpose_permutation = np.arange(n_dim) transpose_permutation[-1], transpose_permutation[0] = 0, axis tensor = tf.transpose(tensor, transpose_permutation) def prod(acc, x): return acc * x prob = tf.scan(prod, tensor) tensor = tf.transpose(prob, transpose_permutation) return tensor
def get_output_for(self, input, **kwargs): input_shape = tf.shape(input) n_batches = input_shape[0] n_steps = input_shape[1] input = tf.reshape(input, tf.pack([n_batches, n_steps, -1])) if 'recurrent_state' in kwargs and self in kwargs['recurrent_state']: h0s = kwargs['recurrent_state'][self] else: h0s = tf.tile( tf.reshape(self.h0, (1, self.num_units)), (n_batches, 1) ) # flatten extra dimensions shuffled_input = tf.transpose(input, (1, 0, 2)) hs = tf.scan( self.step, elems=shuffled_input, initializer=h0s ) shuffled_hs = tf.transpose(hs, (1, 0, 2)) if 'recurrent_state_output' in kwargs: kwargs['recurrent_state_output'][self] = shuffled_hs return shuffled_hs
def get_output_for(self, input, **kwargs): input_shape = tf.shape(input) n_batches = input_shape[0] n_steps = input_shape[1] input = tf.reshape(input, tf.pack([n_batches, n_steps, -1])) c0s = tf.tile( tf.reshape(self.c0, (1, self.num_units)), (n_batches, 1) ) h0s = self.nonlinearity(c0s) # flatten extra dimensions shuffled_input = tf.transpose(input, (1, 0, 2)) hcs = tf.scan( self.step, elems=shuffled_input, initializer=tf.concat(1, [h0s, c0s]) ) shuffled_hcs = tf.transpose(hcs, (1, 0, 2)) shuffled_hs = shuffled_hcs[:, :, :self.num_units] shuffled_cs = shuffled_hcs[:, :, self.num_units:] return shuffled_hs
def get_output_for(self, input, **kwargs): input_shape = tf.shape(input) n_batches = input_shape[0] n_steps = input_shape[1] input = tf.reshape(input, tf.stack([n_batches, n_steps, -1])) if 'recurrent_state' in kwargs and self in kwargs['recurrent_state']: h0s = kwargs['recurrent_state'][self] else: h0s = tf.tile( tf.reshape(self.h0, (1, self.num_units)), (n_batches, 1) ) # flatten extra dimensions shuffled_input = tf.transpose(input, (1, 0, 2)) hs = tf.scan( self.step, elems=shuffled_input, initializer=h0s ) shuffled_hs = tf.transpose(hs, (1, 0, 2)) if 'recurrent_state_output' in kwargs: kwargs['recurrent_state_output'][self] = shuffled_hs return shuffled_hs
def get_output_for(self, input, **kwargs): input_shape = tf.shape(input) n_batches = input_shape[0] n_steps = input_shape[1] input = tf.reshape(input, tf.stack([n_batches, n_steps, -1])) c0s = tf.tile( tf.reshape(self.c0, (1, self.num_units)), (n_batches, 1) ) h0s = self.nonlinearity(c0s) # flatten extra dimensions shuffled_input = tf.transpose(input, (1, 0, 2)) hcs = tf.scan( self.step, elems=shuffled_input, initializer=tf.concat(axis=1, values=[h0s, c0s]) ) shuffled_hcs = tf.transpose(hcs, (1, 0, 2)) shuffled_hs = shuffled_hcs[:, :, :self.num_units] shuffled_cs = shuffled_hcs[:, :, self.num_units:] return shuffled_hs
def seg_prediction(self): outputs, size, batch_size = self.outputs num_class = self.config.num_class output_w = weight_variable([size, num_class]) output_b = bias_variable([num_class]) # outputs = tf.transpose(outputs,[1,0,2]) tag_trans = weight_variable([num_class, num_class]) def transition(p, x): res = tf.matmul(x, output_w) + output_b # deviation = tf.tile(tf.expand_dims(tf.reduce_min(previous_pred, reduction_indices=1), 1), # [1, num_class]) # previous_pred -= deviation focus = 1. res += tf.matmul(p, tag_trans) * focus prediction = tf.nn.softmax(res) return prediction # Recurrent network. pred = tf.scan(transition, outputs, initializer=tf.zeros([batch_size, num_class]), parallel_iterations=100) pred = tf.transpose(pred, [1, 0, 2]) return pred
def pos_prediction(self): outputs, size, batch_size = self.outputs num_class = len(POS_tagging['P']) output_w = weight_variable([size, num_class]) output_b = bias_variable([num_class]) # outputs = tf.transpose(outputs,[1,0,2]) tag_trans = weight_variable([num_class, num_class]) outputs = tf.reverse(outputs, [True, False, False]) def transition(previous_pred, x): res = tf.matmul(x, output_w) + output_b deviation = tf.tile(tf.expand_dims(tf.reduce_min(previous_pred, reduction_indices=1), 1), [1, num_class]) previous_pred -= deviation focus = 0.5 res += tf.matmul(previous_pred, tag_trans) * focus prediction = tf.nn.softmax(res) return prediction # Recurrent network. pred = tf.scan(transition, outputs, initializer=tf.zeros([batch_size, num_class]), parallel_iterations=100) pred = tf.reverse(pred, [True, False, False]) pred = tf.transpose(pred, [1, 0, 2]) return pred
def loss_crf(self): """ CRF based loss. :return: loss """ # Reshaping seq_len tensor [seq_len, 1] seq_length_reshaped = tf.reshape(self.x_tokens_len, [tf.shape(self.x_tokens_len)[0], -1]) # Computing loss by scanning mini-batch tensor out = tf.scan(self.loss_crf_scan, [self.prediction, seq_length_reshaped, self.y], back_prop=True, infer_shape=True, initializer=0.0) # Division by batch_size loss_crf = tf.divide(tf.reduce_sum(out), tf.cast(tf.shape(self.x_tokens)[0], dtype=tf.float32)) return loss_crf
def refine_boxes(boxes, num_iters, step, sigma): assert num_iters > 1 def iteration(prev, i): state_prev, _ = prev features = state_prev / sigma dists = tf.nn.relu(nnutil.pairwise_distance(features)) weights = tf.exp(-dists) confidence = tf.reduce_sum(weights, [1], True) weights = weights / confidence state_up = tf.matmul(weights, state_prev) return (1.0 - step) * state_prev + step * state_up, confidence states = tf.scan(iteration, tf.range(0, num_iters), initializer=(boxes, boxes[:,0:1])) return states[0][-1], states[1][-1]
def compute_predictions_scan(self): state = self.init_state rnn_states = \ tf.scan( self.rnn_step_scan, tf.transpose(self.x, [1, 0, 2]), initializer=state, parallel_iterations=1) rnn_outputs = \ tf.scan( self.output_step_scan, rnn_states, initializer=tf.zeros([self.N_batch, self.N_out]), parallel_iterations= 1) return tf.transpose(rnn_outputs, [1, 0, 2]), tf.unstack(rnn_states) # fix spectral radius of recurrent matrix
def get_decoder_states(self): batch_size = tf.shape(self.input)[0] seq_length = tf.shape(self.input)[1] scan_input_ = tf.transpose(self.input, perm=[2, 0, 1]) scan_input_ = tf.transpose(scan_input_) # scan input is [seq_length x batch_size x input_dim] z = tf.zeros([1, batch_size, self.input_dim], dtype=tf.float32) scan_input = tf.concat([scan_input_,z],0) scan_input = tf.slice(scan_input, [1,0,0],[seq_length ,batch_size, self.input_dim]) scan_input = tf.reverse(scan_input, [0])#tf.reverse(scan_input, [True, False, False]) scan_time_ = tf.transpose(self.time) # scan_time [seq_length x batch_size] z2 = tf.zeros([1, batch_size], dtype=tf.float32) scan_time = tf.concat([scan_time_, z2],0) scan_time = tf.slice(scan_time, [1,0],[seq_length ,batch_size]) scan_time = tf.reverse(scan_time, [0])#tf.reverse(scan_time, [True, False]) initial_hidden, initial_cell = self.get_representation() ini_state_cell = tf.stack([initial_hidden, initial_cell]) # make scan_time [seq_length x batch_size x 1] scan_time = tf.reshape(scan_time, [tf.shape(scan_time)[0], tf.shape(scan_time)[1], 1]) concat_input = tf.concat([scan_time, scan_input],2) # [seq_length x batch_size x input_dim+1] packed_hidden_states = tf.scan(self.T_LSTM_Decoder_Unit, concat_input, initializer=ini_state_cell, name='decoder_states') all_decoder_states = packed_hidden_states[:, 0, :, :] return all_decoder_states
def __call__(self, inputs, init_state=None): if init_state is None: init_state = self.zero_state init_states = tf.unstack(init_state) next_inputs = inputs for i, cell in enumerate(self.cells): with tf.variable_scope('bilstm_%d' % i): with tf.variable_scope('forward'): f_outputs = cell.scan(next_inputs, init_states[i]) with tf.variable_scope('backward'): r_inputs = tf.reverse(next_inputs, axis=(0,)) rb_outputs = cell.scan(r_inputs, init_states[i]) b_outputs = tf.reverse(rb_outputs, axis=(0,)) outputs = tf.concat([f_outputs, b_outputs], axis=2) next_inputs = tf.nn.dropout(outputs, keep_prob=self.dropout) return next_inputs
def parse_args(): parser = argparse.ArgumentParser( description='Gated Recurrent Unit RNN for Text Hallucination, built with tf.scan') group = parser.add_mutually_exclusive_group(required=True) group.add_argument('-g', '--generate', action='store_true', help='generate text') group.add_argument('-t', '--train', action='store_true', help='train model') parser.add_argument('-n', '--num_words', required=False, type=int, help='number of words to generate') args = vars(parser.parse_args()) return args ### # main function
def parse_args(): parser = argparse.ArgumentParser( description='Long Short Term Memory RNN for Text Hallucination, built with tf.scan') group = parser.add_mutually_exclusive_group(required=True) group.add_argument('-g', '--generate', action='store_true', help='generate text') group.add_argument('-t', '--train', action='store_true', help='train model') parser.add_argument('-n', '--num_words', required=False, type=int, help='number of words to generate') args = vars(parser.parse_args()) return args ### # main function
def parse_args(): parser = argparse.ArgumentParser( description='Stacked Long Short Term Memory RNN for Text Hallucination, built with tf.scan') group = parser.add_mutually_exclusive_group(required=True) group.add_argument('-g', '--generate', action='store_true', help='generate text') group.add_argument('-t', '--train', action='store_true', help='train model') parser.add_argument('-n', '--num_words', required=False, type=int, help='number of words to generate') args = vars(parser.parse_args()) return args ### # main function
def parse_args(): parser = argparse.ArgumentParser( description='Stacked Gated Recurrent Unit RNN for Text Hallucination, built with tf.scan') group = parser.add_mutually_exclusive_group(required=True) group.add_argument('-g', '--generate', action='store_true', help='generate text') group.add_argument('-t', '--train', action='store_true', help='train model') parser.add_argument('-n', '--num_words', required=False, type=int, help='number of words to generate') args = vars(parser.parse_args()) return args ### # main function
def backward_step_fn(self, params, inputs): """ Backwards step over a batch, to be used in tf.scan :param params: :param inputs: (batch_size, variable dimensions) :return: """ mu_back, Sigma_back = params mu_pred_tp1, Sigma_pred_tp1, mu_filt_t, Sigma_filt_t, A = inputs # J_t = tf.matmul(tf.reshape(tf.transpose(tf.matrix_inverse(Sigma_pred_tp1), [0, 2, 1]), [-1, self.dim_z]), # self.A) # J_t = tf.transpose(tf.reshape(J_t, [-1, self.dim_z, self.dim_z]), [0, 2, 1]) J_t = tf.matmul(tf.transpose(A, [0, 2, 1]), tf.matrix_inverse(Sigma_pred_tp1)) J_t = tf.matmul(Sigma_filt_t, J_t) mu_back = mu_filt_t + tf.matmul(J_t, mu_back - mu_pred_tp1) Sigma_back = Sigma_filt_t + tf.matmul(J_t, tf.matmul(Sigma_back - Sigma_pred_tp1, J_t, adjoint_b=True)) return mu_back, Sigma_back
def compute_forwards(self, reuse=None): """Compute the forward step in the Kalman filter. The forward pass is intialized with p(z_1)=N(self.mu, self.Sigma). We then return the mean and covariances of the predictive distribution p(z_t|z_tm1,u_t), t=2,..T+1 and the filtering distribution p(z_t|x_1:t,u_1:t), t=1,..T We follow the notation of Murphy's book, section 18.3.1 """ # To make sure we are not accidentally using the real outputs in the steps with missing values, set them to 0. y_masked = tf.multiply(tf.expand_dims(self.mask, 2), self.y) inputs = tf.concat([y_masked, self.u, tf.expand_dims(self.mask, 2)], axis=2) y_prev = tf.expand_dims(self.y_0, 0) # (1, dim_y) y_prev = tf.tile(y_prev, (tf.shape(self.mu)[0], 1)) alpha, state, u, buffer = self.alpha(y_prev, self.state, self.u[:, 0], init_buffer=True, reuse= reuse) # dummy matrix to initialize B and C in scan dummy_init_A = tf.ones([self.Sigma.get_shape()[0], self.dim_z, self.dim_z]) dummy_init_B = tf.ones([self.Sigma.get_shape()[0], self.dim_z, self.dim_u]) dummy_init_C = tf.ones([self.Sigma.get_shape()[0], self.dim_y, self.dim_z]) forward_states = tf.scan(self.forward_step_fn, tf.transpose(inputs, [1, 0, 2]), initializer=(self.mu, self.Sigma, self.mu, self.Sigma, alpha, u, state, buffer, dummy_init_A, dummy_init_B, dummy_init_C), parallel_iterations=1, name='forward') return forward_states
def decode(self, input): # returns a decoder hidden = tf.matmul(input, self.weights["decoder1_weights"]) + self.weights["decoder1_biases"] hidden_relu = tf.nn.relu(hidden) # output is encoding_size x 1 x small_encoding_size # multiheaded_hidden = tf.matmul(input, self.weights["multiheaded1_weights"]) + self.weights["multiheaded1_biases"] # multiheaded_hidden = tf.reshape(multiheaded_hidden, [-1, self.arch_params['output_dim'], 1, self.arch_params['small_encoding_dim']]) # multiheaded_hidden = tf.nn.relu(multiheaded_hidden) # # h = tf.scan(lambda a,x: tf.batch_matmul(x, self.weights["multiheaded2_weights"]), multiheaded_hidden, # initializer=tf.Variable(tf.constant(0.0, shape=[self.arch_params['output_dim'],1,1]))) # multiheaded_output = h + self.weights["multiheaded2_biases"] # output1 = tf.reshape(multiheaded_output, [-1, self.arch_params['output_dim']]) output1 = tf.matmul(hidden_relu, self.weights["decoder2_weights"]) + self.weights["decoder2_biases"] output = output1 return output
def get_output_for(self, input, **kwargs): input_shape = tf.shape(input) n_batches = input_shape[0] n_steps = input_shape[1] input = tf.reshape(input, tf.pack([n_batches, n_steps, -1])) c0s = tf.tile( tf.reshape(self.c0, (1, self.num_units)), (n_batches, 1) ) h0s = self.nonlinearity(c0s) # flatten extra dimensions shuffled_input = tf.transpose(input, (1, 0, 2)) hcs = tf.scan( self.step, elems=shuffled_input, initializer=tf.concat(axis=1, values=[h0s, c0s]) ) shuffled_hcs = tf.transpose(hcs, (1, 0, 2)) shuffled_hs = shuffled_hcs[:, :, :self.num_units] shuffled_cs = shuffled_hcs[:, :, self.num_units:] return shuffled_hs
def ctc_label_dense_to_sparse(labels, label_lengths, batch_size): # The second dimension of labels must be equal to the longest label length in the batch correct_shape_assert = tf.assert_equal(tf.shape(labels)[1], tf.reduce_max(label_lengths)) with tf.control_dependencies([correct_shape_assert]): labels = tf.identity(labels) label_shape = tf.shape(labels) num_batches_tns = tf.stack([label_shape[0]]) max_num_labels_tns = tf.stack([label_shape[1]]) def range_less_than(previous_state, current_input): return tf.expand_dims(tf.range(label_shape[1]), 0) < current_input init = tf.cast(tf.fill(max_num_labels_tns, 0), tf.bool) init = tf.expand_dims(init, 0) dense_mask = tf.scan(range_less_than, label_lengths, initializer=init, parallel_iterations=1) dense_mask = dense_mask[:, 0, :] label_array = tf.reshape(tf.tile(tf.range(0, label_shape[1]), num_batches_tns), label_shape) label_ind = tf.boolean_mask(label_array, dense_mask) batch_array = tf.transpose(tf.reshape(tf.tile(tf.range(0, label_shape[0]), max_num_labels_tns), tf.reverse(label_shape, [0]))) batch_ind = tf.boolean_mask(batch_array, dense_mask) indices = tf.transpose(tf.reshape(tf.concat([batch_ind, label_ind], 0), [2, -1])) shape = [batch_size, tf.reduce_max(label_lengths)] vals_sparse = gather_nd(labels, indices, shape) return tf.SparseTensor(tf.to_int64(indices), vals_sparse, tf.to_int64(label_shape)) # Validate and normalize transcriptions. Returns a cleaned version of the label # or None if it's invalid.
def __init__(self, energy_fn, prior, std=1.0, inter_op_parallelism_threads=1, intra_op_parallelism_threads=1): self.energy_fn = energy_fn self.prior = prior self.z = self.energy_fn.z def fn(z, x): z_ = z + tf.random_normal(tf.shape(self.z), 0.0, std) accept = metropolis_hastings_accept( energy_prev=energy_fn(z), energy_next=energy_fn(z_) ) return tf.where(accept, z_, z) self.steps = tf.placeholder(tf.int32, []) elems = tf.zeros([self.steps]) self.z_ = tf.scan( fn, elems, self.z, back_prop=False ) self.sess = tf.Session( config=tf.ConfigProto( inter_op_parallelism_threads=inter_op_parallelism_threads, intra_op_parallelism_threads=intra_op_parallelism_threads ) ) self.sess.run(tf.global_variables_initializer())
def __call__(self, inputs, steps, nice_steps=1): def nice_proposal(zv, x): """ Nice Proposal (without Metropolis-Hastings). `z` is the input state. `v` is created as a dummy variable to allow output of v_, for debugging purposes. :param zv: :param x: :return: next state `z_`, and the corresponding auxiliary variable `v_' (without MH). """ z, v = zv z_, v_ = self.network([z, v], is_backward=(x < 0.5)) #(tf.random_uniform([]) < 0.5)) return z_, v_ def fn(zv, x): """ Transition with Metropolis-Hastings. `z` is the input state. `v` is created as a dummy variable to allow output of v_, for debugging purposes. :param zv: [z, v]. It is written in this form merely to appeal to Python 3. :param x: variable only for specifying the number of steps :return: next state `z_`, and the corresponding auxiliary variable `v_`. """ z, v = zv v = tf.random_normal(shape=tf.stack([tf.shape(z)[0], self.network.v_dim])) # z_, v_ = self.network([z, v], is_backward=(tf.random_uniform([]) < 0.5)) z_, v_ = tf.scan(nice_proposal, x * tf.random_uniform([]), (z, v), back_prop=False) z_, v_ = z_[-1], v_[-1] ep = hamiltonian(z, v, self.energy_fn) en = hamiltonian(z_, v_, self.energy_fn) accept = metropolis_hastings_accept(energy_prev=ep, energy_next=en) z_ = tf.where(accept, z_, z) return z_, v_ elems = tf.ones([steps, nice_steps]) return tf.scan(fn, elems, inputs, back_prop=False)
def segment_sample_select(probs, segment_ids): num_segments = tf.reduce_max(segment_ids) + 1 sampled = tf.random_uniform([num_segments]) def scan_fn(acc, x): p, i = x[0], x[1] prev_v = tf.gather(acc[0], i) new_probs = acc[0] + tf.one_hot(i, num_segments, p) select = tf.logical_and(tf.less(prev_v, 0.0), tf.greater_equal(prev_v + p, 0.0)) return new_probs, select _, selection = tf.scan(scan_fn, (probs, segment_ids), initializer=(-sampled, False)) return selection
def get_output_for(self, input, **kwargs): input_shape = tf.shape(input) n_batches = input_shape[0] state = tf.tile( tf.reshape(self.h0, (1, self.num_units)), (n_batches, 1) ) state.set_shape((None, self.num_units)) if self.horizon is not None: outputs = [] for idx in range(self.horizon): output, state = self.gru(input[:, idx, :], state, scope=self.scope) # self.name) outputs.append(tf.expand_dims(output, 1)) outputs = tf.concat(1, outputs) return outputs else: n_steps = input_shape[1] input = tf.reshape(input, tf.pack([n_batches, n_steps, -1])) # flatten extra dimensions shuffled_input = tf.transpose(input, (1, 0, 2)) shuffled_input.set_shape((None, None, self.input_shape[-1])) hs = tf.scan( self.step, elems=shuffled_input, initializer=state ) shuffled_hs = tf.transpose(hs, (1, 0, 2)) return shuffled_hs
def get_output_for(self, input, **kwargs): input_shape = tf.shape(input) n_batches = input_shape[0] n_steps = input_shape[1] input = tf.reshape(input, tf.pack([n_batches, n_steps, -1])) h0s = tf.tile( tf.reshape(self.h0, (1, self.num_units)), (n_batches, 1) ) c0s = tf.tile( tf.reshape(self.c0, (1, self.num_units)), (n_batches, 1) ) # flatten extra dimensions shuffled_input = tf.transpose(input, (1, 0, 2)) hcs = tf.scan( self.step, elems=shuffled_input, initializer=tf.concat(1, [h0s, c0s]) ) shuffled_hcs = tf.transpose(hcs, (1, 0, 2)) shuffled_hs = shuffled_hcs[:, :, :self.num_units] shuffled_cs = shuffled_hcs[:, :, self.num_units:] if 'recurrent_state_output' in kwargs: kwargs['recurrent_state_output'][self] = shuffled_hcs return shuffled_hs
def get_output_for(self, input, **kwargs): input_shape = tf.shape(input) n_batches = input_shape[0] h0s = tf.tile( tf.reshape(self.h0, (1, self.num_units)), (n_batches, 1) ) h0s.set_shape((None, self.num_units)) c0s = tf.tile( tf.reshape(self.c0, (1, self.num_units)), (n_batches, 1) ) c0s.set_shape((None, self.num_units)) state = (c0s, h0s) if self.horizon is not None: outputs = [] for idx in range(self.horizon): output, state = self.lstm(input[:, idx, :], state, scope=self.scope) # self.name) outputs.append(tf.expand_dims(output, 1)) outputs = tf.concat(1, outputs) return outputs else: n_steps = input_shape[1] input = tf.reshape(input, tf.pack([n_batches, n_steps, -1])) # flatten extra dimensions shuffled_input = tf.transpose(input, (1, 0, 2)) shuffled_input.set_shape((None, None, self.input_shape[-1])) hcs = tf.scan( self.step, elems=shuffled_input, initializer=tf.concat(1, [h0s, c0s]), ) shuffled_hcs = tf.transpose(hcs, (1, 0, 2)) shuffled_hs = shuffled_hcs[:, :, :self.num_units] shuffled_cs = shuffled_hcs[:, :, self.num_units:] return shuffled_hs
def get_output_for(self, input, **kwargs): input_shape = tf.shape(input) n_batches = input_shape[0] state = tf.tile( tf.reshape(self.h0, (1, self.num_units)), (n_batches, 1) ) state.set_shape((None, self.num_units)) if self.horizon is not None: outputs = [] for idx in range(self.horizon): output, state = self.gru(input[:, idx, :], state, scope=self.scope) # self.name) outputs.append(tf.expand_dims(output, 1)) outputs = tf.concat(axis=1, values=outputs) return outputs else: n_steps = input_shape[1] input = tf.reshape(input, tf.stack([n_batches, n_steps, -1])) # flatten extra dimensions shuffled_input = tf.transpose(input, (1, 0, 2)) shuffled_input.set_shape((None, None, self.input_shape[-1])) hs = tf.scan( self.step, elems=shuffled_input, initializer=state ) shuffled_hs = tf.transpose(hs, (1, 0, 2)) return shuffled_hs
def get_output_for(self, input, **kwargs): input_shape = tf.shape(input) n_batches = input_shape[0] n_steps = input_shape[1] input = tf.reshape(input, tf.stack([n_batches, n_steps, -1])) h0s = tf.tile( tf.reshape(self.h0, (1, self.num_units)), (n_batches, 1) ) c0s = tf.tile( tf.reshape(self.c0, (1, self.num_units)), (n_batches, 1) ) # flatten extra dimensions shuffled_input = tf.transpose(input, (1, 0, 2)) hcs = tf.scan( self.step, elems=shuffled_input, initializer=tf.concat(axis=1, values=[h0s, c0s]) ) shuffled_hcs = tf.transpose(hcs, (1, 0, 2)) shuffled_hs = shuffled_hcs[:, :, :self.num_units] shuffled_cs = shuffled_hcs[:, :, self.num_units:] if 'recurrent_state_output' in kwargs: kwargs['recurrent_state_output'][self] = shuffled_hcs return shuffled_hs
def get_output_for(self, input, **kwargs): input_shape = tf.shape(input) n_batches = input_shape[0] h0s = tf.tile( tf.reshape(self.h0, (1, self.num_units)), (n_batches, 1) ) h0s.set_shape((None, self.num_units)) c0s = tf.tile( tf.reshape(self.c0, (1, self.num_units)), (n_batches, 1) ) c0s.set_shape((None, self.num_units)) state = (c0s, h0s) if self.horizon is not None: outputs = [] for idx in range(self.horizon): output, state = self.lstm(input[:, idx, :], state, scope=self.scope) # self.name) outputs.append(tf.expand_dims(output, 1)) outputs = tf.concat(axis=1, values=outputs) return outputs else: n_steps = input_shape[1] input = tf.reshape(input, tf.stack([n_batches, n_steps, -1])) # flatten extra dimensions shuffled_input = tf.transpose(input, (1, 0, 2)) shuffled_input.set_shape((None, None, self.input_shape[-1])) hcs = tf.scan( self.step, elems=shuffled_input, initializer=tf.concat(axis=1, values=[h0s, c0s]), ) shuffled_hcs = tf.transpose(hcs, (1, 0, 2)) shuffled_hs = shuffled_hcs[:, :, :self.num_units] shuffled_cs = shuffled_hcs[:, :, self.num_units:] return shuffled_hs
def cummax(x, reverse=False, name=None): """Compute the cumulative maximum of the tensor `x` along `axis`. This operation is similar to the more classic `cumsum`. Only support 1D Tensor for now. Args: x: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`, `complex128`, `qint8`, `quint8`, `qint32`, `half`. axis: A `Tensor` of type `int32` (default: 0). reverse: A `bool` (default: False). name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. """ with ops.name_scope(name, "Cummax", [x]) as name: x = ops.convert_to_tensor(x, name="x") # Not very optimal: should directly integrate reverse into tf.scan. if reverse: x = tf.reverse(x, axis=[0]) # 'Accumlating' maximum: ensure it is always increasing. cmax = tf.scan(lambda a, y: tf.maximum(a, y), x, initializer=None, parallel_iterations=1, back_prop=False, swap_memory=False) if reverse: cmax = tf.reverse(cmax, axis=[0]) return cmax
def tf_discount_rewards(self, tf_r): # tf_r ~ [game_steps,1] discount_f = lambda a, v: a * self._gamma + v; tf_r_reverse = tf.scan(discount_f, tf.reverse(tf_r, [True, False])) tf_discounted_r = tf.reverse(tf_r_reverse, [True, False]) return tf_discounted_r
def output(self): """Iterate through hidden states to get outputs for all""" input_shape = tf.shape(self._input_B_T_Di) input = tf.reshape(self._input_B_T_Di, tf.pack([input_shape[0], input_shape[1], -1])) h0s = tf.tile(tf.reshape(self.h0, (1, self._hidden_units)), (input_shape[0], 1)) # Flatten extra dimension shuffled_input = tf.transpose(input, (1, 0, 2)) hs = tf.scan(self.step, elems=shuffled_input, initializer=h0s) shuffled_hs = tf.transpose(hs, (1, 0, 2)) return shuffled_hs
def compute_detections_greedy(seg_preds, boxes_preds, num_outputs, seg_threshold=0.2, sigma=5e-3, step=0.2, num_iters=20, dist_threshold=20.0): mask_flat = tf.reshape(seg_preds[:,:,1], [-1]) boxes_flat = tf.reshape(boxes_preds, [-1, 4]) # TODO: also collect (y,x) coordinates idxs = tf.where(mask_flat > seg_threshold)[:,0] boxes = tf.gather(boxes_flat, idxs) boxes, confidence = refine_boxes(boxes, num_iters, step, sigma) num_boxes = tf.shape(boxes)[0] dists = tf.nn.relu(nnutil.pairwise_distance(boxes / sigma)) weights = tf.exp(-dists) def _next_detection(prev, i): _, _, presence = prev confidence_curr = tf.reduce_sum(weights * presence, [1], True) idx = tf.to_int32(tf.argmax(confidence_curr, 0)[0]) mask = tf.to_float(tf.gather(dists, idx) > dist_threshold)[:,tf.newaxis] presence = presence * mask confidence = tf.gather(confidence_curr, idx)[0] return idx, confidence, presence idxs, confidence, presences = tf.scan(_next_detection, tf.range(0, num_outputs), initializer=(0, 0.0, tf.ones([num_boxes,1]))) return tf.gather(boxes, idxs), confidence
def tf_discounted_cumulative_reward(self, terminal, reward, discount, final_reward=0.0): """ Creates the TensorFlow operations for calculating the discounted cumulative rewards for a given sequence of rewards. Args: terminal: Terminal boolean tensor. reward: Reward tensor. discount: Discount factor. final_reward: Last reward value in the sequence. Returns: Discounted cumulative reward tensor. """ # TODO: n-step cumulative reward (particularly for envs without terminal) def cumulate(cumulative, reward_and_terminal): rew, term = reward_and_terminal return tf.where( condition=term, x=rew, y=(rew + cumulative * discount) ) # Reverse since reward cumulation is calculated right-to-left, but tf.scan only works left-to-right reward = tf.reverse(tensor=reward, axis=(0,)) terminal = tf.reverse(tensor=terminal, axis=(0,)) reward = tf.scan(fn=cumulate, elems=(reward, terminal), initializer=final_reward) return tf.reverse(tensor=reward, axis=(0,))
def get_output_for(self, input, **kwargs): input_shape = tf.shape(input) n_batches = input_shape[0] state = tf.tile( tf.reshape(self.h0, (1, self.num_units)), (n_batches, 1) ) state.set_shape((None, self.num_units)) if self.horizon is not None: outputs = [] for idx in range(self.horizon): output, state = self.gru( input[:, idx, :], state, scope=self.scope) # self.name) outputs.append(tf.expand_dims(output, 1)) outputs = tf.concat(1, outputs) return outputs else: n_steps = input_shape[1] input = tf.reshape(input, tf.pack([n_batches, n_steps, -1])) # flatten extra dimensions shuffled_input = tf.transpose(input, (1, 0, 2)) shuffled_input.set_shape((None, None, self.input_shape[-1])) hs = tf.scan( self.step, elems=shuffled_input, initializer=state ) shuffled_hs = tf.transpose(hs, (1, 0, 2)) return shuffled_hs
