예제 #1
0
    def __init__(self, output_dim, init='glorot_uniform', activation='linear',
                 reconstruction_activation='linear', weights=None,
                 W_regularizer=None, b_regularizer=None, activity_regularizer=None,
                 output_reconstruction=False,
                 W_constraint=None, b_constraint=None, input_dim=None, **kwargs):
        self.init = initializations.get(init)
        self.activation = activations.get(activation)
        self.reconstruction_activation = activations.get(reconstruction_activation)
        self.output_reconstruction = output_reconstruction
        self.output_dim = output_dim
        self.pretrain = True

        self.W_regularizer = regularizers.get(W_regularizer)
        self.b_regularizer = regularizers.get(b_regularizer)
        self.activity_regularizer = regularizers.get(activity_regularizer)

        self.W_constraint = constraints.get(W_constraint)
        self.b_constraint = constraints.get(b_constraint)
        self.constraints = [self.W_constraint, self.b_constraint]

        self.initial_weights = weights

        self.input_dim = input_dim
        if self.input_dim:
            kwargs['input_shape'] = (self.input_dim,)
        self.input = K.placeholder(ndim=2)
        super(SymmetricAutoencoder, self).__init__(**kwargs)
예제 #2
0
    def __init__(self, output_dim,
                 init='glorot_uniform', activation='linear', weights=None,
                 W_regularizer=None, b_regularizer=None, activity_regularizer=None,
                 W_constraint=None, b_constraint=None,
                 input_dim=None, input_length1=None, input_length2=None, **kwargs):
        self.output_dim = output_dim
        self.init = initializations.get(init)
        self.activation = activations.get(activation)

        self.W_regularizer = regularizers.get(W_regularizer)
        self.b_regularizer = regularizers.get(b_regularizer)
        self.activity_regularizer = regularizers.get(activity_regularizer)

        self.W_constraint = constraints.get(W_constraint)
        self.b_constraint = constraints.get(b_constraint)
        self.constraints = [self.W_constraint, self.b_constraint]

        self.initial_weights = weights

        self.input_dim = input_dim
        self.input_length1 = input_length1
        self.input_length2 = input_length2
        if self.input_dim:
            kwargs['input_shape'] = (self.input_length1, self.input_length2, self.input_dim)
        self.input = K.placeholder(ndim=4)
        super(HigherOrderTimeDistributedDense, self).__init__(**kwargs)
예제 #3
0
파일: LSTMCNN.py 프로젝트: jarfo/kchar
    def __init__(self,
                 init='glorot_uniform',
                 activation=None,
                 weights=None,
                 W_regularizer=None,
                 b_regularizer=None,
                 activity_regularizer=None,
                 W_constraint=None,
                 b_constraint=None,
                 bias=True,
                 input_dim=None,
                 **kwargs):

        self.init = initializers.get(init)
        self.activation = activations.get(activation)

        self.W_regularizer = regularizers.get(W_regularizer)
        self.b_regularizer = regularizers.get(b_regularizer)
        self.activity_regularizer = regularizers.get(activity_regularizer)

        self.W_constraint = constraints.get(W_constraint)
        self.b_constraint = constraints.get(b_constraint)

        self.bias = bias
        self.initial_weights = weights
        self.input_spec = InputSpec(ndim=2)

        self.input_dim = input_dim
        if self.input_dim:
            kwargs['input_shape'] = (self.input_dim,)
        super(Highway, self).__init__(**kwargs)
예제 #4
0
파일: layers.py 프로젝트: Libardo1/modeling
    def __init__(self, output_dim, nb_hsm_classes, batch_size,
            init='glorot_uniform',
            W1_weights=None, W1_regularizer=None, W1_constraint=None,
            W2_weights=None, W2_regularizer=None, W2_constraint=None,
            b1_regularizer=None, b1_constraint=None,
            b2_regularizer=None, b2_constraint=None,
            input_dim=None, **kwargs):

        self.__dict__.update(locals())
        del self.self

        self.init = initializations.get(init)
        #self.output_dim = nb_classes * nb_outputs_per_class
        self.nb_outputs_per_class = int(np.ceil(output_dim / float(nb_hsm_classes)))

        self.W1_regularizer = regularizers.get(W1_regularizer)
        self.b1_regularizer = regularizers.get(b1_regularizer)
        self.W2_regularizer = regularizers.get(W2_regularizer)
        self.b2_regularizer = regularizers.get(b2_regularizer)

        self.W1_constraint = constraints.get(W1_constraint)
        self.b1_constraint = constraints.get(b1_constraint)
        self.W2_constraint = constraints.get(W2_constraint)
        self.b2_constraint = constraints.get(b2_constraint)

        self.constraints = [self.W1_constraint, self.b1_constraint,
                self.W2_constraint, self.b2_constraint]

        #self.initial_weights = weights
        self.input_dim = input_dim
        if self.input_dim:
            kwargs['input_shape'] = (self.input_dim,)
        self.input = T.matrix()
        super(HierarchicalSoftmax, self).__init__(**kwargs)
예제 #5
0
 def __init__(self,
              axis=None,
              epsilon=1e-3,
              center=True,
              scale=True,
              beta_initializer='zeros',
              gamma_initializer='ones',
              beta_regularizer=None,
              gamma_regularizer=None,
              beta_constraint=None,
              gamma_constraint=None,
              **kwargs):
     self.beta = None
     self.gamma = None
     super(InstanceNormalization, self).__init__(**kwargs)
     self.supports_masking = True
     self.axis = axis
     self.epsilon = epsilon
     self.center = center
     self.scale = scale
     self.beta_initializer = initializers.get(beta_initializer)
     self.gamma_initializer = initializers.get(gamma_initializer)
     self.beta_regularizer = regularizers.get(beta_regularizer)
     self.gamma_regularizer = regularizers.get(gamma_regularizer)
     self.beta_constraint = constraints.get(beta_constraint)
     self.gamma_constraint = constraints.get(gamma_constraint)
예제 #6
0
 def __init__(self, offset_creator_class, weight_basis,
              filters,
              kernel_size,
              strides=(1, 1),
              padding='valid',
              data_format=None,
              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,
              **kwargs):
     super(RProjLocallyConnected2D, self).__init__(offset_creator_class, weight_basis, **kwargs)
     self.filters = filters
     self.kernel_size = conv_utils.normalize_tuple(kernel_size, 2, 'kernel_size')
     self.strides = conv_utils.normalize_tuple(strides, 2, 'strides')
     self.padding = conv_utils.normalize_padding(padding)
     if self.padding != 'valid':
         raise ValueError('Invalid border mode for LocallyConnected2D '
                          '(only "valid" is supported): ' + padding)
     self.data_format = conv_utils.normalize_data_format(data_format)
     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.activity_regularizer = regularizers.get(activity_regularizer)
     self.kernel_constraint = constraints.get(kernel_constraint)
     self.bias_constraint = constraints.get(bias_constraint)
     self.input_spec = InputSpec(ndim=4)
예제 #7
0
 def __init__(self, offset_creator_class, weight_basis,
              axis=-1,
              momentum=0.99,
              epsilon=1e-3,
              center=True,
              scale=True,
              beta_initializer='zeros',
              gamma_initializer='ones',
              moving_mean_initializer='zeros',
              moving_variance_initializer='ones',
              beta_regularizer=None,
              gamma_regularizer=None,
              beta_constraint=None,
              gamma_constraint=None,
              **kwargs):
     super(RProjBatchNormalization, self).__init__(offset_creator_class, weight_basis, **kwargs)
     self.supports_masking = True
     self.axis = axis
     self.momentum = momentum
     self.epsilon = epsilon
     self.center = center
     self.scale = scale
     self.beta_initializer = initializers.get(beta_initializer)
     self.gamma_initializer = initializers.get(gamma_initializer)
     self.moving_mean_initializer = initializers.get(moving_mean_initializer)
     self.moving_variance_initializer = initializers.get(moving_variance_initializer)
     self.beta_regularizer = regularizers.get(beta_regularizer)
     self.gamma_regularizer = regularizers.get(gamma_regularizer)
     self.beta_constraint = constraints.get(beta_constraint)
     self.gamma_constraint = constraints.get(gamma_constraint)
