Python initializers.serialize函数代码示例

 def get_config(self):
   config = {
       'axis': self.axis,
       'momentum': self.momentum,
       'epsilon': self.epsilon,
       'center': self.center,
       'scale': self.scale,
       'beta_initializer': initializers.serialize(self.beta_initializer),
       'gamma_initializer': initializers.serialize(self.gamma_initializer),
       'moving_mean_initializer':
           initializers.serialize(self.moving_mean_initializer),
       'moving_variance_initializer':
           initializers.serialize(self.moving_variance_initializer),
       'beta_regularizer': regularizers.serialize(self.beta_regularizer),
       'gamma_regularizer': regularizers.serialize(self.gamma_regularizer),
       'beta_constraint': constraints.serialize(self.beta_constraint),
       'gamma_constraint': constraints.serialize(self.gamma_constraint)
   }
   # Only add TensorFlow-specific parameters if they are set, so as to preserve
   # model compatibility with external Keras.
   if self.renorm:
     config['renorm'] = True
     config['renorm_clipping'] = self.renorm_clipping
     config['renorm_momentum'] = self.renorm_momentum
   if self.virtual_batch_size is not None:
     config['virtual_batch_size'] = self.virtual_batch_size
   # Note: adjustment is not serializable.
   if self.adjustment is not None:
     logging.warning('The `adjustment` function of this `BatchNormalization` '
                     'layer cannot be serialized and has been omitted from '
                     'the layer config. It will not be included when '
                     're-creating the layer from the saved config.')
   base_config = super(BatchNormalizationBase, self).get_config()
   return dict(list(base_config.items()) + list(config.items()))

 def get_config(self):
   config = {'filters': self.filters,
             'kernel_size': self.kernel_size,
             'strides': self.strides,
             'padding': self.padding,
             'data_format': self.data_format,
             'dilation_rate': self.dilation_rate,
             'activation': activations.serialize(self.activation),
             'recurrent_activation': activations.serialize(
                 self.recurrent_activation),
             'use_bias': self.use_bias,
             'kernel_initializer': initializers.serialize(
                 self.kernel_initializer),
             'recurrent_initializer': initializers.serialize(
                 self.recurrent_initializer),
             'bias_initializer': initializers.serialize(self.bias_initializer),
             'unit_forget_bias': self.unit_forget_bias,
             'kernel_regularizer': regularizers.serialize(
                 self.kernel_regularizer),
             'recurrent_regularizer': regularizers.serialize(
                 self.recurrent_regularizer),
             'bias_regularizer': regularizers.serialize(self.bias_regularizer),
             'kernel_constraint': constraints.serialize(
                 self.kernel_constraint),
             'recurrent_constraint': constraints.serialize(
                 self.recurrent_constraint),
             'bias_constraint': constraints.serialize(self.bias_constraint),
             'dropout': self.dropout,
             'recurrent_dropout': self.recurrent_dropout}
   base_config = super(ConvLSTM2DCell, self).get_config()
   return dict(list(base_config.items()) + list(config.items()))

 def get_config(self):
   config = {
       'filters':
           self.filters,
       'kernel_size':
           self.kernel_size,
       'strides':
           self.strides,
       'padding':
           self.padding,
       'data_format':
           self.data_format,
       'activation':
           activations.serialize(self.activation),
       'use_bias':
           self.use_bias,
       'kernel_initializer':
           initializers.serialize(self.kernel_initializer),
       'bias_initializer':
           initializers.serialize(self.bias_initializer),
       'kernel_regularizer':
           regularizers.serialize(self.kernel_regularizer),
       'bias_regularizer':
           regularizers.serialize(self.bias_regularizer),
       'activity_regularizer':
           regularizers.serialize(self.activity_regularizer),
       'kernel_constraint':
           constraints.serialize(self.kernel_constraint),
       'bias_constraint':
           constraints.serialize(self.bias_constraint),
       'implementation':
           self.implementation
   }
   base_config = super(LocallyConnected2D, self).get_config()
   return dict(list(base_config.items()) + list(config.items()))

 def get_config(self):
   config = {
       'units': self.units,
       'activation': activations.serialize(self.activation),
       'use_bias': self.use_bias,
       'kernel_initializer': initializers.serialize(self.kernel_initializer),
       'bias_initializer': initializers.serialize(self.bias_initializer),
       'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
       'bias_regularizer': regularizers.serialize(self.bias_regularizer),
       'activity_regularizer':
           regularizers.serialize(self.activity_regularizer),
       'kernel_constraint': constraints.serialize(self.kernel_constraint),
       'bias_constraint': constraints.serialize(self.bias_constraint)
   }
   base_config = super(Dense, self).get_config()
   return dict(list(base_config.items()) + list(config.items()))

 def get_config(self):
   config = {
       'alpha_initializer': initializers.serialize(self.alpha_initializer),
       'alpha_regularizer': regularizers.serialize(self.alpha_regularizer),
       'alpha_constraint': constraints.serialize(self.alpha_constraint),
       'shared_axes': self.shared_axes
   }
   base_config = super(PReLU, self).get_config()
   return dict(list(base_config.items()) + list(config.items()))

 def get_config(self):
   config = {
       'units': self.units,
       'kernel_initializer': initializers.serialize(self.kernel_initializer),
       'recurrent_initializer':
           initializers.serialize(self.recurrent_initializer),
       'bias_initializer': initializers.serialize(self.bias_initializer),
       'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
       'recurrent_regularizer':
           regularizers.serialize(self.recurrent_regularizer),
       'bias_regularizer': regularizers.serialize(self.bias_regularizer),
       'activity_regularizer':
           regularizers.serialize(self.activity_regularizer),
       'kernel_constraint': constraints.serialize(self.kernel_constraint),
       'recurrent_constraint':
           constraints.serialize(self.recurrent_constraint),
       'bias_constraint': constraints.serialize(self.bias_constraint)
   }
   base_config = super(CuDNNGRU, self).get_config()
   return dict(list(base_config.items()) + list(config.items()))

 def get_config(self):
   kernel_initializer = self.kernel_initializer
   if isinstance(self.kernel_initializer, init_ops.Initializer):
     kernel_initializer = initializers.serialize(self.kernel_initializer)
   config = {
       'output_dim': self.output_dim,
       'kernel_initializer': kernel_initializer,
       'scale': self.scale,
   }
   base_config = super(RandomFourierFeatures, self).get_config()
   return dict(list(base_config.items()) + list(config.items()))

 def get_config(self):
   config = {
       'input_dim': self.input_dim,
       'output_dim': self.output_dim,
       'embeddings_initializer':
           initializers.serialize(self.embeddings_initializer),
       'embeddings_regularizer':
           regularizers.serialize(self.embeddings_regularizer),
       'activity_regularizer':
           regularizers.serialize(self.activity_regularizer),
       'embeddings_constraint':
           constraints.serialize(self.embeddings_constraint),
       'mask_zero': self.mask_zero,
       'input_length': self.input_length
   }
   base_config = super(Embedding, self).get_config()
   return dict(list(base_config.items()) + list(config.items()))

 def get_config(self):
   config = {
       "num_units": self._num_units,
       "use_peepholes": self._use_peepholes,
       "cell_clip": self._cell_clip,
       "initializer": initializers.serialize(self._initializer),
       "num_proj": self._num_proj,
       "proj_clip": self._proj_clip,
       "num_unit_shards": self._num_unit_shards,
       "num_proj_shards": self._num_proj_shards,
       "forget_bias": self._forget_bias,
       "state_is_tuple": self._state_is_tuple,
       "activation": activations.serialize(self._activation),
       "reuse": self._reuse,
   }
   base_config = super(TFLiteLSTMCell, self).get_config()
   return dict(list(base_config.items()) + list(config.items()))

  def test_get_config(self, output_dim, initializer, scale, trainable):
    rff_layer = kernel_layers.RandomFourierFeatures(
        output_dim,
        initializer,
        scale=scale,
        trainable=trainable,
        name='random_fourier_features',
    )
    expected_initializer = initializer
    if isinstance(initializer, init_ops.Initializer):
      expected_initializer = initializers.serialize(initializer)

    expected_config = {
        'output_dim': output_dim,
        'kernel_initializer': expected_initializer,
        'scale': scale,
        'name': 'random_fourier_features',
        'trainable': trainable,
        'dtype': None,
    }
    self.assertLen(expected_config, len(rff_layer.get_config()))
    self.assertSameElements(
        list(expected_config.items()), list(rff_layer.get_config().items()))