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