예제 #8
0
    def __init__(self, nb_filter, nb_row, nb_col, mask_type=None, direction='Down',
                 init='glorot_uniform', activation='linear', weights=None,
                 border_mode='valid', subsample=(1, 1), dim_ordering='th',
                 W_regularizer=None, b_regularizer=None, activity_regularizer=None,
                 W_constraint=None, b_constraint=None,
                 bias=True, **kwargs):
        self.mask_type = mask_type
        self.direction = direction
        if border_mode not in {'valid', 'same'}:
            raise Exception('Invalid border mode for Convolution2D:', border_mode)
        self.nb_filter = nb_filter
        self.nb_row = nb_row
        self.nb_col = nb_col
        self.init = initializations.get(init, dim_ordering=dim_ordering)
        self.activation = activations.get(activation)
        assert border_mode in {'valid', 'same'}, 'border_mode must be in {valid, same}'
        self.border_mode = border_mode
        self.subsample = tuple(subsample)
        assert dim_ordering in {'tf', 'th'}, 'dim_ordering must be in {tf, th}'
        self.dim_ordering = dim_ordering

        self.W_regularizer = regularizers.get(W_regularizer)
        self.b_regularizer = regularizers.get(b_regularizer)
        self.activity_regularizer = regularizers.get(activity_regularizer)

        self.W_constraint = constraints.get(W_constraint)
        self.b_constraint = constraints.get(b_constraint)

        self.bias = bias
        self.input_spec = [InputSpec(ndim=4)]
        self.initial_weights = weights
        super(MaskedConvolution2D, self).__init__(**kwargs)
예제 #9
0
    def __init__(self, nb_filter, nb_row, nb_col,
                 init='glorot_uniform', activation='linear', weights=None,
                 border_mode='valid', subsample=(1, 1),
                 W_regularizer=None, b_regularizer=None, activity_regularizer=None,
                 W_constraint=None, b_constraint=None, **kwargs):

        if border_mode not in {'valid', 'full', 'same'}:
            raise Exception('Invalid border mode for Convolution2D:', border_mode)
        self.nb_filter = nb_filter
        self.nb_row = nb_row
        self.nb_col = nb_col
        self.init = initializations.get(init)
        self.activation = activations.get(activation)
        self.border_mode = border_mode
        self.subsample = tuple(subsample)

        self.W_regularizer = regularizers.get(W_regularizer)
        self.b_regularizer = regularizers.get(b_regularizer)
        self.activity_regularizer = regularizers.get(activity_regularizer)

        self.W_constraint = constraints.get(W_constraint)
        self.b_constraint = constraints.get(b_constraint)
        self.constraints = [self.W_constraint, self.b_constraint]

        self.initial_weights = weights
        super(Convolution2D, self).__init__(**kwargs)
예제 #10
0
    def __init__(self, step_dim,
                 W_regularizer=None, b_regularizer=None,
                 W_constraint=None, b_constraint=None,
                 bias=True, **kwargs):
        """
        Keras Layer that implements an Attention mechanism for temporal data.
        Supports Masking.
        Follows the work of Raffel et al. [https://arxiv.org/abs/1512.08756]
        # Input shape
            3D tensor with shape: `(samples, steps, features)`.
        # Output shape
            2D tensor with shape: `(samples, features)`.
        :param kwargs:
        Just put it on top of an RNN Layer (GRU/LSTM/SimpleRNN) with return_sequences=True.
        The dimensions are inferred based on the output shape of the RNN.
        Example:
            model.add(LSTM(64, return_sequences=True))
            model.add(Attention())
        """
        self.supports_masking = True
        # self.init = initializations.get('glorot_uniform')
        self.init = initializers.get('glorot_uniform')

        self.W_regularizer = regularizers.get(W_regularizer)
        self.b_regularizer = regularizers.get(b_regularizer)

        self.W_constraint = constraints.get(W_constraint)
        self.b_constraint = constraints.get(b_constraint)

        self.bias = bias
        self.step_dim = step_dim
        self.features_dim = 0
        super(Attention, self).__init__(**kwargs)
예제 #11
0
 def __init__(self, offset_creator_class, weight_basis,
              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,
              **kwargs):
     if 'input_shape' not in kwargs and 'input_dim' in kwargs:
         kwargs['input_shape'] = (kwargs.pop('input_dim'),)
     super(RProjDense, self).__init__(offset_creator_class, weight_basis, **kwargs)
     self.units = 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.activity_regularizer = regularizers.get(activity_regularizer)
     self.kernel_constraint = constraints.get(kernel_constraint)
     self.bias_constraint = constraints.get(bias_constraint)
     self.input_spec = InputSpec(min_ndim=2)
     self.supports_masking = True
    def __init__(self, units,
                 projection_units=None,
                 activation='tanh',
                 recurrent_activation='sigmoid',
                 projection_activation='linear',
                 use_bias=True,
                 kernel_initializer='glorot_uniform',
                 recurrent_initializer='orthogonal',
                 projection_initializer='glorot_uniform',
                 bias_initializer='zeros',
                 unit_forget_bias=False,
                 kernel_regularizer=None,
                 recurrent_regularizer=None,
                 projection_regularizer=None,
                 bias_regularizer=None,
                 kernel_constraint=None,
                 recurrent_constraint=None,
                 projection_constraint=None,
                 bias_constraint=None,
                 dropout=0.,
                 recurrent_dropout=0.,
                 implementation=2,
                 **kwargs):
        super(NASCell, self).__init__(**kwargs)
        self.units = units
        self.projection_units = projection_units
        self.activation = activations.get(activation)
        self.recurrent_activation = activations.get(recurrent_activation)
        self.projection_activation = activations.get(projection_activation)
        self.cell_activation = activations.get('relu')
        self.use_bias = use_bias

        self.kernel_initializer = initializers.get(kernel_initializer)
        self.recurrent_initializer = initializers.get(recurrent_initializer)
        self.projection_initializer = initializers.get(projection_initializer)
        self.bias_initializer = initializers.get(bias_initializer)
        self.unit_forget_bias = unit_forget_bias

        self.kernel_regularizer = regularizers.get(kernel_regularizer)
        self.recurrent_regularizer = regularizers.get(recurrent_regularizer)
        self.projection_regularizer = regularizers.get(projection_regularizer)
        self.bias_regularizer = regularizers.get(bias_regularizer)

        self.kernel_constraint = constraints.get(kernel_constraint)
        self.recurrent_constraint = constraints.get(recurrent_constraint)
        self.projection_constraint = constraints.get(projection_constraint)
        self.bias_constraint = constraints.get(bias_constraint)

        self.dropout = min(1., max(0., dropout))
        self.recurrent_dropout = min(1., max(0., recurrent_dropout))
        self.implementation = implementation

        if self.projection_units is not None:
            self.state_size = (self.projection_units, self.units)
        else:
            self.state_size = (self.units, self.units)

        self._dropout_mask = None
        self._recurrent_dropout_mask = None
예제 #13
0
파일: tensor.py 프로젝트: jfsantos/seya
    def __init__(self, input_dim, output_dim, causes_dim,
                 hid2output,
                 init='glorot_uniform',
                 W_regularizer=None,
                 W_constraint=None,
                 b_regularizer=None,
                 b_constraint=None,
                 activation=lambda X: T.minimum(20, T.maximum(0, X)),
                 activity_regularizer=None,
                 truncate_gradient=-1,
                 weights=None, name=None,
                 return_mode='both',
                 return_sequences=True):
        super(GAE, self).__init__()
        self.input_dim = input_dim
        self.output_dim = output_dim
        self.causes_dim = causes_dim
        self.activation = activations.get(activation)
        self.init = initializations.get(init)
        self.truncate_gradient = truncate_gradient
        self.input = T.tensor3()
        self.return_mode = return_mode
        self.return_sequences = return_sequences

        self.V = self.init((input_dim, output_dim))
        self.U = self.init((input_dim, output_dim))
        self.W = self.init((output_dim, causes_dim))
        self.bo = shared_zeros((self.output_dim))
        self.bc = shared_zeros((self.causes_dim))

        self.params = [self.V, self.U, self.W]

        self.regularizers = []
        self.W_regularizer = regularizers.get(W_regularizer)
        if self.W_regularizer:
            self.W_regularizer.set_param(self.W)
            self.regularizers.append(self.W_regularizer)

        self.b_regularizer = regularizers.get(b_regularizer)
        if self.b_regularizer:
            self.b_regularizer.set_param(self.b)
            self.regularizers.append(self.b_regularizer)

        self.activity_regularizer = regularizers.get(activity_regularizer)
        if self.activity_regularizer:
            self.activity_regularizer.set_layer(self)
            self.regularizers.append(self.activity_regularizer)

        self.W_constraint = constraints.get(W_constraint)
        self.b_constraint = constraints.get(b_constraint)
        self.constraints = [self.W_constraint, self.b_constraint]

        if weights is not None:
            self.set_weights(weights)

        if name is not None:
            self.set_name(name)
