def __init__(
self,
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,
# Resnet args
num_classes=1000,
num_filters=64,
kernel_size=7,
conv_stride=2,
first_pool_size=3,
first_pool_stride=2,
second_pool_size=7,
second_pool_stride=1,
resnet_size=18,
block_strides=[1, 2, 2, 2],
apply_to='input',
extra_convs=1,
squash=tf.sigmoid,
output_layer='final_dense',
prelogit_layer='prelogits',
human_score_layer='final_avg_pool',
probability_layer='prob'):
"""Creates a model for classifying an image.
Args:
resnet_size: A single integer for the size of the ResNet model.
num_classes: The number of classes used as labels.
num_filters: The number of filters to use for the first block layer
of the model. This number is then doubled for each subsequent
block layer.
kernel_size: The kernel size to use for convolution.
conv_stride: stride size for the initial convolutional layer
first_pool_size: Pool size to be used for the first pooling layer.
If none, the first pooling layer is skipped.
first_pool_stride: stride size for the first pooling layer. Not
used if first_pool_size is None.
second_pool_size: Pool size to be used for the second pooling
layer.
second_pool_stride: stride size for the final pooling layer
block_fn: Which block layer function should be used? Pass in one of
the two functions defined above: building_block or
bottleneck_block
block_sizes: A list containing n values, where n is the number of
sets of block layers desired. Each value should be the number
of blocks in the i-th set.
block_strides: List of integers representing the desired stride
size for each of the sets of block layers. Should be same
length as block_sizes.
final_size: The expected size of the model after the second
pooling.
data_format: Input format ('channels_last', 'channels_first', or
None). If set to None, the format is dependent on whether a GPU
is available.
"""
# fGRU argments
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.reuse = reuse
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:
raise NotImplementedError
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('_')
# Set initializers for greek letters
if self.force_alpha_divisive:
self.alpha_initializer = tf.initializers.variance_scaling
else:
self.alpha_initializer = tf.constant_initializer(0.1)
self.mu_initializer = tf.constant_initializer(0.)
self.omega_initializer = tf.constant_initializer(0.1)
self.kappa_initializer = tf.constant_initializer(0.)
# Handle BN scope reuse
self.scope_reuse = reuse
# Resnet arguments
self.resnet_size = resnet_size
block_sizes = _get_block_sizes(resnet_size)
attention_blocks = _get_attention_sizes(resnet_size)
data_format = 'channels_last'
# For bigger models, we want to use "bottleneck" layers
if resnet_size < 50:
block_fn = self.building_block
final_size = 512
else:
block_fn = self.bottleneck_block
final_size = 2048
self.data_format = data_format
self.num_classes = num_classes
self.num_filters = num_filters
self.kernel_size = kernel_size
self.conv_stride = conv_stride
self.first_pool_size = first_pool_size
self.first_pool_stride = first_pool_stride
self.second_pool_size = second_pool_size
self.second_pool_stride = second_pool_stride
self.block_fn = block_fn
self.block_sizes = block_sizes
self.attention_blocks = attention_blocks
self.block_strides = block_strides
self.final_size = final_size
self.output_layer = output_layer
self.probability_layer = probability_layer
self.prelogit_layer = prelogit_layer
self.apply_to = apply_to
self.trainable = train
self.squash = squash
self.extra_convs = extra_convs
self.attention_losses = []
self.VGG_MEAN = [103.939, 116.779, 123.68]
if isinstance(self.squash, basestring):
self.squash = interpret_nl(self.squash)
def __init__(
self,
vgg16_npy_path,
train,
timesteps,
reuse,
fgru_normalization_type,
ff_normalization_type,
perturb=None,
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,
downsampled=False,
up_kernel=None,
stop_loop=False,
recurrent_ff=False,
perturb_method="hidden_state", # "kernel"
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.reuse = reuse
self.timesteps = timesteps
self.downsampled = downsampled
self.last_timestep = timesteps - 1
self.perturb = perturb
self.perturb_method = perturb_method
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:
raise NotImplementedError
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.constant_initializer(0.1)
self.mu_initializer = tf.constant_initializer(0.)
self.omega_initializer = tf.constant_initializer(0.1)
self.kappa_initializer = tf.constant_initializer(0.)
# Handle BN scope reuse
self.scope_reuse = reuse
# Load weights
self.data_dict = np.load(vgg16_npy_path,
allow_pickle=True,
encoding='latin1').item()
print("npy file loaded")
def __init__(
self,
layer_name,
gammanet_constructor,
fgru_normalization_type,
ff_normalization_type,
train,
reuse,
fgru_connectivity,
ff_nl=tf.nn.relu,
additional_readouts=None,
horizontal_kernel_initializer=tf.initializers.variance_scaling(),
kernel_initializer=tf.initializers.variance_scaling(),
gate_initializer=tf.contrib.layers.xavier_initializer(),
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,
timesteps=1,
strides=[1, 1, 1, 1],
pool_strides=[2, 2],
pool_kernel=[4, 4],
data_format='NHWC',
horizontal_padding='SAME',
ff_padding='SAME',
aux=None):
"""Global initializations and settings."""
self.timesteps = timesteps
self.strides = strides
self.pool_strides = pool_strides
self.pool_kernel = pool_kernel
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.additional_readouts = additional_readouts
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 = fgru_connectivity
self.gammanet_constructor = gammanet_constructor
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
if up_kernel is None:
self.up_kernel = [
h + w for h, w in zip(self.pool_strides, self.pool_kernel)
]
print 'No up-kernel provided. Derived: %s' % self.up_kernel
else:
self.up_kernel = up_kernel
# Sort through and assign the auxilliary variables
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)
if self.time_skips:
self.conv_dict = OrderedDict()
# 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.initializers.variance_scaling
self.omega_initializer = tf.ones_initializer
self.kappa_initializer = tf.zeros_initializer
# Handle BN scope reuse
self.scope_reuse = reuse
