我们从Python开源项目中，提取了以下18个代码示例，用于说明如何使用tensorflow.contrib.slim.repeat()。
def encoder(self, images, is_training): activation_fn = leaky_relu # tf.nn.relu weight_decay = 0.0 with tf.variable_scope('encoder'): with slim.arg_scope([slim.batch_norm], is_training=is_training): with slim.arg_scope([slim.conv2d, slim.fully_connected], weights_initializer=tf.truncated_normal_initializer(stddev=0.1), weights_regularizer=slim.l2_regularizer(weight_decay), normalizer_fn=slim.batch_norm, normalizer_params=self.batch_norm_params): net = images net = slim.conv2d(net, 32, [4, 4], 2, activation_fn=activation_fn, scope='Conv2d_1a') net = slim.repeat(net, 3, conv2d_block, 0.1, 32, [4, 4], 1, activation_fn=activation_fn, scope='Conv2d_1b') net = slim.conv2d(net, 64, [4, 4], 2, activation_fn=activation_fn, scope='Conv2d_2a') net = slim.repeat(net, 3, conv2d_block, 0.1, 64, [4, 4], 1, activation_fn=activation_fn, scope='Conv2d_2b') net = slim.conv2d(net, 128, [4, 4], 2, activation_fn=activation_fn, scope='Conv2d_3a') net = slim.repeat(net, 3, conv2d_block, 0.1, 128, [4, 4], 1, activation_fn=activation_fn, scope='Conv2d_3b') net = slim.conv2d(net, 256, [4, 4], 2, activation_fn=activation_fn, scope='Conv2d_4a') net = slim.repeat(net, 3, conv2d_block, 0.1, 256, [4, 4], 1, activation_fn=activation_fn, scope='Conv2d_4b') net = slim.flatten(net) fc1 = slim.fully_connected(net, self.latent_variable_dim, activation_fn=None, normalizer_fn=None, scope='Fc_1') fc2 = slim.fully_connected(net, self.latent_variable_dim, activation_fn=None, normalizer_fn=None, scope='Fc_2') return fc1, fc2
def _image_to_head(self, is_training, reuse=None): with tf.variable_scope(self._scope, self._scope, reuse=reuse): net = slim.repeat(self._image, 2, slim.conv2d, 64, [3, 3], trainable=False, scope='conv1') net = slim.max_pool2d(net, [2, 2], padding='SAME', scope='pool1') net = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], trainable=False, scope='conv2') net = slim.max_pool2d(net, [2, 2], padding='SAME', scope='pool2') net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], trainable=is_training, scope='conv3') net = slim.max_pool2d(net, [2, 2], padding='SAME', scope='pool3') net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], trainable=is_training, scope='conv4') net = slim.max_pool2d(net, [2, 2], padding='SAME', scope='pool4') net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], trainable=is_training, scope='conv5') self._act_summaries.append(net) self._layers['head'] = net return net
def encoder(self, x, embedding, reuse=None): with tf.variable_scope("encoder", reuse=reuse): with slim.arg_scope([slim.conv2d], stride=1, activation_fn=tf.nn.elu, padding="SAME", weights_initializer=tf.contrib.layers.variance_scaling_initializer(), weights_regularizer=slim.l2_regularizer(5e-4), bias_initializer=tf.zeros_initializer()): x = slim.conv2d(x, embedding, 3) for i in range(self.conv_repeat_num): channel_num = embedding * (i + 1) x = slim.repeat(x, 2, slim.conv2d, channel_num, 3) if i < self.conv_repeat_num - 1: # Is using stride pooling more better method than max pooling? # or average pooling # x = slim.conv2d(x, channel_num, kernel_size=3, stride=2) # sub-sampling x = slim.avg_pool2d(x, kernel_size=2, stride=2) # x = slim.max_pooling2d(x, 3, 2) x = tf.reshape(x, [-1, np.prod([8, 8, channel_num])]) return x
def decoder(self, z, embedding, reuse=None): with tf.variable_scope("decoder", reuse=reuse): with slim.arg_scope([slim.conv2d, slim.fully_connected], weights_initializer=tf.contrib.layers.variance_scaling_initializer(), weights_regularizer=slim.l2_regularizer(5e-4), bias_initializer=tf.zeros_initializer()): with slim.arg_scope([slim.conv2d], padding="SAME", activation_fn=tf.nn.elu, stride=1): x = slim.fully_connected(z, 8 * 8 * embedding, activation_fn=None) x = tf.reshape(x, [-1, 8, 8, embedding]) for i in range(self.conv_repeat_num): x = slim.repeat(x, 2, slim.conv2d, embedding, 3) if i < self.conv_repeat_num - 1: x = resize_nn(x, 2) # NN up-sampling x = slim.conv2d(x, 3, 3, activation_fn=None) return x
def _image_to_head(self, is_training, reuse=False): with tf.variable_scope(self._scope, self._scope, reuse=reuse): net = slim.repeat(self._image, 2, slim.conv2d, 64, [3, 3], trainable=False, scope='conv1') net = slim.max_pool2d(net, [2, 2], padding='SAME', scope='pool1') net = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], trainable=False, scope='conv2') net = slim.max_pool2d(net, [2, 2], padding='SAME', scope='pool2') net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], trainable=is_training, scope='conv3') net = slim.max_pool2d(net, [2, 2], padding='SAME', scope='pool3') net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], trainable=is_training, scope='conv4') net = slim.max_pool2d(net, [2, 2], padding='SAME', scope='pool4') net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], trainable=is_training, scope='conv5') self._act_summaries.append(net) self._layers['head'] = net return net
def vgg16(inputs, num_classes, batch_size): with slim.arg_scope([slim.conv2d, slim.fully_connected], activation_fn=tf.nn.relu, weights_initializer=tf.truncated_normal_initializer(0.0, 0.01)): net = slim.repeat(inputs, 2, slim.conv2d, 64, [3, 3], padding="SAME", scope='conv1') net = slim.max_pool2d(net, [2, 2], scope='pool1') net = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], padding="SAME", scope='conv2') net = slim.max_pool2d(net, [2, 2], scope='pool2') net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], padding="SAME", scope='conv3') net = slim.max_pool2d(net, [2, 2], scope='pool3') net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], padding="SAME", scope='conv4') net = slim.max_pool2d(net, [2, 2], scope='pool4') net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], padding="SAME", scope='conv5') net = slim.max_pool2d(net, [2, 2], scope='pool5') net = tf.reshape(net, (batch_size, 7 * 7 * 512)) net = slim.fully_connected(net, 4096, scope='fc6') net = slim.dropout(net, 0.5, scope='dropout6') net = slim.fully_connected(net, 4096, scope='fc7') net = slim.dropout(net, 0.5, scope='dropout7') net = slim.fully_connected(net, 1000, activation_fn=None, scope='fc8') return net
def _image_to_head(self, is_training, reuse=False): with tf.variable_scope(self._scope, self._scope, reuse=reuse): # [VGG16] conv1 # input shape : 224 * 224 * 3 # output shape : 112 * 112 * 64 net = slim.repeat(self._image, 2, slim.conv2d, 64, [3, 3], trainable=False, scope='conv1') net = slim.max_pool2d(net, [2, 2], padding='SAME', scope='pool1') # [VGG16] conv2 # input shape : 112 * 112 * 64 # output shape : 56 * 56 * 128 net = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], trainable=False, scope='conv2') net = slim.max_pool2d(net, [2, 2], padding='SAME', scope='pool2') # [Hand Detection] REMOVE net = slim.max_pool2d(net, [2, 2], padding='SAME', scope='pool3') # [Hand Detection] conv3 # input shape : 56 * 56 * 128 # output shape : 56 * 56 * 256 net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], trainable=is_training, scope='conv3') to_be_normalized_1 = net # [Hand Detection] conv4 # input shape : 56 * 56 * 256 # output shape : 56 * 56 * 256 net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], trainable=is_training, scope='conv4') to_be_normalized_2 = net # [Hand Detection] conv5 # input shape : 56 * 56 * 256 # output shape : 56 * 56 * 256 net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], trainable=is_training, scope='conv5') to_be_normalized_3 = net return to_be_normalized_1, to_be_normalized_2, to_be_normalized_3
def vgg_16(inputs, variables_collections=None, scope='vgg_16', reuse=None): """ modification of vgg_16 in TF-slim see original code in https://github.com/tensorflow/models/blob/master/slim/nets/vgg.py """ with tf.variable_scope(scope, 'vgg_16', [inputs]) as sc: # Collect outputs for conv2d, fully_connected and max_pool2d. with slim.arg_scope([slim.conv2d, slim.fully_connected, slim.max_pool2d]): conv1 = slim.repeat(inputs, 2, slim.conv2d, 64, [3, 3], scope='conv1', biases_initializer=None, variables_collections=variables_collections, reuse=reuse) pool1, argmax_1 = tf.nn.max_pool_with_argmax(conv1, [1,2,2,1], [1,2,2,1], padding='VALID', name='pool1') conv2 = slim.repeat(pool1, 2, slim.conv2d, 128, [3, 3], scope='conv2', biases_initializer=None, variables_collections=variables_collections, reuse=reuse) pool2, argmax_2 = tf.nn.max_pool_with_argmax(conv2, [1,2,2,1], [1,2,2,1], padding='VALID', name='pool2') conv3 = slim.repeat(pool2, 3, slim.conv2d, 256, [3, 3], scope='conv3', biases_initializer=None, variables_collections=variables_collections, reuse=reuse) pool3, argmax_3 = tf.nn.max_pool_with_argmax(conv3, [1,2,2,1], [1,2,2,1], padding='VALID', name='pool3') conv4 = slim.repeat(pool3, 3, slim.conv2d, 512, [3, 3], scope='conv4', biases_initializer=None, variables_collections=variables_collections, reuse=reuse) pool4, argmax_4 = tf.nn.max_pool_with_argmax(conv4, [1,2,2,1], [1,2,2,1], padding='VALID', name='pool4') conv5 = slim.repeat(pool4, 3, slim.conv2d, 512, [3, 3], scope='conv5', biases_initializer=None, variables_collections=variables_collections, reuse=reuse) pool5, argmax_5 = tf.nn.max_pool_with_argmax(conv5, [1,2,2,1], [1,2,2,1], padding='VALID', name='pool5') # return argmax argmax = (argmax_1, argmax_2, argmax_3, argmax_4, argmax_5) # return feature maps features = (conv1, conv2, conv3, conv4, conv5) return pool5, argmax, features
def decoder(self, latent_var, is_training): activation_fn = leaky_relu # tf.nn.relu weight_decay = 0.0 with tf.variable_scope('decoder'): with slim.arg_scope([slim.batch_norm], is_training=is_training): with slim.arg_scope([slim.conv2d, slim.fully_connected], weights_initializer=tf.truncated_normal_initializer(stddev=0.1), weights_regularizer=slim.l2_regularizer(weight_decay), normalizer_fn=slim.batch_norm, normalizer_params=self.batch_norm_params): net = slim.fully_connected(latent_var, 4096, activation_fn=None, normalizer_fn=None, scope='Fc_1') net = tf.reshape(net, [-1,4,4,256], name='Reshape') net = tf.image.resize_nearest_neighbor(net, size=(8,8), name='Upsample_1') net = slim.conv2d(net, 128, [3, 3], 1, activation_fn=activation_fn, scope='Conv2d_1a') net = slim.repeat(net, 3, conv2d_block, 0.1, 128, [3, 3], 1, activation_fn=activation_fn, scope='Conv2d_1b') net = tf.image.resize_nearest_neighbor(net, size=(16,16), name='Upsample_2') net = slim.conv2d(net, 64, [3, 3], 1, activation_fn=activation_fn, scope='Conv2d_2a') net = slim.repeat(net, 3, conv2d_block, 0.1, 64, [3, 3], 1, activation_fn=activation_fn, scope='Conv2d_2b') net = tf.image.resize_nearest_neighbor(net, size=(32,32), name='Upsample_3') net = slim.conv2d(net, 32, [3, 3], 1, activation_fn=activation_fn, scope='Conv2d_3a') net = slim.repeat(net, 3, conv2d_block, 0.1, 32, [3, 3], 1, activation_fn=activation_fn, scope='Conv2d_3b') net = tf.image.resize_nearest_neighbor(net, size=(64,64), name='Upsample_4') net = slim.conv2d(net, 3, [3, 3], 1, activation_fn=activation_fn, scope='Conv2d_4a') net = slim.repeat(net, 3, conv2d_block, 0.1, 3, [3, 3], 1, activation_fn=activation_fn, scope='Conv2d_4b') net = slim.conv2d(net, 3, [3, 3], 1, activation_fn=None, scope='Conv2d_4c') return net
def get_model(self,inputs, weight_decay=0.0005,is_training=False): # End_points collect relevant activations for external use. arg_scope = self.__arg_scope(weight_decay=weight_decay) with slim.arg_scope(arg_scope): end_points = {} with tf.variable_scope('vgg_16', [inputs]): # Original VGG-16 blocks. net = slim.repeat(inputs, 2, slim.conv2d, 64, [3, 3], scope='conv1') end_points['block1'] = net net = slim.max_pool2d(net, [2, 2], scope='pool1') # Block 2. net = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], scope='conv2') end_points['block2'] = net net = slim.max_pool2d(net, [2, 2], scope='pool2') # Block 3. net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], scope='conv3') end_points['block3'] = net net = slim.max_pool2d(net, [2, 2], scope='pool3') # Block 4. net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv4') end_points['block4'] = net net = slim.max_pool2d(net, [2, 2], scope='pool4') # Block 5. net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv5') end_points['block5'] = net net = slim.max_pool2d(net, [3, 3], stride=1, scope='pool5') # Additional SSD blocks. keep_prob=0.8 with slim.arg_scope([slim.conv2d], activation_fn=None): with slim.arg_scope([slim.batch_norm], activation_fn=tf.nn.relu, is_training=is_training,updates_collections=None): with slim.arg_scope([slim.dropout], is_training=is_training,keep_prob=keep_prob): with tf.variable_scope(self.model_name): return self.__additional_ssd_block(end_points, net)
def encoder(self, x): """ Convolutional variational encoder to encode image into a low-dimensional latent code If config.conv == False it is a MLP VAE. If config.use_vae == False, it is a normal encoder :param x: sequence of images :return: a, a_mu, a_var """ with tf.variable_scope('vae/encoder'): if self.config.conv: x_flat_conv = tf.reshape(x, (-1, self.d1, self.d2, 1)) enc_hidden = slim.stack(x_flat_conv, slim.conv2d, self.num_filters, kernel_size=self.config.filter_size, stride=2, activation_fn=self.activation_fn, padding='SAME') enc_flat = slim.flatten(enc_hidden) self.enc_shape = enc_hidden.get_shape().as_list()[1:] else: x_flat = tf.reshape(x, (-1, self.d1 * self.d2)) enc_flat = slim.repeat(x_flat, self.config.num_layers, slim.fully_connected, self.config.vae_num_units, self.activation_fn) a_mu = slim.fully_connected(enc_flat, self.config.dim_a, activation_fn=None) if self.config.use_vae: a_var = slim.fully_connected(enc_flat, self.config.dim_a, activation_fn=tf.nn.sigmoid) a_var = self.config.noise_emission * a_var a = simple_sample(a_mu, a_var) else: a_var = tf.constant(1., dtype=tf.float32, shape=()) a = a_mu a_seq = tf.reshape(a, tf.stack((-1, self.ph_steps, self.config.dim_a))) return a_seq, a_mu, a_var
def repeat(inputs, repetitions, layer, layer_dict={}, **kargv): outputs = slim.repeat(inputs, repetitions, layer, **kargv) _update_dict(layer_dict, kargv['scope'], outputs) return outputs
def vgg_16(inputs, num_classes=1000, is_training=True, dropout_keep_prob=0.5, spatial_squeeze=True, scope='vgg_16'): """Oxford Net VGG 16-Layers version D Example. Note: All the fully_connected layers have been transformed to conv2d layers. To use in classification mode, resize input to 224x224. Args: inputs: a tensor of size [batch_size, height, width, channels]. num_classes: number of predicted classes. is_training: whether or not the model is being trained. dropout_keep_prob: the probability that activations are kept in the dropout layers during training. spatial_squeeze: whether or not should squeeze the spatial dimensions of the outputs. Useful to remove unnecessary dimensions for classification. scope: Optional scope for the variables. Returns: the last op containing the log predictions and end_points dict. """ with tf.name_scope(scope, 'vgg_16', [inputs]) as sc: end_points_collection = sc + '_end_points' # Collect outputs for conv2d, fully_connected and max_pool2d. with slim.arg_scope([slim.conv2d, slim.fully_connected, slim.max_pool2d], outputs_collections=end_points_collection): net = slim.repeat(inputs, 2, slim.conv2d, 64, [3, 3], scope='conv1') net = slim.max_pool2d(net, [2, 2], scope='pool1') net = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], scope='conv2') net = slim.max_pool2d(net, [2, 2], scope='pool2') net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], scope='conv3') net = slim.max_pool2d(net, [2, 2], scope='pool3') net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv4') net = slim.max_pool2d(net, [2, 2], scope='pool4') net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv5') net = slim.max_pool2d(net, [2, 2], scope='pool5') # Use conv2d instead of fully_connected layers. net = slim.conv2d(net, 4096, [3, 3], padding='VALID', scope='fc6') net = slim.dropout(net, dropout_keep_prob, is_training=is_training, scope='dropout6') net = slim.conv2d(net, 4096, [1, 1], scope='fc7') net = slim.dropout(net, dropout_keep_prob, is_training=is_training, scope='dropout7') net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None, normalizer_fn=None, scope='fc8') # Convert end_points_collection into a end_point dict. end_points = slim.utils.convert_collection_to_dict(end_points_collection) if spatial_squeeze: net = tf.squeeze(net, [1, 2], name='fc8/squeezed') end_points[sc + '/fc8'] = net return net, end_points
def vgg_19(inputs, num_classes=1000, is_training=False, dropout_keep_prob=0.5, spatial_squeeze=True, scope='vgg_19', reuse = False, fc_conv_padding='VALID'): """Oxford Net VGG 19-Layers version E Example. Note: All the fully_connected layers have been transformed to conv2d layers. To use in classification mode, resize input to 224x224. Args: inputs: a tensor of size [batch_size, height, width, channels]. num_classes: number of predicted classes. is_training: whether or not the model is being trained. dropout_keep_prob: the probability that activations are kept in the dropout layers during training. spatial_squeeze: whether or not should squeeze the spatial dimensions of the outputs. Useful to remove unnecessary dimensions for classification. scope: Optional scope for the variables. fc_conv_padding: the type of padding to use for the fully connected layer that is implemented as a convolutional layer. Use 'SAME' padding if you are applying the network in a fully convolutional manner and want to get a prediction map downsampled by a factor of 32 as an output. Otherwise, the output prediction map will be (input / 32) - 6 in case of 'VALID' padding. Returns: the last op containing the log predictions and end_points dict. """ with tf.variable_scope(scope, 'vgg_19', [inputs], reuse=reuse) as sc: end_points_collection = sc.name + '_end_points' # Collect outputs for conv2d, fully_connected and max_pool2d. with slim.arg_scope([slim.conv2d, slim.fully_connected, slim.max_pool2d], outputs_collections=end_points_collection): net = slim.repeat(inputs, 2, slim.conv2d, 64, 3, scope='conv1', reuse=reuse) net = slim.max_pool2d(net, [2, 2], scope='pool1') net = slim.repeat(net, 2, slim.conv2d, 128, 3, scope='conv2',reuse=reuse) net = slim.max_pool2d(net, [2, 2], scope='pool2') net = slim.repeat(net, 4, slim.conv2d, 256, 3, scope='conv3', reuse=reuse) net = slim.max_pool2d(net, [2, 2], scope='pool3') net = slim.repeat(net, 4, slim.conv2d, 512, 3, scope='conv4',reuse=reuse) net = slim.max_pool2d(net, [2, 2], scope='pool4') net = slim.repeat(net, 4, slim.conv2d, 512, 3, scope='conv5',reuse=reuse) net = slim.max_pool2d(net, [2, 2], scope='pool5') # Use conv2d instead of fully_connected layers. # Convert end_points_collection into a end_point dict. end_points = slim.utils.convert_collection_to_dict(end_points_collection) return net, end_points
def decoder(self, a_seq): """ Convolutional variational decoder to decode latent code to image reconstruction If config.conv == False it is a MLP VAE. If config.use_vae == False it is a normal decoder :param a_seq: latent code :return: x_hat, x_mu, x_var """ # Create decoder if self.config.out_distr == 'bernoulli': activation_x_mu = tf.nn.sigmoid else: activation_x_mu = None with tf.variable_scope('vae/decoder'): a = tf.reshape(a_seq, (-1, self.config.dim_a)) if self.config.conv: dec_upscale = slim.fully_connected(a, int(np.prod(self.enc_shape)), activation_fn=None) dec_upscale = tf.reshape(dec_upscale, [-1] + self.enc_shape) dec_hidden = dec_upscale for filters in reversed(self.num_filters): dec_hidden = slim.conv2d(dec_hidden, filters * 4, self.config.filter_size, activation_fn=self.activation_fn) dec_hidden = subpixel_reshape(dec_hidden, 2) x_mu = slim.conv2d(dec_hidden, 1, 1, stride=1, activation_fn=activation_x_mu) x_var = tf.constant(self.config.noise_pixel_var, dtype=tf.float32, shape=()) else: dec_hidden = slim.repeat(a, self.config.num_layers, slim.fully_connected, self.config.vae_num_units, self.activation_fn) x_mu = slim.fully_connected(dec_hidden, self.d1 * self.d2, activation_fn=activation_x_mu) x_mu = tf.reshape(x_mu, (-1, self.d1, self.d2, 1)) # x_var is not used for bernoulli outputs. Here we fix the output variance of the Gaussian, # we could also learn it globally for each pixel (as we did in the pendulum experiment) or through a # neural network. x_var = tf.constant(self.config.noise_pixel_var, dtype=tf.float32, shape=()) if self.config.out_distr == 'bernoulli': # For bernoulli we show the probabilities x_hat = x_mu else: x_hat = simple_sample(x_mu, x_var) return tf.reshape(x_hat, tf.stack((-1, self.ph_steps, self.d1, self.d2))), x_mu, x_var
def alpha(self, inputs, state=None, u=None, buffer=None, reuse=None, init_buffer=False, name='alpha'): """The dynamics parameter network alpha for mixing transitions in a state space model. This function is quite general and supports different architectures (NN, RNN, FIFO queue, learning the inputs) Args: inputs: tensor to condition mixing vector on state: previous state if using RNN network to model alpha u: pass-through variable if u is given (learn_u=False) buffer: buffer for the FIFO network (used for fifo_size>1) reuse: `True` or `None`; if `True`, we go into reuse mode for this scope as well as all sub-scopes; if `None`, we just inherit the parent scope reuse. init_buffer: initialize buffer for a_t name: name of the scope Returns: alpha: mixing vector of dimension (batch size, K) state: new state u: either inferred u from model or pass-through buffer: FIFO buffer """ # Increase the number of hidden units if we also learn u (learn_u=True) num_units = self.config.alpha_units * 2 if self.config.learn_u else self.config.alpha_units # Overwrite input buffer if init_buffer: buffer = tf.zeros((tf.shape(inputs)[0], self.config.dim_a, self.config.fifo_size), dtype=tf.float32) # If K == 1, return inputs if self.config.K == 1: return tf.ones([self.config.batch_size, self.config.K]), state, u, buffer with tf.variable_scope(name, reuse=reuse): if self.config.alpha_rnn: rnn_cell = BasicLSTMCell(num_units, reuse=reuse) output, state = rnn_cell(inputs, state) else: # Shift buffer buffer = tf.concat([buffer[:, :, 1:], tf.expand_dims(inputs, 2)], 2) output = slim.repeat( tf.reshape(buffer, (tf.shape(inputs)[0], self.config.dim_a * self.config.fifo_size)), self.config.alpha_layers, slim.fully_connected, num_units, get_activation_fn(self.config.alpha_activation), scope='hidden') # Get Alpha as the first part of the output alpha = slim.fully_connected(output[:, :self.config.alpha_units], self.config.K, activation_fn=tf.nn.softmax, scope='alpha_var') if self.config.learn_u: # Get U as the second half of the output u = slim.fully_connected(output[:, self.config.alpha_units:], self.config.dim_u, activation_fn=None, scope='u_var') return alpha, state, u, buffer