예제 #14
0
    def __init__(self, filters, kernel_size,strides=1,padding='same',dilation_rate=1,
                 bias_initializer='zeros',kernel_initializer='glorot_uniform', activation='linear', weights=None,
                 border_mode='valid', subsample_length=1,
                 kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None,
                 kernel_constraint=None, bias_constraint=None,
                 use_bias=True, input_dim=None, input_length=None, tied_to=None,data_format='channels_last',rank=1,learnedKernel=None,layer_inner=None,
                 **kwargs):
        if border_mode not in {'valid', 'same'}:
            raise Exception('Invalid border mode for Convolution1D:', border_mode)
        self.input_spec = [InputSpec(ndim=3)]
        self.input_dim = input_dim
        self.input_length = input_length
        self.tied_to = tied_to
        self.learnedKernel = np.array(learnedKernel)
        #self.tied_to.set_weights([weights, bias])
        self.strides = conv_utils.normalize_tuple(strides, rank, 'strides')
        self.padding = conv_utils.normalize_padding(padding)
        self.dilation_rate = conv_utils.normalize_tuple(dilation_rate, rank, 'dilation_rate')
        self.data_format = data_format
        self.filters = filters
        if self.tied_to is not None:
            self.kernel_size = self.tied_to.kernel_size
        else:
            self.kernel_size = kernel_size
        self.kernel_initializer = initializers.get(kernel_initializer)
        self.bias_initializer = initializers.get(bias_initializer)
        self.activation = activations.get(activation)
        assert border_mode in {'valid', 'same'}, 'border_mode must be in {valid, same}'
        self.border_mode = border_mode
        self.subsample_length = subsample_length
        self.subsample = (subsample_length, 1)

        self.kernel_regularizer = regularizers.get(kernel_regularizer)
        self.bias_regularizer = regularizers.get(bias_regularizer)
        self.activity_regularizer = regularizers.get(activity_regularizer)

        self.kernel_constraint = constraints.get(kernel_constraint)
        self.bias_constraint = constraints.get(bias_constraint)

        self.use_bias = use_bias

        self.rank = 1

        self.layer_inner = layer_inner

        if self.input_dim:
            kwargs['input_shape'] = (self.input_length, self.input_dim)

        #self.layer_inner = kwargs.pop('layer_inner')

        super(Convolution1D_tied, self).__init__(**kwargs)
예제 #15
0
    def __init__(self, input_dim, hidden_dim, init='glorot_uniform', weights=None, name=None,
        W_regularizer=None, bx_regularizer=None, bh_regularizer=None, #activity_regularizer=None,
        W_constraint=None, bx_constraint=None, bh_constraint=None):

        super(RBM, self).__init__()
        self.init = initializations.get(init)
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim

        self.input = T.matrix()
        self.W = self.init((self.input_dim, self.hidden_dim))
        self.bx = shared_zeros((self.input_dim))
        self.bh = shared_zeros((self.hidden_dim))

        self.params = [self.W, self.bx, self.bh]

        self.regularizers = []

        self.W_regularizer = regularizers.get(W_regularizer)
        if self.W_regularizer:
            self.W_regularizer.set_param(self.W)
            self.regularizers.append(self.W_regularizer)

        self.bx_regularizer = regularizers.get(bx_regularizer)
        if self.bx_regularizer:
            self.bx_regularizer.set_param(self.bx)
            self.regularizers.append(self.bx_regularizer)

        self.bh_regularizer = regularizers.get(bh_regularizer)
        if self.bh_regularizer:
            self.bh_regularizer.set_param(self.bh)
            self.regularizers.append(self.bh_regularizer)

        #self.activity_regularizer = regularizers.get(activity_regularizer)
        #if self.activity_regularizer:
        #    self.activity_regularizer.set_layer(self)
        #    self.regularizers.append(self.activity_regularizer)

        self.W_constraint = constraints.get(W_constraint)
        self.bx_constraint = constraints.get(bx_constraint)
        self.bh_constraint = constraints.get(bh_constraint)
        self.constraints = [self.W_constraint, self.bx_constraint, self.bh_constraint]

        if weights is not None:
            self.set_weights(weights)

        if name is not None:
            self.set_name(name)

        self.srng = RandomStreams(seed=np.random.randint(10e6))
    def __init__(self, timesteps, bias=True, simple=False,
                 W_regularizer=None, W_constraint=None,
                 V_regularizer=None, V_constraint=None,
                 **kwargs):
        self.supports_masking = True
        self.init = initializers.get('glorot_uniform')
        self.bias = bias
        self.timesteps = timesteps
        self.simple = simple
        self.W_regularizer = regularizers.get(W_regularizer)
        self.W_constraint = constraints.get(W_constraint)
        self.V_regularizer = regularizers.get(V_regularizer)
        self.V_constraint = constraints.get(V_constraint)

        super(Attention, self).__init__(**kwargs)
    def __init__(self, timesteps, attention_size, bias=True,
                 W_regularizer=regularizers.l1(0.01), W_constraint=None,
                 U_regularizer=regularizers.l1(0.01), U_constraint=None,
                 **kwargs):
        self.supports_masking = True
        self.init = initializers.get('glorot_uniform')
        self.bias = bias
        self.timesteps = timesteps
        self.attention_size = attention_size
        self.W_regularizer = regularizers.get(W_regularizer)
        self.W_constraint = constraints.get(W_constraint)
        self.U_regularizer = regularizers.get(U_regularizer)
        self.U_constraint = constraints.get(U_constraint)

        super(Attention, self).__init__(**kwargs)
예제 #18
0
    def __init__(self, nb_filter, filter_length,
                 init='glorot_uniform', activation='linear', weights=None,
                 padding='valid', strides=[1,1,1],
                 W_regularizer=None, b_regularizer=None, activity_regularizer=None,
                 W_constraint=None, b_constraint=None, input_dim=None, input_length=None, **kwargs):

        if padding not in {'valid','same'}:
            raise Exception('Invalid border mode for Convolution1D:', padding)
        #self.deconv_shape = deconv_shape

        # transform 1 D in 2D
        #deconv_shape = [batch_size, output_size_y, output_size_x, number_of_filters]
        # self.deconv_shape = [deconv_shape[0],1,deconv_shape[1],deconv_shape[2]]

        self.nb_filter = nb_filter
        self.filter_length = filter_length
        self.init = initializations.get(init)
        self.activation = activations.get(activation)
        assert padding in {'valid', 'same'}, 'border_mode must be in {valid, same}'
        self.padding = padding
        # necessary for loading, since a 4 dim. stride will be saved
        if len(strides) == 3:
            self.strides = [strides[0], 1, strides[1], strides[2]]
        else:
            self.strides = strides

        self.W_regularizer = regularizers.get(W_regularizer)
        self.b_regularizer = regularizers.get(b_regularizer)
        self.activity_regularizer = regularizers.get(activity_regularizer)

        # self.W_shape = [1, W_shape[0], W_shape[1], W_shape[2]]
        # self.b_shape = b_shape

        self.W_constraint = constraints.get(W_constraint)
        self.b_constraint = constraints.get(b_constraint)
        self.constraints = [self.W_constraint, self.b_constraint]

        self.initial_weights = weights
        #self.input = K.placeholder(ndim=4) # old keras 0.3.x

        # Keras 1.0:
        self.input_spec = [InputSpec(ndim=3)]
        self.initial_weights = weights
        self.input_dim = input_dim
        self.input_length = input_length
        if self.input_dim:
            kwargs['input_shape'] = (self.input_length, self.input_dim)
        super(Convolution1D_Transpose_Arbitrary, self).__init__(**kwargs)
