def __init__(
self,
vgg16_npy_path,
train,
timesteps,
reuse,
fgru_normalization_type,
ff_normalization_type,
layer_name='recurrent_vgg16',
ff_nl=tf.nn.relu,
# horizontal_kernel_initializer=tf.initializers.orthogonal(),
horizontal_kernel_initializer=tf_fun.Identity(),
kernel_initializer=tf.initializers.orthogonal(),
gate_initializer=tf.initializers.orthogonal(),
train_ff_gate=None,
train_fgru_gate=None,
train_norm_moments=None,
train_norm_params=None,
train_fgru_kernels=None,
train_fgru_params=None,
up_kernel=None,
stop_loop=False,
recurrent_ff=False,
strides=[1, 1, 1, 1],
pool_strides=[2, 2], # Because fgrus are every other down-layer
pool_kernel=[2, 2],
data_format='NHWC',
horizontal_padding='SAME',
ff_padding='SAME',
vgg_dtype=tf.bfloat16,
aux=None):
if vgg16_npy_path is None:
path = inspect.getfile(Vgg16)
path = os.path.abspath(os.path.join(path, os.pardir))
path = os.path.join(path, "vgg16.npy")
vgg16_npy_path = path
print path
self.data_format = data_format
self.pool_strides = pool_strides
self.strides = strides
self.pool_kernel = pool_kernel
self.fgru_normalization_type = fgru_normalization_type
self.ff_normalization_type = ff_normalization_type
self.horizontal_padding = horizontal_padding
self.ff_padding = ff_padding
self.train = train
self.layer_name = layer_name
self.data_format = data_format
self.horizontal_kernel_initializer = horizontal_kernel_initializer
self.kernel_initializer = kernel_initializer
self.gate_initializer = gate_initializer
self.fgru_normalization_type = fgru_normalization_type
self.ff_normalization_type = ff_normalization_type
self.recurrent_ff = recurrent_ff
self.stop_loop = stop_loop
self.ff_nl = ff_nl
self.fgru_connectivity = ''
self.timesteps = timesteps
if train_ff_gate is None:
self.train_ff_gate = self.train
else:
self.train_ff_gate = train_ff_gate
if train_fgru_gate is None:
self.train_fgru_gate = self.train
else:
self.train_fgru_gate = train_fgru_gate
if train_norm_moments is None:
self.train_norm_moments = self.train
else:
self.train_norm_moments = train_norm_moments
if train_norm_moments is None:
self.train_norm_params = self.train
else:
self.train_norm_params = train_norm_params
if train_fgru_kernels is None:
self.train_fgru_kernels = self.train
else:
self.train_fgru_kernels = train_fgru_kernels
if train_fgru_kernels is None:
self.train_fgru_params = self.train
else:
self.train_fgru_params = train_fgru_params
default_vars = defaults()
if aux is not None and isinstance(aux, dict):
for k, v in aux.iteritems():
default_vars[k] = v
self.update_params(default_vars)
# Store variables in the order they were created. Hack for python 2.x.
self.variable_list = OrderedDict()
self.hidden_dict = OrderedDict()
# Kernel info
if data_format is 'NHWC':
self.prepared_pool_kernel = [1] + self.pool_kernel + [1]
self.prepared_pool_stride = [1] + self.pool_strides + [1]
self.up_strides = [1] + self.pool_strides + [1]
else:
self.prepared_pool_kernel = [1, 1] + self.pool_kernel
self.prepared_pool_stride = [1, 1] + self.pool_strides
self.up_strides = [1, 1] + self.pool_strides
self.sanity_check()
if self.symmetric_weights:
self.symmetric_weights = self.symmetric_weights.split('_')
# Nonlinearities and initializations
if isinstance(self.recurrent_nl, basestring):
self.recurrent_nl = tf_fun.interpret_nl(self.recurrent_nl)
# Set initializers for greek letters
if self.force_alpha_divisive:
self.alpha_initializer = tf.initializers.variance_scaling
else:
self.alpha_initializer = tf.ones_initializer
self.mu_initializer = tf.zeros_initializer
self.omega_initializer = tf.ones_initializer
self.kappa_initializer = tf.zeros_initializer
# Handle BN scope reuse
self.scope_reuse = reuse
# Load weights
self.data_dict = np.load(vgg16_npy_path, encoding='latin1').item()
print("npy file loaded")
def build_model(
data_tensor,
reuse,
training,
output_shape,
data_format='NHWC'):
"""Create the hgru from Learning long-range..."""
if isinstance(output_shape, list):
output_shape = output_shape[-1]
elif isinstance(output_shape, dict):
output_shape = output_shape['output']
normalization_type = 'no_param_instance_norm'
output_normalization_type = 'instance_norm'
ff_kernel_size = (3, 3)
# ff_nl = tf.nn.relu
ff_nl = tf.nn.relu
data_tensor, long_data_format = tf_fun.interpret_data_format(
data_tensor=data_tensor,
data_format=data_format)
# Prepare gammanet structure
(
compression,
ff_kernels,
ff_repeats,
features,
fgru_kernels,
additional_readouts) = v2_big_working()
gammanet_constructor = tf_fun.get_gammanet_constructor(
compression=compression,
ff_kernels=ff_kernels,
ff_repeats=ff_repeats,
features=features,
fgru_kernels=fgru_kernels)
aux = get_aux()
# Build model
with tf.variable_scope('gammanet', reuse=reuse):
activity = tf.layers.conv2d(
inputs=data_tensor,
filters=gammanet_constructor[0]['features'],
kernel_size=ff_kernel_size,
padding='same',
data_format=long_data_format,
name='l0_0',
activation=ff_nl,
use_bias=True,
reuse=reuse)
activity = tf.layers.conv2d(
inputs=activity,
filters=gammanet_constructor[0]['features'],
kernel_size=ff_kernel_size,
padding='same',
data_format=long_data_format,
name='l0_1',
activation=ff_nl,
use_bias=True,
reuse=reuse)
activity = normalization.apply_normalization(
activity=activity,
name='input_norm',
normalization_type=output_normalization_type,
data_format=data_format,
training=training,
trainable=training,
reuse=reuse)
activity = tf.layers.max_pooling2d(activity, (2, 2), (2, 2), data_format=long_data_format)
activity = tf.layers.conv2d(
inputs=activity,
filters=gammanet_constructor[0]['features'],
kernel_size=ff_kernel_size,
padding='same',
data_format=long_data_format,
name='l0_2',
activation=ff_nl,
use_bias=True,
reuse=reuse)
# Shift conv-layers to the front
# Run fGRU
gn = gammanet.GN(
layer_name='fgru',
gammanet_constructor=gammanet_constructor,
data_format=data_format,
reuse=reuse,
timesteps=8,
fgru_connectivity='', # 'all_to_all',
additional_readouts=additional_readouts,
fgru_normalization_type=normalization_type,
ff_normalization_type=normalization_type,
horizontal_padding='SAME',
ff_padding='SAME',
ff_nl=ff_nl,
recurrent_ff=True,
horizontal_kernel_initializer=tf_fun.Identity(),
kernel_initializer=tf.initializers.orthogonal(),
gate_initializer=tf.initializers.orthogonal(),
# horizontal_kernel_initializer=tf.contrib.layers.xavier_initializer(),
# kernel_initializer=tf.contrib.layers.xavier_initializer(),
# gate_initializer=tf.contrib.layers.xavier_initializer(),
aux=aux,
strides=[1, 1, 1, 1],
pool_strides=[2, 2],
pool_kernel=[2, 2],
up_kernel=[4, 4],
train=training)
h2, h_deep = gn(X=activity)
# h2 = gn(X=activity)
with tf.variable_scope('cv_readout', reuse=reuse):
# Apply one more normalization
# h_deep = apply_normalization(
# activity=h_deep,
# name='output_normh_deep',
# normalization_type=normalization_type,
# data_format=data_format,
# training=training,
# reuse=reuse)
activity = normalization.apply_normalization(
activity=h2,
name='output_norm',
normalization_type=output_normalization_type,
data_format=data_format,
training=training,
trainable=training,
reuse=reuse)
activity = tf.reduce_max(activity, reduction_indices=[1, 2])
activity = tf.layers.dense(
inputs=activity,
units=output_shape,
activation=None,
use_bias=True,
name='readout_fc_2',
reuse=reuse)
if long_data_format is 'channels_first':
activity = tf.transpose(activity, (0, 2, 3, 1))
extra_activities = {
# 'activity_low': h2,
# 'activity_high': h_deep,
}
if activity.dtype != tf.float32:
activity = tf.cast(activity, tf.float32)
# return [activity, h_deep], extra_activities
return activity, extra_activities