def build(self, input_shape): input_shape = tensor_shape.TensorShape(input_shape).as_list() if len(input_shape) < 3: raise ValueError( '`TimeDistributed` Layer should be passed an `input_shape ` ' 'with at least 3 dimensions, received: ' + str(input_shape)) # Don't enforce the batch or time dimension. self.input_spec = InputSpec(shape=[None, None] + input_shape[2:]) child_input_shape = [input_shape[0]] + input_shape[2:] super(TimeDistributed, self).build(tuple(child_input_shape)) self.built = True
def __init__(self, units, mask, activation=None, use_bias=True, **kwargs): if 'input_shape' not in kwargs and 'input_dim' in kwargs: kwargs['input_shape'] = (kwargs.pop('input_dim'), ) # each instance of the class will have all of these attributes self.mask_tensor = mask self.activation = activations.get(activation) self.units = units self.use_bias = use_bias self.input_spec = InputSpec(min_ndim=2) super(MaskedDense, self).__init__(**kwargs)
def __init__(self, height, width, interpolation='bilinear', name=None, **kwargs): self.target_height = height self.target_width = width self.interpolation = interpolation self._interpolation_method = get_interpolation(interpolation) self.input_spec = InputSpec(ndim=4) super(Resizing, self).__init__(name=name, **kwargs)
def __init__(self, horizontal=None, vertical=None, seed=None, **kwargs): # If both arguments are None, set both to True. if horizontal is None and vertical is None: self.horizontal = True self.vertical = True else: self.horizontal = horizontal or False self.vertical = vertical or False self.seed = seed self._rng = make_generator(self.seed) self.input_spec = InputSpec(ndim=4) super(RandomFlip, self).__init__(**kwargs)
def __init__(self, cell, # Normal RNN cell output_layer, # Output layer turning the RNN cell into the desired output dim likelihood_fn, # Likelihood function used for computing gradients niter, # Number of iterations to run the RIM for **kwargs): super(self.__class__, self).__init__(cell, **kwargs) self.output_layer = output_layer self.likelihood_fn = likelihood_fn self.niter = niter self.input_spec = [InputSpec(ndim=5)]
def build(self, input_shape): input_shape = tensor_shape.TensorShape(input_shape) input_channel = self._get_input_channel(input_shape) if input_channel % self.groups != 0: raise ValueError( 'The number of input channels must be evenly divisible by the number ' 'of groups. Received groups={}, but the input has {} channels ' '(full input shape is {}).'.format(self.groups, input_channel, input_shape)) kernel_shape = self.kernel_size + ( input_channel // self.groups, self.filters, ) self.kernel = self.add_weight( name='kernel', shape=kernel_shape, initializer=self.kernel_initializer, regularizer=self.kernel_regularizer, constraint=self.kernel_constraint, trainable=True, dtype=self.dtype, ) if self.use_bias: self.bias = self.add_weight( name='bias', shape=(self.filters, ), initializer=self.bias_initializer, regularizer=self.bias_regularizer, constraint=self.bias_constraint, trainable=True, dtype=self.dtype, ) else: self.bias = None channel_axis = self._get_channel_axis() self.input_spec = InputSpec(ndim=self.rank + 2, axes={channel_axis: input_channel}) self._build_conv_op_input_shape = input_shape self._build_input_channel = input_channel self._padding_op = self._get_padding_op() self._conv_op_data_format = conv_utils.convert_data_format( self.data_format, self.rank + 2) self._convolution_op = Convolution( input_shape, filter_shape=self.kernel.shape, dilation_rate=self.dilation_rate, strides=self.strides, padding=self._padding_op, data_format=self._conv_op_data_format, ) self.built = True
def __init__(self, factor, seed=None, name=None, **kwargs): self.factor = factor if isinstance(factor, (tuple, list)): self.lower = factor[0] self.upper = factor[1] else: self.lower = self.upper = factor if self.lower < 0. or self.upper < 0. or self.lower > 1.: raise ValueError('Factor cannot have negative values, ' 'got {}'.format(factor)) self.seed = seed self.input_spec = InputSpec(ndim=4) super(RandomContrast, self).__init__(name=name, **kwargs)
def __init__(self, elementwise=False, name=None, **kwargs): super(AutoAugment, self).__init__(name=name, **kwargs) self.elementwise = elementwise self.transforms = [ tf.keras.Sequential([ augmentations.RandomChance(_get_transform(t1, m1), p1), augmentations.RandomChance(_get_transform(t2, m2), p2), ]) for (t1, p1, m1), (t2, p2, m2) in _AUTO_AUGMENT_POLICY_V0 ] self._transform = augmentations.RandomChoice(self.transforms, n_transforms=1, elementwise=elementwise) self.input_spec = InputSpec(ndim=4, dtype=tf.uint8)
def __init__(self, factor, seed=random.randint(0,1000), name=None, **kwargs): self.factor = factor if isinstance(factor, (tuple, list)): self.lower = factor[0] self.upper = factor[1] else: self.lower = self.upper = factor if self.lower < 0. or self.upper < 0. or self.lower > 1.: raise ValueError('Factor cannot have negative values or greater than 1.0,' ' got {}'.format(factor)) self.seed = seed self.input_spec = InputSpec(ndim=4) super(RandomBrightness, self).__init__(name=name, **kwargs)
def __init__(self, level, interpolation="nearest", fill_mode="constant", fill_value=0.0, name=None, **kwargs): super(ShearY, self).__init__(name=name, **kwargs) self.level = level self.interpolation = interpolation self.fill_mode = fill_mode self.fill_value = fill_value self.input_spec = InputSpec(ndim=4)
def __init__(self, pixels, interpolation="nearest", fill_mode="constant", fill_value=0.0, name=None, **kwargs): super(TranslateY, self).__init__(name=name, **kwargs) self.pixels = pixels self.interpolation = interpolation self.fill_mode = fill_mode self.fill_value = fill_value self.input_spec = InputSpec(ndim=4)
def build(self, input_shape): input_shape = tensor_shape.TensorShape(input_shape).as_list() assert len(input_shape) >= 3 self.input_spec = InputSpec(shape=input_shape) child_input_shape = [input_shape[0]] + input_shape[2:] if not self.layer.built: # The base layer class calls a conversion function on the input shape to # convert it to a TensorShape. The conversion function requires a # tuple which is why we cast the shape. self.layer.build(tuple(child_input_shape)) self.layer.built = True super(TimeDistributed, self).build() self.built = True
def __init__(self, num_templates=10, **kwargs): WeightedMixIn.__init__(self) new_kwargs = kwargs.copy() new_kwargs["center"] = False new_kwargs["scale"] = False BatchNormalization.__init__(self, **new_kwargs) self.num_templates = num_templates if "scale" not in kwargs or kwargs["scale"]: self.add_template_variable(weight_name="template_gamma") if "center" not in kwargs or kwargs["center"]: self.add_template_variable(weight_name="template_beta") mixture_input_spec = InputSpec(ndim=1) self.input_spec = (self.input_spec, mixture_input_spec)
def __init__(self, max_tokens=None, output_mode=BINARY, sparse=False, **kwargs): # 'output_mode' must be one of (COUNT, BINARY, TFIDF) layer_utils.validate_string_arg( output_mode, allowable_strings=(COUNT, BINARY, TFIDF), layer_name="CategoryEncoding", arg_name="output_mode") # If max_tokens is set, the value must be greater than 1 - otherwise we # are creating a 0-element vocab, which doesn't make sense. if max_tokens is not None and max_tokens < 1: raise ValueError("max_tokens must be > 1.") # We need to call super() before we call _add_state_variable(). combiner = _CategoryEncodingCombiner( max_tokens=max_tokens, compute_idf=output_mode == TFIDF) super(CategoryEncoding, self).__init__(combiner=combiner, **kwargs) base_preprocessing_layer.keras_kpl_gauge.get_cell( "CategoryEncoding").set(True) self.max_tokens = max_tokens self.output_mode = output_mode self.sparse = sparse self._called = False if self.output_mode == TFIDF: # The TF-IDF weight may have a (None,) tensorshape. This creates # a 1D variable with arbitrary shape, which we can assign any weight to # so long as it has 1 dimension. In order to properly initialize this # weight in Keras, we need to provide a custom callable initializer which # does not depend on the shape of the weight (as all other initializers # do) since the weight is not known. Hence the lambda shape, dtype: [0]. if max_tokens is None: initializer = lambda shape, dtype: [0] else: initializer = init_ops.zeros_initializer # We are adding these here instead of in build() since they do not depend # on the input shape at all. self.tf_idf_weights = self._add_state_variable( name=_IDF_NAME, shape=tensor_shape.TensorShape((max_tokens,)), dtype=K.floatx(), initializer=initializer) self.input_spec = InputSpec(ndim=2)
def build(self, input_shape): dtype = dtypes.as_dtype(self.dtype or K.floatx()) if not (dtype.is_floating or dtype.is_complex): raise TypeError( 'Unable to build `Dense_plasticity` layer with non-floating point ' 'dtype %s' % (dtype, )) input_shape = tensor_shape.TensorShape(input_shape) if tensor_shape.dimension_value(input_shape[-1]) is None: raise ValueError( 'The last dimension of the inputs to `Dense_plasticity` ' 'should be defined. Found `None`.') last_dim = tensor_shape.dimension_value(input_shape[-1]) self.input_spec = InputSpec(min_ndim=2, axes={-1: last_dim}) self.kernel = self.add_weight('kernel', shape=[last_dim, self.units], initializer=self.kernel_initializer, regularizer=self.kernel_regularizer, constraint=self.kernel_constraint, dtype=self.dtype, trainable=True) #plasticity self.kernel_p = self.add_weight( 'kernel_p', shape=[last_dim, self.units], initializer=keras.initializers.Constant(), regularizer=self.kernel_regularizer, constraint=self.kernel_constraint, dtype=self.dtype, trainable=True) self.hebb = self.add_weight('hebb', shape=[last_dim, self.units], initializer=self.kernel_initializer, regularizer=self.kernel_regularizer, constraint=self.kernel_constraint, dtype=self.dtype, trainable=False) if self.use_bias: self.bias = self.add_weight('bias', shape=[ self.units, ], initializer=self.bias_initializer, regularizer=self.bias_regularizer, constraint=self.bias_constraint, dtype=self.dtype, trainable=True) else: self.bias = None self.built = True
def __init__(self, rank, filters, kernel_size, strides=1, padding='valid', data_format=None, dilation_rate=1, activation=None, is_mc=True, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, trainable=True, name=None, **kwargs): super(VWNConv, self).__init__( trainable=trainable, name=name, activity_regularizer=regularizers.get(activity_regularizer), **kwargs) self.rank = rank self.filters = filters self.kernel_size = conv_utils.normalize_tuple(kernel_size, rank, 'kernel_size') self.strides = conv_utils.normalize_tuple(strides, rank, 'strides') self.padding = conv_utils.normalize_padding(padding) if (self.padding == 'causal' and not isinstance(self, (Conv1D, SeparableConv1D))): raise ValueError('Causal padding is only supported for `Conv1D`' 'and ``SeparableConv1D`.') self.data_format = conv_utils.normalize_data_format(data_format) self.dilation_rate = conv_utils.normalize_tuple( dilation_rate, rank, 'dilation_rate') self.is_mc = tf.cast(is_mc, dtype=tf.bool) self.activation = activations.get(activation) self.use_bias = use_bias self.kernel_initializer = initializers.get(kernel_initializer) self.bias_initializer = initializers.get(bias_initializer) self.kernel_regularizer = regularizers.get(kernel_regularizer) self.bias_regularizer = regularizers.get(bias_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.bias_constraint = constraints.get(bias_constraint) self.input_spec = InputSpec(ndim=self.rank + 2) self.a_initializer = initializers.Constant( 1e-04) # ADDED (what is a) (use keras initializers??)
def __init__(self, units, rate=1e-2, activation=selu(input), kernel_initializer='lecun_uniform', **kwargs): if 'input_shape' not in kwargs and 'input_dim' in kwargs: kwargs['input_shape'] = (kwargs.pop('input_dim'),) super(SNNDense, self).__init__() self.units = int(units) if not isinstance(units, int) else units self.activation = activations.get(activation) self.kernel_initializer = initializers.get(kernel_initializer) self.input_spec = InputSpec(min_ndim=2)
def build(self, input_shape): dtype = dtypes.as_dtype(self.dtype or k.floatx()) if not (dtype.is_floating or dtype.is_complex): raise TypeError('Unable to build `NoisyDense` layer with non-floating point' 'dtype %s' % (dtype,)) input_shape = tensor_shape.TensorShape(input_shape) if tensor_shape.dimension_value(input_shape[-1]) is None: raise ValueError('The last dimension of the inputs to `NoisyDense` ' 'should be defined. Found `None`.') last_dim = tensor_shape.dimension_value(input_shape[-1]) self.input_spec = InputSpec(min_ndim=2, axes={-1: last_dim}) if self.std_func is None: std = math.sqrt(3 / input_shape[-1]) else: std = self.std_func(input_shape[-1]) if self.sigma_func is not None: sigma_init = self.sigma_func(self.sigma_init, input_shape[-1]) else: sigma_init = self.sigma_init self.mu_weights = self.add_weight( 'mu_weights', shape=[last_dim, self.units], initializer=initializers.RandomUniform(minval=-std, maxval=std), regularizer=self.kernel_regularizer, constraint=self.kernel_constraint, dtype=self.dtype, trainable=True) self.sigma_weights = self.add_weight( 'sigma_weights', shape=[last_dim, self.units], initializer=initializers.Constant(value=sigma_init), dtype=self.dtype, trainable=True) if self.use_bias: self.mu_bias = self.add_weight( 'mu_bias', shape=[self.units, ], initializer=initializers.RandomUniform(minval=-std, maxval=std), regularizer=self.bias_regularizer, constraint=self.bias_constraint, dtype=self.dtype, trainable=True) self.sigma_bias = self.add_weight( 'sigma_bias', shape=[self.units, ], initializer=initializers.Constant(value=sigma_init), dtype=self.dtype, trainable=True) self.built = True
def __init__(self, pool_function, pool_size, strides, padding='valid', data_format='channels_last', name=None, **kwargs): super(Pooling1D, self).__init__(name=name, **kwargs) if data_format is None: data_format = backend.image_data_format() if strides is None: strides = pool_size self.pool_function = pool_function self.pool_size = conv_utils.normalize_tuple(pool_size, 1, 'pool_size') self.strides = conv_utils.normalize_tuple(strides, 1, 'strides') self.padding = conv_utils.normalize_padding(padding) self.data_format = conv_utils.normalize_data_format(data_format) self.input_spec = InputSpec(ndim=3)
def __init__(self, degrees, interpolation="nearest", fill_mode="constant", fill_value=0.0, name=None, **kwargs): super(Rotate, self).__init__(name=name, **kwargs) self.degrees = degrees self.interpolation = interpolation self.fill_mode = fill_mode self.fill_value = fill_value self._radians = degrees * math.pi / 180.0 self.input_spec = InputSpec(ndim=4)
def __init__(self, units, learning_rate=0.01, online=True, n_passes=1, return_hidden=True, use_bias=True, visible_activation='sigmoid', hidden_activation='sigmoid', kernel_initializer='glorot_uniform', bias_initializer='glorot_uniform', kernel_regularizer='l2', bias_regularizer='l2', activity_regularizer='l2', # kernel_constraint=None, kernel_constraint=constraints.MinMaxNorm( min_value=-1.0, max_value=1.0, rate=1.0, axis=-1 ), # bias_constraint=None, bias_constraint=constraints.MinMaxNorm( min_value=-1.0, max_value=1.0, rate=1.0, axis=-1 ), optimizer='Adam', ** kwargs): if 'input_shape' not in kwargs and 'input_dim' in kwargs: kwargs['input_shape'] = (kwargs.pop('input_dim'),) super(OnlineBolzmannCell, self).__init__( activity_regularizer=regularizers.get(activity_regularizer), **kwargs) self.units = units self.learning_rate = learning_rate self.online = online self.return_hidden = return_hidden self.visible_activation = activations.get(visible_activation) self.hidden_activation = activations.get(hidden_activation) self.use_bias = use_bias self.kernel_initializer = initializers.get(kernel_initializer) self.bias_initializer = initializers.get(bias_initializer) self.kernel_regularizer = regularizers.get(kernel_regularizer) self.bias_regularizer = regularizers.get(bias_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.bias_constraint = constraints.get(bias_constraint) self.optimizer = optimizers.get(optimizer) self.optimizer.learning_rate = self.learning_rate self.n_passes = n_passes self.supports_masking = True self.input_spec = InputSpec(min_ndim=2)
def __init__(self, units, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, activations_datatype_size_byte=1, weights_datatype_size_byte=1, results_datatype_size_byte=4, systolic_array_height=256, systolic_array_width=256, activation_fifo_depth=8, accumulator_array_height=4096, log_file_output_dir='.', model_name='unnamed', **kwargs): if 'input_shape' not in kwargs and 'input_dim' in kwargs: kwargs['input_shape'] = (kwargs.pop('input_dim'), ) super(mpusim_fc_base, self).__init__( activity_regularizer=regularizers.get(activity_regularizer), **kwargs) self.units = int(units) self.activation = activations.get(activation) self.use_bias = use_bias self.kernel_initializer = initializers.get(kernel_initializer) self.bias_initializer = initializers.get(bias_initializer) self.kernel_regularizer = regularizers.get(kernel_regularizer) self.bias_regularizer = regularizers.get(bias_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.bias_constraint = constraints.get(bias_constraint) self.supports_masking = True self.input_spec = InputSpec(min_ndim=2) self.activations_datatype_size_byte = activations_datatype_size_byte self.weights_datatype_size_byte = weights_datatype_size_byte self.results_datatype_size_byte = results_datatype_size_byte self.systolic_array_height = systolic_array_height self.systolic_array_width = systolic_array_width self.activation_fifo_depth = activation_fifo_depth self.accumulator_array_height = accumulator_array_height self.log_file_output_dir = log_file_output_dir self.model_name = model_name
def build(self, input_shape): input_shape = tensor_shape.TensorShape(input_shape) input_channel = self._get_input_channel(input_shape) kernel_shape = self.kernel_size + (input_channel, self.filters) self.kernel_weights = self.add_weight( name='kernel_weights', shape=kernel_shape, initializer=tf.random_normal_initializer(mean=0.0, stddev=0.05), regularizer=self.kernel_regularizer, constraint=self.kernel_constraint, trainable=True, dtype=self.dtype) self.kernel_log_scale = self.add_weight(name='kernel_log_scale', shape=(1, 1, 1, self.filters), initializer=tf.constant_initializer(value=0.), regularizer=None, constraint=None, trainable=True, dtype=self.dtype) if self.use_bias: self.bias = self.add_weight( name='bias', shape=(self.filters,), initializer=self.bias_initializer, regularizer=self.bias_regularizer, constraint=self.bias_constraint, trainable=True, dtype=self.dtype) else: self.bias = None channel_axis = self._get_channel_axis() self.input_spec = InputSpec(ndim=self.rank + 2, axes={channel_axis: input_channel}) self._build_conv_op_input_shape = input_shape self._build_input_channel = input_channel self._padding_op = self._get_padding_op() self._conv_op_data_format = conv_utils.convert_data_format( self.data_format, self.rank + 2) self._convolution_op = nn_ops.Convolution( input_shape, filter_shape=self.kernel.shape, dilation_rate=self.dilation_rate, strides=self.strides, padding=self._padding_op, data_format=self._conv_op_data_format) self.built = True
def build(self, input_shape): dtype = dtypes.as_dtype(self.dtype or tfk.backend.floatx()) if not (dtype.is_floating or dtype.is_complex): raise TypeError( 'Unable to build `Dense` layer with non-floating point ' 'dtype %s' % (dtype, )) input_shape = tensor_shape.TensorShape(input_shape) if tensor_shape.dimension_value(input_shape[-1]) is None: raise ValueError('The last dimension of the inputs to `Dense` ' 'should be defined. Found `None`.') last_dim = tensor_shape.dimension_value(input_shape[-1]) self.input_spec = InputSpec(min_ndim=2, axes={-1: last_dim}) self.kernel = self.build_kernel(shape=[last_dim, self.units]) self.build_bias(self.units) self.built = True
def __init__(self, min_side=None, max_side=None, interpolation="bilinear", name=None, **kwargs): super(ResizingMinMax, self).__init__(name=name, **kwargs) if min_side is None and max_side is None: raise ValueError("Must specify either 'min_side' or 'max_side'.") self.min_side = min_side self.max_side = max_side self.interpolation = interpolation self.input_spec = InputSpec(ndim=4)
def build(self, two_input_shapes): [input_shape_targets, input_shape_main] = two_input_shapes input_shape_main = tensor_shape.TensorShape(input_shape_main) input_channel = self._get_input_channel(input_shape_main) kernel_shape = self.kernel_size + (input_channel, self.filters) channel_axis = self._get_channel_axis() self.input_spec = (InputSpec(ndim=self.rank + 2, axes={channel_axis: input_channel}), InputSpec(ndim=self.rank + 2, axes={channel_axis: input_channel})) self._build_conv_op_input_shape = input_shape_main self._build_input_channel = input_channel self._padding_op = self._get_padding_op() self._conv_op_data_format = conv_utils.convert_data_format( self.data_format, self.rank + 2) self._convolution_op = nn_ops.Convolution( input_shape_main, filter_shape=tensor_shape.TensorShape(kernel_shape), dilation_rate=self.dilation_rate, strides=self.strides, padding=self._padding_op, data_format=self._conv_op_data_format) self.image_height = input_shape_main[1] self.image_width = input_shape_main[2] self.input_channels = input_shape_main[3] num_patches = self.image_width * self.image_height self.num_patches = num_patches self.target_matrix = self.add_weight( 'target_matrix', shape=[self.realisation_batch_size * num_patches, self.filters], initializer=self.kernel_initializer, regularizer=self.kernel_regularizer, constraint=self.kernel_constraint, dtype=self.dtype, trainable=True) self.built = True
def build(self, input_shape): input_shape = tf_utils.convert_shapes(input_shape, to_tuples=False) input_dims = nest.flatten( nest.map_structure(lambda x: x.ndims, input_shape)) if any(dim < 3 for dim in input_dims): raise ValueError( '`TimeDistributed` Layer should be passed an `input_shape ` ' 'with at least 3 dimensions, received: ' + str(input_shape)) # Don't enforce the batch or time dimension. self.input_spec = nest.map_structure( lambda x: InputSpec(shape=[None, None] + x.as_list()[2:]), input_shape) child_input_shape = nest.map_structure(self._remove_timesteps, input_shape) child_input_shape = tf_utils.convert_shapes(child_input_shape) super(TimeDistributed, self).build(tuple(child_input_shape)) self.built = True
def __init__(self, height_factor, width_factor, fill_mode='reflect', interpolation='bilinear', seed=None, name=None, **kwargs): self.height_factor = height_factor if isinstance(height_factor, (tuple, list)): self.height_lower = height_factor[0] self.height_upper = height_factor[1] else: self.height_lower = self.height_upper = height_factor if self.height_lower < 0. or self.height_upper < 0.: raise ValueError('`height_factor` cannot have negative values, ' 'got {}'.format(height_factor)) if self.height_lower > self.height_upper: raise ValueError('`height_factor` cannot have lower bound larger than ' 'upper bound, got {}.'.format(height_factor)) self.width_factor = width_factor if isinstance(width_factor, (tuple, list)): self.width_lower = width_factor[0] self.width_upper = width_factor[1] else: self.width_lower = self.width_upper = width_factor if self.width_lower < 0. or self.width_upper < 0.: raise ValueError('`width_factor` cannot have negative values, ' 'got {}'.format(width_factor)) if self.width_lower > self.width_upper: raise ValueError('`width_factor` cannot have lower bound larger than ' 'upper bound, got {}.'.format(width_factor)) if fill_mode not in {'reflect', 'wrap', 'constant'}: raise NotImplementedError( 'Unknown `fill_mode` {}. Only `reflect`, `wrap` and ' '`constant` are supported.'.format(fill_mode)) if interpolation not in {'nearest', 'bilinear'}: raise NotImplementedError( 'Unknown `interpolation` {}. Only `nearest` and ' '`bilinear` are supported.'.format(interpolation)) self.fill_mode = fill_mode self.interpolation = interpolation self.seed = seed self._rng = make_generator(self.seed) self.input_spec = InputSpec(ndim=4) super(RandomZoom, self).__init__(name=name, **kwargs)
def build(self, input_shape): input_shape = tensor_shape.TensorShape(input_shape) if self.data_format == 'channels_first': channel_axis = 1 else: channel_axis = -1 if input_shape.dims[channel_axis].value is None: raise ValueError('The channel dimension of the inputs ' 'should be defined. Found `None`.') input_dim = int(input_shape[channel_axis]) kernel_shape = self.kernel_size + (input_dim, self.filters) self.kernel = self.add_weight( name='kernel', shape=kernel_shape, initializer=self.kernel_initializer, regularizer=self.kernel_regularizer, constraint=self.kernel_constraint, trainable=self.kernel_trainable, dtype=self.dtype) if self.use_bias: self.bias = self.add_weight( name='bias', shape=(self.filters, ), initializer=self.bias_initializer, regularizer=self.bias_regularizer, constraint=self.bias_constraint, trainable=self.bias_trainable, dtype=self.dtype) else: self.bias = None self.input_spec = InputSpec(ndim=self.rank + 2, axes={channel_axis: input_dim}) if self.padding == 'causal': op_padding = 'valid' else: op_padding = self.padding if not isinstance(op_padding, (list, tuple)): op_padding = op_padding.upper() self._convolution_op = nn_ops.Convolution( input_shape, filter_shape=self.kernel.shape, dilation_rate=self.dilation_rate, strides=self.strides, padding=op_padding, data_format=conv_utils.convert_data_format( self.data_format, self.rank + 2)) self.built = True
def build(self, input_shape): self.alpha = self.add_weight(shape=(1, ), name="alpha", initializer=self.alpha_initializer, regularizer=None, constraint=None, dtype=self.dtype, trainable=True) channel_axis = (1 if is_channels_first(self.data_format) else len(input_shape) - 1) axes = {} for i in range(1, len(input_shape)): if i != channel_axis: axes[i] = input_shape[i] self.input_spec = InputSpec(ndim=len(input_shape), axes=axes) self.built = True