예제 #19
0
    def __init__(self,
                 W_regularizer=None, b_regularizer=None,
                 W_constraint=None, b_constraint=None,
                 bias=True, **kwargs):

        self.supports_masking = True
        self.init = initializers.get('glorot_uniform')

        self.W_regularizer = regularizers.get(W_regularizer)
        self.b_regularizer = regularizers.get(b_regularizer)

        self.W_constraint = constraints.get(W_constraint)
        self.b_constraint = constraints.get(b_constraint)

        self.bias = bias
        super(Attention_layer, self).__init__(**kwargs)
예제 #20
0
    def __init__(self, nb_filter, nb_row, nb_col,
                 init='glorot_uniform', weights=None,
                 border_mode='same', subsample=(1, 1), dim_ordering='th',
                 W_regularizer=None, activity_regularizer=None,
                 W_constraint=None, **kwargs):

        if border_mode not in {'valid', 'same'}:
            raise Exception('Invalid border mode for Deconvolution2D:', border_mode)
        self.nb_filter = nb_filter
        self.nb_row = nb_row
        self.nb_col = nb_col
        self.init = initializations.get(init, dim_ordering=dim_ordering)
        assert border_mode in {'same'}, 'border_mode must be same'
        self.border_mode = border_mode
        self.subsample = tuple(subsample)
        assert dim_ordering in {'tf', 'th'}, 'dim_ordering must be in {tf, th}'
        self.dim_ordering = dim_ordering

        self.W_regularizer = regularizers.get(W_regularizer)
        self.activity_regularizer = regularizers.get(activity_regularizer)

        self.W_constraint = constraints.get(W_constraint)

        self.input_spec = [InputSpec(ndim=4)]
        self.initial_weights = weights
        super(Deconvolution2D, self).__init__(**kwargs)
    def __init__(self, input_dim, EmbedMatrix, input_length=None,
                 init='uniform',
                 W_regularizer=None, activity_regularizer=None,
                 W_constraint=None,
                 mask_zero=False,
                 weights=None, **kwargs):
        '''

        :param input_dim: 字典大小
        :param input_length: max_seq_len最大序列长度
        :param EmbedMatrix: 已经计算好的 word2vec 矩阵,单词 * 嵌入
        '''
        self.input_dim = input_dim
        self.EmbedMatrix = theano.shared(value=EmbedMatrix)
        self.output_dim = EmbedMatrix.shape[1]
        self.init = initializations.get(init)
        self.input_length = input_length
        self.mask_zero = mask_zero

        self.W_constraint = constraints.get(W_constraint)
        self.constraints = [self.W_constraint]

        self.W_regularizer = regularizers.get(W_regularizer)
        self.activity_regularizer = regularizers.get(activity_regularizer)

        self.initial_weights = weights
        kwargs['input_shape'] = (self.input_dim,)
        super(LookUpEmbeddingLayer, self).__init__(**kwargs) # 在初始化里input_shape = [None, self.input_dim]
예제 #22
0
 def __init__(self,
              kernel_size,
              strides=(1, 1),
              padding='valid',
              depth_multiplier=1,
              data_format=None,
              activation=None,
              use_bias=True,
              depthwise_initializer='glorot_uniform',
              bias_initializer='zeros',
              depthwise_regularizer=None,
              bias_regularizer=None,
              activity_regularizer=None,
              depthwise_constraint=None,
              bias_constraint=None,
              **kwargs):
     super(DepthwiseConv2D, self).__init__(
         filters=None,
         kernel_size=kernel_size,
         strides=strides,
         padding=padding,
         data_format=data_format,
         activation=activation,
         use_bias=use_bias,
         bias_regularizer=bias_regularizer,
         activity_regularizer=activity_regularizer,
         bias_constraint=bias_constraint,
         **kwargs)
     self.depth_multiplier = depth_multiplier
     self.depthwise_initializer = initializers.get(depthwise_initializer)
     self.depthwise_regularizer = regularizers.get(depthwise_regularizer)
     self.depthwise_constraint = constraints.get(depthwise_constraint)
     self.bias_initializer = initializers.get(bias_initializer)
예제 #23
0
    def __init__(self, input_dim, hidden_dim, init='glorot_uniform', weights=None, name=None,
                 W_regularizer=None, bx_regularizer=None, bh_regularizer=None, #activity_regularizer=None,
                 W_constraint=None, bx_constraint=None, bh_constraint=None):

        super(RBM, self).__init__()
        self.init = initializations.get(init)
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim

        self.input = K.placeholder(ndim = 2)
        self.W = self.init((self.input_dim, self.hidden_dim))
        self.bx = K.zeros((self.input_dim))
        self.bh = K.zeros((self.hidden_dim))

        self.params = [self.W, self.bx, self.bh]

        self.regularizers = []
        self.W_regularizer = regularizers.get(W_regularizer)
        if self.W_regularizer:
            self.W_regularizer.set_param(self.W)
            self.regularizers.append(self.W_regularizer)

        self.bx_regularizer = regularizers.get(bx_regularizer)
        if self.bx_regularizer:
            self.bx_regularizer.set_param(self.bx)
            self.regularizers.append(self.bx_regularizer)

        self.bh_regularizer = regularizers.get(bh_regularizer)
        if self.bh_regularizer:
            self.bh_regularizer.set_param(self.bh)
            self.regularizers.append(self.bh_regularizer)

        #self.activity_regularizer = regularizers.get(activity_regularizer)
        #if self.activity_regularizer:
        #    self.activity_regularizer.set_layer(self)
        #    self.regularizers.append(self.activity_regularizer)

        self.W_constraint = constraints.get(W_constraint)
        self.bx_constraint = constraints.get(bx_constraint)
        self.bh_constraint = constraints.get(bh_constraint)
        self.constraints = [self.W_constraint, self.bx_constraint, self.bh_constraint]

        if weights is not None:
            self.set_weights(weights)

        if name is not None:
            self.set_name(name)
예제 #24
0
    def __init__(self,
                 units = 1,
                 output_dim = 1,
                 W_regularizer=None, b_regularizer=None,
                 W_constraint=None, b_constraint=None,
                 bias=True,
                 return_sequence = True,
                 return_attention=False,
                 return_probabilities = False,
                 **kwargs):
        """
        Keras Layer that implements an Attention mechanism for temporal data.
        Supports Masking.
        Follows the work of Raffel et al. [https://arxiv.org/abs/1512.08756]
        # Input shape
            3D tensor with shape: `(samples, steps, features)`.
        # Output shape
            2D tensor with shape: `(samples, features)`.
        :param kwargs:
        Just put it on top of an RNN Layer (GRU/LSTM/SimpleRNN) with return_sequences=True.
        The dimensions are inferred based on the output shape of the RNN.
        Note: The layer has been tested with Keras 1.x
        Example:
        
            # 1
            model.add(LSTM(64, return_sequences=True))
            model.add(Attention())
            # next add a Dense layer (for classification/regression) or whatever...
            # 2 - Get the attention scores
            hidden = LSTM(64, return_sequences=True)(words)
            sentence, word_scores = Attention(return_attention=True)(hidden)
        """
        self.supports_masking = True
        self.return_attention = return_attention
        self.init = initializers.get('glorot_uniform')
        self.attention_dim = units
        self.output_dim = output_dim
        self.W_regularizer = regularizers.get(W_regularizer)
        self.b_regularizer = regularizers.get(b_regularizer)

        self.W_constraint = constraints.get(W_constraint)
        self.b_constraint = constraints.get(b_constraint)

        self.bias = bias
        super(AttentionDecoder, self).__init__(**kwargs)
