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']
output_shape = 2
# norm_moments_training = training # Force instance norm
# normalization_type = 'no_param_batch_norm_original'
normalization_type = 'no_param_instance_norm'
# output_normalization_type = 'batch_norm_original_renorm'
output_normalization_type = 'instance_norm'
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('vgg', reuse=reuse):
aux = get_aux()
vgg = vgg16.Vgg16(
vgg16_npy_path=
'/media/data_cifs/clicktionary/pretrained_weights/vgg16.npy',
reuse=reuse,
aux=aux,
train=training,
timesteps=8,
fgru_normalization_type=normalization_type,
ff_normalization_type=normalization_type)
vgg(rgb=data_tensor, constructor=gammanet_constructor)
activity = vgg.fgru_0
if long_data_format is 'channels_first':
activity = tf.transpose(activity, (0, 2, 3, 1))
extra_activities = {
"fgru": vgg.fgru_0
} # idx: v for idx, v in enumerate(hs_0)}
if activity.dtype != tf.float32:
activity = tf.cast(activity, tf.float32)
# return [activity, h_deep], extra_activities
return activity, extra_activities
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']
# output_shape = 2
# norm_moments_training = training # Force instance norm
normalization_type = 'no_param_batch_norm_original'
# normalization_type = 'ada_batch_norm'
# normalization_type = 'no_param_instance_norm'
output_normalization_type = 'batch_norm_original_renorm'
# output_normalization_type = 'instance_norm'
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('vgg', reuse=reuse):
aux = get_aux()
vgg = vgg16.Vgg16(
vgg16_npy_path='/media/data_cifs/clicktionary/pretrained_weights/vgg16.npy',
reuse=reuse,
aux=aux,
train=training,
timesteps=8,
fgru_normalization_type=normalization_type,
ff_normalization_type=normalization_type)
vgg(rgb=data_tensor, constructor=gammanet_constructor)
# activity = vgg.fgru_0
with tf.variable_scope('fgru', reuse=reuse):
# Get side weights
activity = normalization.batch(
bottom=vgg.fgru_0, # activity,
renorm=True,
name='readout_0_bn',
training=training)
# activity = normalization.group(
# bottom=vgg.fgru_0) # , # activity,
# # name='readout_0_bn')
prepool_activity = tf.layers.conv2d(
inputs=activity,
filters=output_shape, # int(activity.get_shape()[-1]),
kernel_size=1,
name='pre_readout_conv0',
strides=(1, 1),
padding='same',
activation=tf.nn.elu,
trainable=training,
use_bias=True)
"""
prepool_activity = normalization.batch(
bottom=prepool_activity,
renorm=True,
name='readout_1_bn',
training=False) # training)
"""
"""
prepool_activity = tf.layers.conv2d(
inputs=prepool_activity,
filters=output_shape,
kernel_size=1,
name='pre_readout_conv1',
strides=(1, 1),
padding='same',
activation=None,
trainable=training,
use_bias=True)
"""
out_activity = tf.reduce_max(prepool_activity, reduction_indices=[1, 2])
activity = tf.layers.dense(
inputs=out_activity,
units=output_shape)
if long_data_format is 'channels_first':
activity = tf.transpose(activity, (0, 2, 3, 1))
# extra_activities = {'orientations': orientations, 'model_output_y': vgg.fgru_0, 'model_output_x': vgg.fgru_0_init}
extra_activities = {'x': vgg.fgru_0}
if activity.dtype != tf.float32:
activity = tf.cast(activity, tf.float32)
# return [activity, h_deep], extra_activities
return activity, extra_activities
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']
# norm_moments_training = training # Force instance norm
# normalization_type = 'no_param_batch_norm_original'
normalization_type = 'no_param_instance_norm'
# output_normalization_type = 'batch_norm_original_renorm'
output_normalization_type = 'instance_norm'
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('vgg', reuse=reuse):
aux = get_aux()
vgg = vgg16.Vgg16(
vgg16_npy_path=
'/media/data_cifs/clicktionary/pretrained_weights/vgg16.npy',
reuse=reuse,
aux=aux,
train=training,
timesteps=8,
fgru_normalization_type=normalization_type,
ff_normalization_type=normalization_type)
vgg(rgb=data_tensor, constructor=gammanet_constructor)
# activity = vgg.fgru_0
with tf.variable_scope('fgru', reuse=reuse):
# Get side weights
h2_rem = [vgg.fgru_0, vgg.fgru_1, vgg.fgru_2]
reses = []
for idx, h in enumerate(h2_rem):
res = normalization.apply_normalization(
activity=h,
name='output_norm1_%s' % idx,
normalization_type=output_normalization_type,
data_format=data_format,
training=training,
trainable=training,
reuse=reuse)
res = aux['image_resize'](res,
data_tensor.get_shape().as_list()[1:3],
align_corners=True)
reses += [res]
activity = tf.layers.conv2d(
tf.concat(reses, -1),
filters=output_shape,
kernel_size=(1, 1),
padding='same',
data_format=long_data_format,
name='out',
# activation=tf.nn.relu,
activation=None,
trainable=training,
use_bias=True,
# use_bias=False,
reuse=reuse)
if long_data_format is 'channels_first':
activity = tf.transpose(activity, (0, 2, 3, 1))
extra_activities = {} # idx: v for idx, v in enumerate(hs_0)}
if activity.dtype != tf.float32:
activity = tf.cast(activity, tf.float32)
# return [activity, h_deep], extra_activities
return activity, extra_activities
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']
output_shape = 1
# norm_moments_training = training # Force instance norm
# normalization_type = 'no_param_batch_norm_original'
normalization_type = 'no_param_instance_norm'
# output_normalization_type = 'batch_norm_original_renorm'
output_normalization_type = 'instance_norm'
# data_tensor = tf.concat((data_tensor, data_tensor, data_tensor), -1) # Expand to 3D
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('vgg', reuse=reuse):
aux = get_aux()
vgg = vgg16.Vgg16(
vgg16_npy_path=
'/media/data_cifs/clicktionary/pretrained_weights/vgg16.npy',
reuse=reuse,
aux=aux,
train=False, # training,
timesteps=8,
fgru_normalization_type=normalization_type,
ff_normalization_type=normalization_type)
vgg(rgb=data_tensor, constructor=gammanet_constructor)
# activity = vgg.fgru_0
with tf.variable_scope('fgru', reuse=reuse):
# Get side weights
h2_rem = [vgg.fgru_0, vgg.fgru_1, vgg.fgru_2]
activities = []
for idx, h in enumerate(h2_rem):
# res = normalization.apply_normalization(
# activity=h,
# name='output_norm1_%s' % idx,
# normalization_type=output_normalization_type,
# data_format=data_format,
# training=False,
# trainable=False,
# reuse=reuse)
activities.append(aux['image_resize'](
h, vgg.fgru_0.get_shape().as_list()[1:3], align_corners=True))
activity = tf.concat(activities, -1)
# Then read out
# activity = normalization.apply_normalization(
# activity=res,
# name='output_norm1',
# normalization_type=output_normalization_type,
# data_format=data_format,
# training=training,
# trainable=training,
# reuse=reuse)
with tf.variable_scope('readout', reuse=reuse):
activity = normalization.batch(bottom=activity,
renorm=False,
name='hgru_bn',
training=training)
activity = conv.readout_layer(activity=activity,
reuse=reuse,
training=training,
output_shape=output_shape)
if long_data_format is 'channels_first':
activity = tf.transpose(activity, (0, 2, 3, 1))
# extra_activities = {'orientations': orientations, 'model_output_y': vgg.fgru_0, 'model_output_x': vgg.fgru_0_init}
extra_activities = {}
if activity.dtype != tf.float32:
activity = tf.cast(activity, tf.float32)
# return [activity, h_deep], extra_activities
return activity, extra_activities
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']
# norm_moments_training = training # Force instance norm
# normalization_type = 'no_param_batch_norm_original'
normalization_type = 'no_param_instance_norm'
# output_normalization_type = 'batch_norm_original_renorm'
output_normalization_type = 'instance_norm'
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('vgg', reuse=reuse):
aux = get_aux()
vgg = vgg16.Vgg16(
vgg16_npy_path=
'/media/data_cifs/clicktionary/pretrained_weights/vgg16.npy',
reuse=reuse,
aux=aux,
train=False, # training,
timesteps=8,
train_norm_moments=training,
train_norm_params=training,
fgru_normalization_type=normalization_type,
ff_normalization_type=normalization_type)
activity = vgg(rgb=data_tensor,
constructor=gammanet_constructor,
store_timesteps=True)
activity = tf.stack(activity, 0)
# activity = vgg.fgru_0
with tf.variable_scope('fgru', reuse=reuse):
# Get side weights
res = normalization.apply_normalization(
activity=activity,
name='output_norm1_%s' % 0,
normalization_type=output_normalization_type,
data_format=data_format,
training=training,
trainable=training,
reuse=reuse)
res_images = []
for ri in range(activity.get_shape().as_list()[0]):
res_images.append(aux['image_resize'](
res[ri],
data_tensor.get_shape().as_list()[1:3],
align_corners=True))
res = tf.stack(res_images, 0)
with tf.variable_scope('readout', reuse=reuse):
activity = tf.layers.conv3d(
inputs=res,
filters=gammanet_constructor[0]['features'],
kernel_size=(1, 1, 1),
padding='same',
data_format=long_data_format,
name='readout_l0_1',
activation=None,
use_bias=True,
trainable=training,
reuse=reuse)
activity = tf.nn.relu(activity)
activity = normalization.apply_normalization(
activity=activity,
name='output_norm_final_%s' % 1,
normalization_type=output_normalization_type,
data_format=data_format,
training=training,
trainable=training,
reuse=reuse)
activity = tf.layers.conv3d(inputs=activity,
filters=output_shape,
kernel_size=(1, 1, 1),
padding='same',
data_format=long_data_format,
name='readout_l0_2',
activation=tf.nn.relu,
use_bias=True,
trainable=training,
reuse=reuse)
activity = activity[-1]
activity = tf.layers.conv2d(inputs=activity,
filters=output_shape,
kernel_size=(1, 1),
padding='same',
data_format=long_data_format,
name='readout_l0_3',
activation=None,
use_bias=True,
trainable=training,
reuse=reuse)
if long_data_format is 'channels_first':
activity = tf.transpose(activity, (0, 2, 3, 1))
extra_activities = {} # 'orientations': orientations}
if activity.dtype != tf.float32:
activity = tf.cast(activity, tf.float32)
# return [activity, h_deep], extra_activities
return activity, extra_activities
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']
# norm_moments_training = training # Force instance norm
# normalization_type = 'no_param_batch_norm_original'
normalization_type = 'no_param_instance_norm'
# output_normalization_type = 'batch_norm_original_renorm'
output_normalization_type = 'instance_norm'
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('vgg', reuse=reuse):
aux = get_aux()
vgg = vgg16.Vgg16(
vgg16_npy_path=
'/media/data_cifs/clicktionary/pretrained_weights/vgg16.npy',
reuse=reuse,
aux=aux,
train=False,
timesteps=8,
fgru_normalization_type=normalization_type,
ff_normalization_type=normalization_type)
vgg(rgb=data_tensor, constructor=gammanet_constructor)
activity = vgg.fgru_0
with tf.variable_scope('fgru_gilbert', reuse=reuse):
# Then read out
# activity = activity ** 2
activity = normalization.apply_normalization(
activity=activity,
name='output_norm1',
normalization_type=output_normalization_type,
data_format=data_format,
training=training,
trainable=training,
reuse=reuse)
activity = tf.layers.conv2d(
inputs=activity,
filters=gammanet_constructor[0]['features'],
kernel_size=(1, 1),
padding='same',
data_format=long_data_format,
name='readout_l0_1',
activation=tf.nn.relu,
use_bias=True,
trainable=training,
reuse=reuse)
activity = tf.layers.conv2d(inputs=activity,
filters=1,
kernel_size=(1, 1),
padding='same',
data_format=long_data_format,
name='readout_l0_2',
activation=None,
use_bias=True,
trainable=training,
reuse=reuse)
activity = tf.reduce_max(activity, reduction_indices=[1, 2])
if long_data_format is 'channels_first':
activity = tf.transpose(activity, (0, 2, 3, 1))
extra_activities = {}
if activity.dtype != tf.float32:
activity = tf.cast(activity, tf.float32)
# return [activity, h_deep], extra_activities
return activity, extra_activities
