def test_activity_regularization_config(self):
config_dict = {
'l1': 0.2,
'l2': 0.32,
}
config = ActivityRegularizationConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def assert_separable_conv(conv_class, dim):
config_dict = {
'filters': 30,
'kernel_size': 10,
'strides': [1, 1] if dim == 2 else [1, 1, 1],
'padding': 'valid',
'data_format': None,
'depth_multiplier': 1,
'activation': None,
'use_bias': True,
'depthwise_initializer':
GlorotNormalInitializerConfig().to_schema(),
'pointwise_initializer':
GlorotNormalInitializerConfig().to_schema(),
'bias_initializer': ZerosInitializerConfig().to_schema(),
'depthwise_regularizer': None,
'pointwise_regularizer': None,
'bias_regularizer': None,
'activity_regularizer': None,
'depthwise_constraint': None,
'pointwise_constraint': None,
'bias_constraint': None
}
config = conv_class.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_conv_lstm_2d_config(self):
config_dict = {
'filters': 20,
'kernel_size': 3,
'strides': [1, 1],
'padding': 'valid',
'data_format': None,
'dilation_rate': [1, 1],
'activation': 'tanh',
'recurrent_activation': 'hard_sigmoid',
'use_bias': True,
'kernel_initializer': GlorotNormalInitializerConfig().to_schema(),
'recurrent_initializer': OrthogonalInitializerConfig().to_schema(),
'bias_initializer': ZerosInitializerConfig().to_schema(),
'unit_forget_bias': True,
'kernel_regularizer': None,
'recurrent_regularizer': None,
'bias_regularizer': None,
'activity_regularizer': None,
'kernel_constraint': None,
'recurrent_constraint': None,
'bias_constraint': None,
'return_sequences': False,
'go_backwards': False,
'stateful': False,
'dropout': 0.,
'recurrent_dropout': 0.
}
config = ConvLSTM2DConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def assert_zero_padding(zero_padding_class, dim):
config_dict = {
'padding': 1 if dim == 1 else [1, 1] if dim == 2 else [1, 1, 1],
}
if dim > 1:
config_dict['data_format'] = None
config = zero_padding_class.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def assert_upsampling(upsampling_class, dim):
config_dict = {
'size': 1 if dim == 1 else [1, 1] if dim == 2 else [1, 1, 1],
}
if dim > 1:
config_dict['data_format'] = None
config = upsampling_class.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_convert_color_space_config(self):
config_dict = {
'from_space': 'rgb',
'to_space': 'grayscale',
'name': 'ConvertColorSpace'
}
config = ConvertColorSpaceConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_prelu_config(self):
config_dict = {
'alpha_initializer': ZerosInitializerConfig().to_schema(),
'alpha_regularizer': None,
'alpha_constraint': None,
'shared_axes': None
}
config = PReLUConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_convert_image_dtype_config(self):
config_dict = {
'dtype': 'float32',
'saturate': True,
'name': 'ConvertImagesDtype'
}
config = ConvertImagesDtypeConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_alpha_dropout_config(self):
config_dict = {
'rate': 0.8,
'noise_shape': [1, 1],
'seed': None
}
config = AlphaDropoutConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_rotate_config(self):
config_dict = {
'k': 0,
'is_random': False,
'seed': None,
'name': 'Rotate90'
}
config = Rotate90Config.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_flip_config(self):
config_dict = {
'axis': 0,
'is_random': False,
'seed': None,
'name': 'Flip'
}
config = FlipConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_adjust_brightness_config(self):
config_dict = {
'delta': 1.3,
'is_random': True,
'seed': 1000,
'name': 'AdjustBrightness'
}
config = AdjustBrightnessConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_adjust_hue_config(self):
config_dict = {
'delta': 0.3,
'is_random': True,
'seed': 1000,
'name': 'AdjustHue'
}
config = AdjustHueConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_resize_config(self):
config_dict = {
'height': 28,
'width': 28,
'method': 0,
'align_corners': True,
'name': 'Resize'
}
config = ResizeConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def assert_pooling_config(pooling_class, dim):
config_dict = {
'pool_size': 1 if dim == 1 else [1, 1] if dim == 2 else [1, 1, 1],
'strides': 1 if dim == 1 else [1, 1] if dim == 2 else [1, 1, 1],
'padding': 'valid',
}
if dim > 1:
config_dict['data_format'] = None
config = pooling_class.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_recurrent_config(self):
config_dict = {
'return_sequences': False,
'return_state': False,
'go_backwards': False,
'stateful': False,
'unroll': False,
'implementation': 0,
}
config = RecurrentConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_adjust_saturation_config(self):
config_dict = {
'saturation_factor': 0.3,
'saturation_factor_max': None,
'is_random': True,
'seed': 1000,
'name': 'AdjustSaturation'
}
config = AdjustSaturationConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_adjust_contrast_config(self):
config_dict = {
'contrast_factor': 1.3,
'contrast_factor_max': None,
'is_random': False,
'seed': 1000,
'name': 'AdjustContrast'
}
config = AdjustContrastConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_extract_glimpse_config(self):
config_dict = {
'size': [1, 1],
'offsets': [1, 1],
'centered': True,
'normalized': True,
'uniform_noise': True,
'name': 'ExtractGlimpse'
}
config = ExtractGlimpseConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_to_bounding_box_config(self):
config_dict = {
'offset_height': 1,
'offset_width': 1,
'target_height': 10,
'target_width': 10,
'method': 'crop',
'name': 'ToBoundingBox'
}
config = ToBoundingBoxConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_embedding_config(self):
config_dict = {
'input_dim': 100,
'output_dim': 100,
'embeddings_initializer': UniformInitializerConfig().to_schema(),
'embeddings_regularizer': None,
'activity_regularizer': None,
'embeddings_constraint': None,
'mask_zero': False,
'input_length': None,
}
config = EmbeddingConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_conv_recurrent_2d_config(self):
config_dict = {
'filters': 20,
'kernel_size': 3,
'strides': [1, 1],
'padding': 'valid',
'data_format': None,
'dilation_rate': [1, 1],
'return_sequences': False,
'go_backwards': False,
'stateful': False
}
config = ConvRecurrent2DConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_dense_config(self):
config_dict = {
'units': 12,
'activation': 'elu',
'use_bias': True,
'kernel_initializer': GlorotNormalInitializerConfig().to_schema(),
'bias_initializer': ZerosInitializerConfig().to_schema(),
'kernel_regularizer': None,
'bias_regularizer': None,
'activity_regularizer': None,
'kernel_constraint': None,
'bias_constraint': None,
'inbound_nodes': [['layer_1', 0, 1], ['layer_2', 1, 1]]
}
config = DenseConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_batch_normalization_config(self):
config_dict = {
'axis': -1,
'momentum': 0.99,
'epsilon': 1e-3,
'center': True,
'scale': True,
'beta_initializer': ZerosInitializerConfig().to_schema(),
'gamma_initializer': OnesInitializerConfig().to_schema(),
'moving_mean_initializer': ZerosInitializerConfig().to_schema(),
'moving_variance_initializer': OnesInitializerConfig().to_schema(),
'beta_regularizer': None,
'gamma_regularizer': None,
'beta_constraint': None,
'gamma_constraint': None,
}
config = BatchNormalizationConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_simple_rnn_config(self):
config_dict = {
'units': 3,
'activation': 'tanh',
'use_bias': True,
'kernel_initializer': GlorotUniformInitializerConfig().to_schema(),
'recurrent_initializer': OrthogonalInitializerConfig().to_schema(),
'bias_initializer': ZerosInitializerConfig().to_schema(),
'kernel_regularizer': None,
'recurrent_regularizer': None,
'bias_regularizer': None,
'activity_regularizer': None,
'kernel_constraint': None,
'recurrent_constraint': None,
'bias_constraint': None,
'dropout': 0.,
'recurrent_dropout': 0.,
}
config = SimpleRNNConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def assert_local_config(local_class, dim):
config_dict = {
'filters': 20,
'kernel_size': 3,
'strides': 1 if dim == 1 else [1, 1],
'padding': 'valid',
'data_format': None,
'activation': None,
'use_bias': True,
'kernel_initializer': GlorotUniformInitializerConfig().to_schema(),
'bias_initializer': ZerosInitializerConfig().to_schema(),
'kernel_regularizer': None,
'bias_regularizer': None,
'activity_regularizer': None,
'kernel_constraint': None,
'bias_constraint': None,
}
if dim > 1:
config_dict['data_format'] = None
config = local_class.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def assert_conv_config(conv_class, dim):
config_dict = {
'filters': 30,
'kernel_size': 3,
'strides': 1 if dim == 1 else [1, 1] if dim == 2 else [1, 1, 1],
'padding': 'valid',
'activation': 'relu',
'dilation_rate':
1 if dim == 1 else [1, 1] if dim == 2 else [1, 1, 1],
'use_bias': True,
'kernel_initializer': GlorotNormalInitializerConfig().to_schema(),
'bias_initializer': ZerosInitializerConfig().to_schema(),
'kernel_regularizer': L1L2RegularizerConfig().to_schema(),
'bias_regularizer': None,
'activity_regularizer': L1RegularizerConfig().to_schema(),
'kernel_constraint': MaxNormConfig().to_schema(),
'bias_constraint': None,
'inbound_nodes': [['layer_1', 0, 1], ['layer_2', 1, 1]]
}
if dim > 1:
config_dict['data_format'] = None
config = conv_class.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_flatten_config(self):
config_dict = {}
config = FlattenConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_cast_config(self):
config_dict = {
'dtype': 'float32',
}
config = CastConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
def test_repeat_vector_config(self):
config_dict = {
'n': 12,
}
config = RepeatVectorConfig.from_dict(config_dict)
assert_equal_layers(config, config_dict)