예제 #25
0
    def __init__(self, step_dim,
                 W_regularizer=None, b_regularizer=None,
                 W_constraint=None, b_constraint=None,
                 bias=True, **kwargs):
        self.supports_masking = True
        # self.init = initializations.get('glorot_uniform')
        self.init = initializers.get('glorot_uniform')

        self.W_regularizer = regularizers.get(W_regularizer)
        self.b_regularizer = regularizers.get(b_regularizer)

        self.W_constraint = constraints.get(W_constraint)
        self.b_constraint = constraints.get(b_constraint)

        self.bias = bias
        self.step_dim = step_dim
        self.features_dim = 0
        super(Attention, self).__init__(**kwargs)
    def __init__(self, input_dim, output_dim, init='glorot_uniform', activation='linear', weights=None, name=None,
                 W_regularizer=None, b_regularizer=None, activity_regularizer=None,
                 W_constraint=None, b_constraint=None, corruption_level=0.0):

        super(DAE, self).__init__()
        self.srng = RandomStreams(seed=np.random.randint(10e6))
        self.init = initializations.get(init)
        self.activation = activations.get(activation)
        self.input_dim = input_dim
        self.output_dim = output_dim
        self.corruption_level = corruption_level

        self.input = T.matrix()
        self.W = self.init((self.input_dim, self.output_dim))
        self.b = shared_zeros((self.output_dim))
        self.bT = shared_zeros((self.input_dim))

        self.params = [self.W, self.b, self.bT]

        self.regularizers = []
        self.W_regularizer = regularizers.get(W_regularizer)
        if self.W_regularizer:
            self.W_regularizer.set_param(self.W)
            self.regularizers.append(self.W_regularizer)

        self.b_regularizer = regularizers.get(b_regularizer)
        if self.b_regularizer:
            self.b_regularizer.set_param(self.b)
            self.regularizers.append(self.b_regularizer)

        self.activity_regularizer = regularizers.get(activity_regularizer)
        if self.activity_regularizer:
            self.activity_regularizer.set_layer(self)
            self.regularizers.append(self.activity_regularizer)

        self.W_constraint = constraints.get(W_constraint)
        self.b_constraint = constraints.get(b_constraint)
        self.constraints = [self.W_constraint, self.b_constraint]

        if weights is not None:
            self.set_weights(weights)

        if name is not None:
            self.set_name(name)
예제 #27
0
 def __init__(self, a_initializer='ones',
              k_initializer='ones',
              n_initializer='ones',
              z_initializer='zeros',
              a_regularizer=None,
              a_constraint=constraints.NonNeg(),
              k_regularizer=None,
              k_constraint=constraints.NonNeg(),
              n_regularizer=None,
              n_constraint=constraints.NonNeg(),  
              z_regularizer=None,
              z_constraint=constraints.NonNeg(),
              shared_axes=None,
              a_shared=True,
              k_shared=True,
              n_shared=True,
              z_shared=True,
              z_one=False,
              **kwargs):
     super(Hill, self).__init__(**kwargs)
     self.supports_masking = True
     self.a_initializer = initializers.get(a_initializer)
     self.a_regularizer = regularizers.get(a_regularizer)
     self.a_constraint = constraints.get(a_constraint)
     self.k_initializer = initializers.get(a_initializer)
     self.k_regularizer = regularizers.get(a_regularizer)
     self.k_constraint = constraints.get(a_constraint)
     self.n_initializer = initializers.get(a_initializer)
     self.n_regularizer = regularizers.get(a_regularizer)
     self.n_constraint = constraints.get(a_constraint)
     self.z_initializer = initializers.get(a_initializer)
     self.z_regularizer = regularizers.get(a_regularizer)
     self.z_constraint = constraints.get(a_constraint)
     self.a_shared = a_shared
     self.k_shared = k_shared
     self.n_shared = n_shared
     self.z_shared = z_shared
     self.z_one = z_one
     if shared_axes is None:
         self.shared_axes = None
     elif not isinstance(shared_axes, (list, tuple)):
         self.shared_axes = [shared_axes]
     else:
         self.shared_axes = list(shared_axes)
    def __init__(self, units, output_dim,
                 activation='tanh',
                 return_probabilities=False,
                 name='AttentionDecoder',
                 kernel_initializer='glorot_uniform',
                 recurrent_initializer='orthogonal',
                 bias_initializer='zeros',
                 kernel_regularizer=None,
                 bias_regularizer=None,
                 activity_regularizer=None,
                 kernel_constraint=None,
                 bias_constraint=None,
                 **kwargs):
        """
        Implements an AttentionDecoder that takes in a sequence encoded by an
        encoder and outputs the decoded states 
        :param units: dimension of the hidden state and the attention matrices
        :param output_dim: the number of labels in the output space

        references:
            Bahdanau, Dzmitry, Kyunghyun Cho, and Yoshua Bengio. 
            "Neural machine translation by jointly learning to align and translate." 
            arXiv preprint arXiv:1409.0473 (2014).
        """
        self.units = units
        self.output_dim = output_dim
        self.return_probabilities = return_probabilities
        self.activation = activations.get(activation)
        self.kernel_initializer = initializers.get(kernel_initializer)
        self.recurrent_initializer = initializers.get(recurrent_initializer)
        self.bias_initializer = initializers.get(bias_initializer)

        self.kernel_regularizer = regularizers.get(kernel_regularizer)
        self.recurrent_regularizer = regularizers.get(kernel_regularizer)
        self.bias_regularizer = regularizers.get(bias_regularizer)
        self.activity_regularizer = regularizers.get(activity_regularizer)

        self.kernel_constraint = constraints.get(kernel_constraint)
        self.recurrent_constraint = constraints.get(kernel_constraint)
        self.bias_constraint = constraints.get(bias_constraint)

        super(AttentionDecoder, self).__init__(**kwargs)
        self.name = name
        self.return_sequences = True  # must return sequences
예제 #29
0
def test_serialization():
    all_activations = ['max_norm', 'non_neg',
                       'unit_norm', 'min_max_norm']
    for name in all_activations:
        fn = constraints.get(name)
        ref_fn = getattr(constraints, name)()
        assert fn.__class__ == ref_fn.__class__
        config = constraints.serialize(fn)
        fn = constraints.deserialize(config)
        assert fn.__class__ == ref_fn.__class__
    def __init__(self, nb_filter, nb_row, nb_col,
                 init='glorot_uniform', activation='linear', weights=None, dim_ordering='th',
                 W_regularizer=None, b_regularizer=None, activity_regularizer=None,
                 W_constraint=None, b_constraint=None, **kwargs):
        self.nb_filter = nb_filter
        self.nb_row = nb_row
        self.nb_col = nb_col
        self.init = initializations.get(init, dim_ordering=dim_ordering)
        self.activation = activations.get(activation)
        self.dim_ordering = dim_ordering

        self.W_regularizer = regularizers.get(W_regularizer)
        self.b_regularizer = regularizers.get(b_regularizer)
        self.activity_regularizer = regularizers.get(activity_regularizer)

        self.W_constraint = constraints.get(W_constraint)
        self.b_constraint = constraints.get(b_constraint)

        self.input_spec = [InputSpec(ndim=4)]
        self.initial_weights = weights
        super(DeConvLayer, self).__init__(**kwargs)
 def __init__(self, alpha_initializer='zeros',
              alpha_regularizer=None,
              alpha_constraint=None,
              shared_axes=None,
              **kwargs):
     super(PReLU, self).__init__(**kwargs)
     self.supports_masking = True
     self.alpha_initializer = initializers.get(alpha_initializer)
     self.alpha_regularizer = regularizers.get(alpha_regularizer)
     self.alpha_constraint = constraints.get(alpha_constraint)
     if shared_axes is None:
         self.shared_axes = None
     elif not isinstance(shared_axes, (list, tuple)):
         self.shared_axes = [shared_axes]
     else:
         self.shared_axes = list(shared_axes)
예제 #32
0
    def __init__(self,
                 alpha_initializer=Constant(3.0),
                 alpha_regularizer=None,
                 alpha_constraint=MinMaxValue(),
                 **kwargs):
        if 'input_shape' not in kwargs and 'input_dim' in kwargs:
            kwargs['input_shape'] = (kwargs.pop('input_dim'), )

        super(PLSEU, self).__init__(**kwargs)
        self.alpha_initializer = initializers.get(alpha_initializer)
        self.alpha_regularizer = regularizers.get(alpha_regularizer)
        self.alpha_constraint = constraints.get(alpha_constraint)
        self.alpha = None

        self.input_spec = InputSpec(min_ndim=2)
        self.supports_masking = True
