def shapenet_inference(image_features, angles, d_theta, d_psi, num_samples):
"""
Perform inference for the view reconstruction task
:param image_features: tensor (N x d) of training image features.
:param angles: tensor (N x d_angle) of training image angles.
:param d_theta: integer dimensionality of the features.
:param d_psi: integer dimensionality of adaptation parameters.
:param num_samples: number of samples to generate from the distribution.
:return: dictionary containing distribution parameters and samples.
"""
# Concatenate features and angles
h = tf.concat([image_features, angles], axis=-1)
# denses layer before pooling
h = dense_layer(inputs=h, output_size=d_theta, activation=tf.nn.elu, use_bias=True, name='pre_process_dense_1')
h = dense_layer(inputs=h, output_size=d_theta, activation=tf.nn.elu, use_bias=True, name='pre_process_dense_2')
# Pool across dimensions
nu = tf.expand_dims(tf.reduce_mean(h, axis=0), axis=0)
post_processed = _post_process(nu, d_psi)
# Compute means and log variances for the parameter
psi = {
'mu': dense_layer(inputs=post_processed, output_size=d_psi, activation=None, use_bias=True, name='psi_mean'),
'log_variance': dense_layer(inputs=post_processed, output_size=d_psi, activation=None, use_bias=True,
name='psi_log_var')
}
psi['psi_samples'] = sample_normal(psi['mu'], psi['log_variance'], num_samples)
return psi
def _post_process(pooled, units):
"""
Process a pooled variable through 2 dense layers
:param pooled: tensor of rank (1 x num_features).
:param units: integer number of output features.
:return: tensor of rank (1 x units)
"""
h = dense_layer(pooled, units, tf.nn.elu, True, 'post_process_dense_1')
h = dense_layer(h, units, tf.nn.elu, True, 'post_process_dense_2')
return h
def inference_block(inputs, d_theta, output_units, name):
"""
Three dense layers in sequence.
:param inputs: batch of inputs.
:param d_theta: dimensionality of the intermediate hidden layers.
:param output_units: dimensionality of the output.
:param name: name used to scope this operation.
:return: batch of outputs.
"""
h = dense_layer(inputs, d_theta, tf.nn.elu, True, name + '1')
h = dense_layer(h, d_theta, tf.nn.elu, True, name + '2')
h = dense_layer(h, output_units, None, True, name + '3')
return h
def generate_views(angles, adaptation_inputs):
"""
Based on the architecture described in 'Matching Networks for One-Shot Learning'
http://arxiv.org/abs/1606.04080.pdf.
:param angles: batch of orientationses.
:param adaptation_inputs: batch of adaptation_inputs.
:return: batch of generated views.
"""
h = tf.concat([angles, adaptation_inputs], -1)
h = dense_layer(inputs=h,
output_size=512,
activation=tf.nn.relu,
use_bias=False,
name='generate_dense_1')
h = dense_layer(inputs=h,
output_size=1024,
activation=tf.nn.relu,
use_bias=False,
name='generate_dense_2')
h = tf.reshape(h, shape=[-1, 2, 2, 256])
h = conv2d_transpose_layer(inputs=h,
filters=128,
activation=tf.nn.relu,
name='generate_deconv_1')
h = conv2d_transpose_layer(inputs=h,
filters=64,
activation=tf.nn.relu,
name='generate_deconv_2')
h = conv2d_transpose_layer(inputs=h,
filters=32,
activation=tf.nn.relu,
name='generate_deconv_3')
h = conv2d_transpose_layer(inputs=h,
filters=1,
activation=tf.nn.sigmoid,
name='generate_deconv_4')
return h
def infer_classifier(features, labels, d_theta, num_classes):
"""
Infer a linear classifier by concatenating vectors for each class.
:param features: tensor (tasks_per_batch x num_features) feature matrix
:param labels: tensor (tasks_per_batch x num_classes) one-hot label matrix
:param d_theta: Integer number of features on final layer before classifier.
:param num_classes: Integer number of classes per task.
:return: Dictionary containing output classifier layer (including means and
: log variances for weights and biases).
"""
# dense layer before pooling
pre_pooling = dense_layer(features, d_theta, None, True, 'pre_process_dense')
classifier = {}
class_weight_means = []
class_weight_logvars = []
class_bias_means = []
class_bias_logvars = []
for c in range(num_classes):
class_mask = tf.equal(tf.argmax(labels, 1), c)
class_features = tf.boolean_mask(pre_pooling, class_mask)
# Pool across dimensions
nu = tf.expand_dims(tf.reduce_mean(class_features, axis=0), axis=0)
post_processed = __post_process(nu, d_theta)
class_weight_means.append(dense_layer(post_processed, d_theta, None, True, 'weight_mean'))
class_weight_logvars.append(dense_layer(post_processed, d_theta, None, True, 'weight_log_variance'))
class_bias_means.append(dense_layer(post_processed, 1, None, True, 'bias_mean'))
class_bias_logvars.append(dense_layer(post_processed, 1, None, True, 'bias_log_variance'))
classifier['weight_mean'] = tf.transpose(tf.concat(class_weight_means, axis=0))
classifier['bias_mean'] = tf.reshape(tf.concat(class_bias_means, axis=1), [num_classes, ])
classifier['weight_log_variance'] = tf.transpose(tf.concat(class_weight_logvars, axis=0))
classifier['bias_log_variance'] = tf.reshape(tf.concat(class_bias_logvars, axis=1), [num_classes, ])
return classifier