예제 #33
0
 def __init__(self,
              r=None,
              kernel_initializer='glorot_uniform',
              kernel_regularizer=None,
              kernel_constraint=None,
              **kwargs):
     super(CCMProjection, self).__init__(**kwargs)
     self.radius = r
     self.kernel_initializer = initializers.get(kernel_initializer)
     self.kernel_regularizer = regularizers.get(kernel_regularizer)
     if self.radius == 'spherical':
         self.kernel_constraint = self.Pos()
     elif self.radius == 'hyperbolic':
         self.kernel_constraint = self.Neg()
     else:
         self.kernel_constraint = constraints.get(kernel_constraint)
예제 #34
0
파일: layers.py 프로젝트: AspirinCode/nfp
    def __init__(self,
                 input_dim,
                 output_dim,
                 embeddings_initializer='uniform',
                 embeddings_regularizer=None,
                 embeddings_constraint=None,
                 **kwargs):

        super(Embedding2D, self).__init__(**kwargs)

        self.input_dim = input_dim
        self.output_dim = output_dim

        self.embeddings_initializer = initializers.get(embeddings_initializer)
        self.embeddings_regularizer = regularizers.get(embeddings_regularizer)
        self.embeddings_constraint = constraints.get(embeddings_constraint)
예제 #35
0
 def __init__(
     self,
     gamma_initializer="ones",
     gamma_regularizer=None,
     gamma_constraint=None,
     epsilon=1e-07,
     **kwargs,
 ):
     super(WeightNorm_Conv, self).__init__(**kwargs)
     if self.rank == 1:
         self.data_format = "channels_last"
     self.gamma_initializer = sanitizedInitGet(gamma_initializer)
     self.gamma_regularizer = regularizers.get(gamma_regularizer)
     self.gamma_constraint = constraints.get(gamma_constraint)
     self.epsilon = epsilon
     self.gamma = None
 def __init__(self,
              kernel_initializer='glorot_uniform',
              kernel_regularizer=None,
              kernel_constraint=None,
              use_bias=True,
              mid_units=None,
              alpha=1.,
              keepdims=False,
              **kwargs):
     self.kernel_initializer = initializers.get(kernel_initializer)
     self.kernel_regularizer = regularizers.get(kernel_regularizer)
     self.kernel_constraint = constraints.get(kernel_constraint)
     self.use_bias = use_bias
     self.mid_units = mid_units
     self.supports_masking = True
     super(PairAttention, self).__init__(alpha, keepdims, **kwargs)
예제 #37
0
 def get_config(self):
     config = {
         'x_imputation': self.x_imputation,
         'input_decay': serialize_keras_object(self.input_decay),
         'hidden_decay': serialize_keras_object(self.hidden_decay),
         'use_decay_bias': self.use_decay_bias,
         'feed_masking': self.feed_masking,
         'masking_decay': serialize_keras_object(self.masking_decay),
         'decay_initializer': initializers.get(self.decay_initializer),
         'decay_regularizer': regularizers.get(self.decay_regularizer),
         'decay_constraint': constraints.get(self.decay_constraint)
     }
     base_config = super(GRUD, self).get_config()
     for c in ['implementation', 'reset_after']:
         del base_config[c]
     return dict(list(base_config.items()) + list(config.items()))
예제 #38
0
    def __init__(self,
                 units,
                 s=5.,
                 kernel_initializer='glorot_uniform',
                 kernel_regularizer=None,
                 kernel_constraint=None,
                 **kwargs):
        if 'input_shape' not in kwargs and 'input_dim' in kwargs:
            kwargs['input_shape'] = (kwargs.pop('input_dim'), )
        super(Dense, self).__init__(**kwargs)
        self.units = units
        self.s = s

        self.kernel_initializer = initializers.get(kernel_initializer)
        self.kernel_regularizer = regularizers.get(kernel_regularizer)
        self.kernel_constraint = constraints.get(kernel_constraint)
 def __init__(self,
              theta_initializer=None,
              theta_regularizer=None,
              theta_constraint=None,
              shared_axes=None,
              **kwargs):
     super(SoftThresholdingLayer, self).__init__(**kwargs)
     self.supports_masking = True
     self.theta_initializer = initializers.get(theta_initializer)
     self.theta_regularizer = regularizers.get(theta_regularizer)
     self.theta_constraint = constraints.get(theta_constraint)
     if shared_axes is None:
         self.shared_axes = None
     elif not isinstance(shared_axes, (list, tuple)):
         self.shared_axes = [shared_axes]
     else:
         self.shared_axes = list(shared_axes)
예제 #40
0
 def __init__(self,
              activation=None,
              bias_initializer='zeros',
              bias_regularizer=None,
              activity_regularizer=None,
              bias_constraint=None,
              **kwargs):
     if 'input_shape' not in kwargs and 'input_dim' in kwargs:
         kwargs['input_shape'] = (kwargs.pop('input_dim'), )
     super(Bias, self).__init__(**kwargs)
     self.activation = activations.get(activation)
     self.bias_initializer = initializers.get(bias_initializer)
     self.bias_regularizer = regularizers.get(bias_regularizer)
     self.activity_regularizer = regularizers.get(activity_regularizer)
     self.bias_constraint = constraints.get(bias_constraint)
     self.input_spec = InputSpec(min_ndim=2)
     self.supports_masking = True
예제 #41
0
 def __init__(self, ratio,
              return_mask=False,
              sigmoid_gating=False,
              kernel_initializer='glorot_uniform',
              kernel_regularizer=None,
              activity_regularizer=None,
              kernel_constraint=None,
              **kwargs):
     super().__init__(**kwargs)
     self.ratio = ratio  # Ratio of nodes to keep in each graph
     self.return_mask = return_mask
     self.sigmoid_gating = sigmoid_gating
     self.gating_op = K.sigmoid if self.sigmoid_gating else K.tanh
     self.kernel_initializer = initializers.get(kernel_initializer)
     self.kernel_regularizer = regularizers.get(kernel_regularizer)
     self.activity_regularizer = regularizers.get(activity_regularizer)
     self.kernel_constraint = constraints.get(kernel_constraint)
예제 #42
0
파일: core.py 프로젝트: whkanggg/hyperion
    def __init__(self, output_dim,
                 weights=None,
                 regularizer=None, 
                 constraint=None, **kwargs):

        self.output_dim = output_dim
        self.input_dim = None

        self.regularizer = regularizers.get(regularizer)
        self.constraint = constraints.get(constraint)

        self.initial_weights = weights
        self.input_spec = None

        if self.input_dim:
            kwargs['input_shape'] = (self.input_dim,)
        super(Constant, self).__init__(**kwargs)
 def __init__(self,
              input_units,
              input_metrix=False,
              input_square=False,
              add_square=False,
              kernel_initializer='uniform',
              kernel_regularizer=None,
              kernel_constraint=None,
              **kwargs):
     self.input_units = input_units
     self.input_metrix = input_metrix
     self.input_square = input_square
     self.add_square = add_square
     self.kernel_initializer = initializers.get(kernel_initializer)
     self.kernel_regularizer = regularizers.get(kernel_regularizer)
     self.kernel_constraint = constraints.get(kernel_constraint)
     super(Attention, self).__init__(**kwargs)
예제 #44
0
 def __init__(self,
              trainable_kernel=False,
              activation=None,
              kernel_initializer='glorot_uniform',
              kernel_regularizer=None,
              activity_regularizer=None,
              kernel_constraint=None,
              **kwargs):
     if 'input_shape' not in kwargs and 'input_dim' in kwargs:
         kwargs['input_shape'] = (kwargs.pop('input_dim'), )
     super(InnerProduct, self).__init__(**kwargs)
     self.trainable_kernel = trainable_kernel
     self.activation = activations.get(activation)
     self.kernel_initializer = initializers.get(kernel_initializer)
     self.kernel_regularizer = regularizers.get(kernel_regularizer)
     self.activity_regularizer = regularizers.get(activity_regularizer)
     self.kernel_constraint = constraints.get(kernel_constraint)
예제 #45
0
 def __init__(self,
              units,
              is_norm=True,
              kernel_initializer='glorot_uniform',
              kernel_regularizer=None,
              kernel_constraint=None,
              **kwargs):
     if 'input_shape' not in kwargs and 'input_dim' in kwargs:
         kwargs['input_shape'] = (kwargs.pop('input_dim'), )
     super(NormilizedDense, self).__init__(**kwargs)
     self.units = units
     self.is_norm = is_norm
     self.kernel_initializer = initializers.get(kernel_initializer)
     self.kernel_regularizer = regularizers.get(kernel_regularizer)
     self.kernel_constraint = constraints.get(kernel_constraint)
     self.input_spec = InputSpec(min_ndim=2)
     self.supports_masking = True
예제 #46
0
    def __init__(
        self,
        input_dim,
        output_dim,
        embeddings_initializer="uniform",
        embeddings_regularizer=None,
        activity_regularizer=None,
        embeddings_constraint=None,
        mask_zero=False,
        input_length=None,
        **kwargs,
    ):
        if "input_shape" not in kwargs:
            if input_length:
                kwargs["input_shape"] = (input_length,)
            else:
                kwargs["input_shape"] = (None,)
        if input_dim <= 0 or output_dim <= 0:
            raise ValueError(
                "Both `input_dim` and `output_dim` should be positive, "
                f"Received input_dim = {input_dim} "
                f"and output_dim = {output_dim}"
            )
        if (
            not base_layer_utils.v2_dtype_behavior_enabled()
            and "dtype" not in kwargs
        ):
            # In TF1, the dtype defaults to the input dtype which is typically
            # int32, so explicitly set it to floatx
            kwargs["dtype"] = backend.floatx()
        # We set autocast to False, as we do not want to cast floating- point
        # inputs to self.dtype. In call(), we cast to int32, and casting to
        # self.dtype before casting to int32 might cause the int32 values to be
        # different due to a loss of precision.
        kwargs["autocast"] = False
        super().__init__(**kwargs)

        self.input_dim = input_dim
        self.output_dim = output_dim
        self.embeddings_initializer = initializers.get(embeddings_initializer)
        self.embeddings_regularizer = regularizers.get(embeddings_regularizer)
        self.activity_regularizer = regularizers.get(activity_regularizer)
        self.embeddings_constraint = constraints.get(embeddings_constraint)
        self.mask_zero = mask_zero
        self.supports_masking = mask_zero
        self.input_length = input_length
예제 #47
0
    def __init__(self,
                 units,
                 x_imputation='zero',
                 input_decay='exp_relu',
                 hidden_decay='exp_relu',
                 use_decay_bias=True,
                 feed_masking=True,
                 masking_decay=None,
                 decay_initializer='zeros',
                 decay_regularizer=None,
                 decay_constraint=None,
                 **kwargs):
        super(GRUDCell, self).__init__(units, **kwargs)

        assert 'reset_after' not in kwargs or not kwargs['reset_after'], (
            'Only the default GRU reset gate can be used in GRU-D.')
        assert (
            'implementation' not in kwargs or kwargs['implementation'] == 1), (
                'Only Implementation-1 (larger number of smaller operations) '
                'is supported in GRU-D.')

        assert x_imputation in _SUPPORTED_IMPUTATION, (
            'x_imputation {} argument is not supported.'.format(x_imputation))
        self.x_imputation = x_imputation

        self.input_decay = get_activation(input_decay)
        self.hidden_decay = get_activation(hidden_decay)
        self.use_decay_bias = use_decay_bias

        assert (
            feed_masking or masking_decay is None
            or masking_decay == 'None'), (
                'Mask needs to be fed into GRU-D to enable the mask_decay.')
        self.feed_masking = feed_masking
        if self.feed_masking:
            self.masking_decay = get_activation(masking_decay)
            self._masking_dropout_mask = None
        else:
            self.masking_decay = None

        if (self.input_decay is not None or self.hidden_decay is not None
                or self.masking_decay is not None):
            self.decay_initializer = initializers.get(decay_initializer)
            self.decay_regularizer = regularizers.get(decay_regularizer)
            self.decay_constraint = constraints.get(decay_constraint)
예제 #48
0
    def __init__(self,
                 kernel_size,
                 strides=(1, 1),
                 padding='valid',
                 depth_multiplier=1,
                 data_format=None,
                 activation=None,
                 use_bias=True,
                 depthwise_initializer='glorot_uniform',
                 bias_initializer='zeros',
                 depthwise_regularizer=None,
                 bias_regularizer=None,
                 activity_regularizer=None,
                 depthwise_constraint=None,
                 bias_constraint=None,
                 **kwargs):
        super(DepthwiseConv2D, self).__init__(
            filters=None,
            kernel_size=kernel_size,
            strides=strides,
            padding=padding,
            data_format=data_format,
            activation=activation,
            use_bias=use_bias,
            bias_regularizer=bias_regularizer,
            activity_regularizer=activity_regularizer,
            bias_constraint=bias_constraint,
            **kwargs)
        self.depth_multiplier = depth_multiplier
        self.depthwise_initializer = initializers.get(depthwise_initializer)
        self.depthwise_regularizer = regularizers.get(depthwise_regularizer)
        self.depthwise_constraint = constraints.get(depthwise_constraint)
        self.bias_initializer = initializers.get(bias_initializer)

        self._padding = padding.upper()

        if K.image_data_format() == 'channels_last':
            self._strides = (1,) + strides + (1,)
        else:
            self._strides = (1, 1,) + strides

        if self.data_format == 'channels_last':
            self._data_format = "NHWC"
        else:
            self._data_format = "NCHW"
예제 #49
0
    def __init__(self,
                 nb_widths,
                 kernel_length=100,
                 init='uniform',
                 activation='linear',
                 weights=None,
                 padding='same',
                 strides=1,
                 data_format='channels_last',
                 use_bias=True,
                 kernel_regularizer=None,
                 bias_regularizer=None,
                 activity_regularizer=None,
                 kernel_constraint=None,
                 bias_constraint=None,
                 input_shape=None,
                 **kwargs):

        if padding.lower() not in {'valid', 'same'}:
            raise Exception('Invalid border mode for WaveletDeconvolution:',
                            padding)
        if data_format.lower() not in {'channels_first', 'channels_last'}:
            raise Exception('Invalid data format for WaveletDeconvolution:',
                            data_format)
        self.nb_widths = nb_widths
        self.kernel_length = kernel_length
        self.init = self.didactic  #initializers.get(init, data_format='channels_first')
        self.activation = activations.get(activation)
        self.padding = padding
        self.strides = strides

        self.subsample = (strides, 1)

        self.data_format = data_format.lower()

        self.kernel_regularizer = regularizers.get(kernel_regularizer)
        self.bias_regularizer = regularizers.get(bias_regularizer)
        self.activity_regularizer = regularizers.get(activity_regularizer)

        self.kernel_constraint = Pos()
        self.bias_constraint = constraints.get(bias_constraint)

        self.use_bias = use_bias
        self.initial_weights = weights
        super(WaveletDeconvolution, self).__init__(**kwargs)
    def __init__(self,
                 num_filters,
                 kernel_size,
                 strides=(1, 1),
                 padding='valid',
                 kernel_initializer='glorot_uniform',
                 kernel_constraint=None,
                 **kwargs):
        super(Erosion2D, self).__init__(**kwargs)
        self.num_filters = num_filters
        self.kernel_size = kernel_size
        self.strides = strides
        self.padding = padding

        self.kernel_initializer = initializers.get(kernel_initializer)
        self.kernel_constraint = constraints.get(kernel_constraint)
        # for we are assuming channel last
        self.channel_axis = -1
예제 #51
0
파일: decode.py 프로젝트: melton1968/kfs
    def __init__(self,
                 nb_complex,
                 filter_delays,
                 kernel_initializer='glorot_uniform',
                 kernel_regularizer=None,
                 kernel_constraint=None,
                 **kwargs):
        if 'input_shape' not in kwargs and 'input_dim' in kwargs:
            kwargs['input_shape'] = (kwargs.pop('input_dim'), )

        self.nb_complex = nb_complex
        self.filter_delays = filter_delays
        self.kernel_initializer = initializers.get(kernel_initializer)
        self.kernel_regularizer = regularizers.get(kernel_regularizer)
        self.kernel_constraint = constraints.get(kernel_constraint)

        self.input_spec = [InputSpec(ndim=3)]
        super(SpatioTemporalFilterComplex, self).__init__(**kwargs)
예제 #52
0
    def __init__(self,
                 units,
                 prec_initializer='zeros',
                 prec_regularizer=None,
                 prec_constraint=None,
                 **kwargs):

        if 'input_shape' not in kwargs and 'input_dim' in kwargs:
            kwargs['input_shape'] = (kwargs.pop('input_dim'), )
        super(GlobalProdRenormDiagNormalConstCovStdPrior2,
              self).__init__(**kwargs)

        self.units = units
        self.prec_initializer = initializers.get(prec_initializer)
        self.prec_regularizer = regularizers.get(prec_regularizer)
        self.prec_constraint = constraints.get(prec_constraint)
        self.input_spec = [InputSpec(ndim=3), InputSpec(min_ndim=2)]
        self.supports_masking = True
예제 #53
0
    def __init__(self,
                 units,
                 n_hop=5,
                 return_attend_weight=False,
                 initializer='orthogonal',
                 regularizer=None,
                 constraint=None,
                 **kwargs):
        self.units = units
        self.n_hop = n_hop
        self.return_attend_weight = return_attend_weight

        self.initializer = initializers.get(initializer)
        self.regularizer = regularizers.get(regularizer)
        self.constraint = constraints.get(constraint)

        self.supports_masking = True
        super(RecurrentAttention, self).__init__(**kwargs)
예제 #54
0
	def __init__(self, units, with_H = False, s = 5., negative_k = 100, num_batch = 100,
				 kernel_initializer='glorot_uniform',
				 kernel_regularizer=None,
				 kernel_constraint=None,
				 **kwargs):
		if 'input_shape' not in kwargs and 'input_dim' in kwargs:
			kwargs['input_shape'] = (kwargs.pop('input_dim'),)
		super(Dense, self).__init__(**kwargs)
		self.units = units
		
		self.with_H = with_H
		self.s = s
		self.negative_k = negative_k
		self.num_batch = num_batch
		
		self.kernel_initializer = initializers.get(kernel_initializer)
		self.kernel_regularizer = regularizers.get(kernel_regularizer)
		self.kernel_constraint = constraints.get(kernel_constraint)
예제 #55
0
 def __init__(self,
              filters,
              groups=1,
              hysteresis=0.1,
              H=1.0,
              bias_initializer='zeros',
              bias_regularizer=None,
              bias_constraint=None,
              useMix=False,
              **kwargs):
     super(EednConv2D, self).__init__(filters, **kwargs)
     self.H = H
     self.hysteresis = hysteresis
     self.groups = groups
     self.bias_initializer = initializers.get(bias_initializer)
     self.bias_regularizer = regularizers.get(bias_regularizer)
     self.bias_constraint = constraints.get(bias_constraint)
     self.useMix = useMix
예제 #56
0
 def __init__(
     self,
     operation,
     initializer=None,
     weight_shape=None,
     input_as_operand=False,
     constraint=None,
     trainable=True,
     **kwargs,
 ):
     """
     # Arguments
         operation: Operation to perform between input and the weight.
             It must be one of the allowed operations.
             Check `Arithmetic.allowed_operations` to see what operations you can use.
         initializer: Initializer of the weight.
             Accepts string, instance of Initializer, and numerical values.
             Set to None to use default initializer that performs identity function.
             E.g., if the operation is '+' or '-', default initializer will be 'zeros'.
             If the operation is '*' or '/', default initializer will be 'ones'.
         weight_shape: Default shape is for a scalar number.
             Shape will be inferred from initializer if it's numerical values.
             If weight_shape is set, it will broadcast initializer to have shape
             = weight_shape. If broadcasting fails, a ValueError will be raised.
         input_as_operand: Whether to use the input as operand or operator of the operation to the weight.
         trainable: Whether the weight is variable or fixed.
     """
     super(Arithmetic, self).__init__(trainable=trainable, **kwargs)
     if not operation or operation not in self.allowed_operations:
         raise ValueError(
             f"Operation '{operation}' is not one of the allowed operations: '{self.allowed_operations}'"
         )
     self.operation = operation
     self.weight_shape = weight_shape
     if initializer is None:
         initializer = "ones" if operation in "*/" else "zeros"
     try:
         self.initializer = initializers.get(initializer)
     except ValueError:
         initializer = tf.constant_initializer(initializer)
         self.initializer = initializers.get(initializer)
     self.input_as_operand = input_as_operand
     self.constraint = constraints.get(constraint)
     self.trainable = trainable
예제 #57
0
    def __init__(self, nb_kernels, kernel_dim, init='glorot_uniform', weights=None,
                 W_regularizer=None, activity_regularizer=None,
                 W_constraint=None, input_dim=None, **kwargs):
        self.init = initializers.get(init)
        self.nb_kernels = nb_kernels
        self.kernel_dim = kernel_dim
        self.input_dim = input_dim

        self.W_regularizer = regularizers.get(W_regularizer)
        self.activity_regularizer = regularizers.get(activity_regularizer)

        self.W_constraint = constraints.get(W_constraint)

        self.initial_weights = weights
        self.input_spec = [InputSpec(ndim=2)]

        if self.input_dim:
            kwargs['input_shape'] = (self.input_dim,)
        super(MinibatchDiscrimination, self).__init__(**kwargs)
예제 #58
0
    def __init__(self,
                 nb_gaussian,
                 init='normal',
                 weights=None,
                 W_regularizer=None,
                 activity_regularizer=None,
                 W_constraint=None,
                 **kwargs):
        self.nb_gaussian = nb_gaussian
        self.init = initializers.get(init)  #, dim_ordering='th')

        self.W_regularizer = regularizers.get(W_regularizer)
        self.activity_regularizer = regularizers.get(activity_regularizer)

        self.W_constraint = constraints.get(W_constraint)

        self.input_spec = [InputSpec(ndim=4)]
        self.initial_weights = weights
        super(LearningPrior, self).__init__(**kwargs)
예제 #59
0
 def __init__(self, ratio,
              return_mask=False,
              sigmoid_gating=False,
              kernel_initializer='glorot_uniform',
              kernel_regularizer=None,
              activity_regularizer=None,
              kernel_constraint=None,
              **kwargs):
     if 'input_shape' not in kwargs and 'input_dim' in kwargs:
         kwargs['input_shape'] = (kwargs.pop('input_dim'),)
     super(TopKPool, self).__init__(**kwargs)
     self.ratio = ratio  # Ratio of nodes to keep in each graph
     self.return_mask = return_mask
     self.sigmoid_gating = sigmoid_gating
     self.gating_op = K.sigmoid if self.sigmoid_gating else K.tanh
     self.kernel_initializer = initializers.get(kernel_initializer)
     self.kernel_regularizer = regularizers.get(kernel_regularizer)
     self.activity_regularizer = regularizers.get(activity_regularizer)
     self.kernel_constraint = constraints.get(kernel_constraint)
예제 #60
0
 def build(self, input_shape):
     output_shape = self.layer.get_output_shape_for(input_shape)
     if output_shape != input_shape:
         raise Exception('Cannot apply residual to layer "{}": '
                         'mismatching input and output shapes'
                         '"{}" and "{}"'.format(self.layer.name,
                                                input_shape, output_shape))
     if not self.layer.built:
         self.layer.build(input_shape)
         self.layer.built = True
     self.input_spec = [InputSpec(shape=input_shape)]
     super(Residual, self).build()
     if not self.p:
         self.p = self.add_weight((1, ),
                                  initializer='uniform',
                                  name='{}_p'.format(self.layer.name),
                                  regularizer=regularizers.get(None),
                                  constraint=constraints.get(None))
     self.res = None