def __init__(self, nb_filter, filter_length, direction='Down', init='glorot_uniform', inner_init='orthogonal', forget_bias_init='one', activation='tanh', inner_activation='hard_sigmoid', border_mode="same", sub_sample=(1, 1), W_regularizer=None, U_regularizer=None, b_regularizer=None, dropout_W=0., dropout_U=0., **kwargs): self.nb_filter = nb_filter self.filter_length = filter_length self.border_mode = border_mode self.subsample = sub_sample self.direction = direction self.init = initializations.get(init) self.inner_init = initializations.get(inner_init) self.forget_bias_init = initializations.get(forget_bias_init) self.activation = activations.get(activation) self.inner_activation = activations.get(inner_activation) self.W_regularizer = regularizers.get(W_regularizer) self.U_regularizer = regularizers.get(U_regularizer) self.b_regularizer = regularizers.get(b_regularizer) self.dropout_W, self.dropout_U = dropout_W, dropout_U kwargs["nb_filter"] = nb_filter kwargs["filter_length"] = filter_length if self.dropout_W or self.dropout_U: self.uses_learning_phase = True super(DiagLSTM, self).__init__(**kwargs)
def __init__(self, input_dim, output_dim=128, train_init_cell=True, train_init_h=True, init='glorot_uniform', inner_init='orthogonal', forget_bias_init='one', input_activation='tanh', gate_activation='hard_sigmoid', output_activation='tanh', weights=None, truncate_gradient=-1, return_sequences=False): super(LSTMLayer, self).__init__() self.input_dim = input_dim self.output_dim = output_dim self.truncate_gradient = truncate_gradient self.return_sequences = return_sequences self.init = initializations.get(init) self.inner_init = initializations.get(inner_init) self.forget_bias_init = initializations.get(forget_bias_init) self.input_activation = activations.get(input_activation) self.gate_activation = activations.get(gate_activation) self.output_activation = activations.get(output_activation) self.input = T.tensor3() self.time_range = None W_z = self.init((self.input_dim, self.output_dim)).get_value(borrow=True) R_z = self.inner_init((self.output_dim, self.output_dim)).get_value(borrow=True) # self.b_z = shared_zeros(self.output_dim) W_i = self.init((self.input_dim, self.output_dim)).get_value(borrow=True) R_i = self.inner_init((self.output_dim, self.output_dim)).get_value(borrow=True) # self.b_i = shared_zeros(self.output_dim) W_f = self.init((self.input_dim, self.output_dim)).get_value(borrow=True) R_f = self.inner_init((self.output_dim, self.output_dim)).get_value(borrow=True) # self.b_f = self.forget_bias_init(self.output_dim) W_o = self.init((self.input_dim, self.output_dim)).get_value(borrow=True) R_o = self.inner_init((self.output_dim, self.output_dim)).get_value(borrow=True) # self.b_o = shared_zeros(self.output_dim) self.h_m1 = shared_zeros(shape=(1, self.output_dim), name='h0') self.c_m1 = shared_zeros(shape=(1, self.output_dim), name='c0') W = np.vstack((W_z[np.newaxis, :, :], W_i[np.newaxis, :, :], W_f[np.newaxis, :, :], W_o[np.newaxis, :, :])) # shape = (4, input_dim, output_dim) R = np.vstack((R_z[np.newaxis, :, :], R_i[np.newaxis, :, :], R_f[np.newaxis, :, :], R_o[np.newaxis, :, :])) # shape = (4, output_dim, output_dim) self.W = theano.shared(W, name='Input to hidden weights (zifo)', borrow=True) self.R = theano.shared(R, name='Recurrent weights (zifo)', borrow=True) self.b = theano.shared(np.zeros(shape=(4, self.output_dim), dtype=theano.config.floatX), name='bias', borrow=True) self.params = [self.W, self.R] if train_init_cell: self.params.append(self.c_m1) if train_init_h: self.params.append(self.h_m1) if weights is not None: self.set_weights(weights)
def __init__(self, output_dim, init='uniform', inner_init='orthogonal', forget_bias_init='one', activation='tanh', inner_activation='hard_sigmoid', U_init = 'identity', v_init = 0.1, b_init = 0, weights=None, truncate_gradient=-1, return_sequences=False, input_dim=None, input_length=None, **kwargs): self.output_dim = output_dim self.init = initializations.get(init) self.inner_init = initializations.get(inner_init) self.forget_bias_init = initializations.get(forget_bias_init) self.activation = activations.get(activation) self.inner_activation = activations.get(inner_activation) self.truncate_gradient = truncate_gradient self.return_sequences = return_sequences self.initial_weights = weights self.U_init = U_init self.v_init = v_init self.b_init = b_init self.input_dim = input_dim self.input_length = input_length if self.input_dim: kwargs['input_shape'] = (self.input_length, self.input_dim, self.input_dim_c) super(LSTM_td, self).__init__(**kwargs)
def __init__( self, output_dim, n_experts, init="glorot_uniform", inner_init="orthogonal", activation="tanh", inner_activation="hard_sigmoid", weights=None, truncate_gradient=-1, return_sequences=False, input_dim=None, input_length=None, go_backwards=False, **kwargs ): self.output_dim = output_dim self.n_experts = n_experts self.init = initializations.get(init) self.inner_init = initializations.get(inner_init) self.activation = activations.get(activation) self.inner_activation = activations.get(inner_activation) self.truncate_gradient = truncate_gradient self.return_sequences = return_sequences self.initial_weights = weights self.go_backwards = go_backwards self.input_dim = input_dim self.input_length = input_length if self.input_dim: kwargs["input_shape"] = (self.input_length, self.input_dim) super(ExpertIIgated, self).__init__(**kwargs)
def __init__(self, output_dim, init='glorot_uniform', inner_init='orthogonal', activation='sigmoid', inner_activation='hard_sigmoid', weights=None, truncate_gradient=-1, return_sequences=False, input_dim=None, input_length=None, go_backwards=False, dropout=0.0, **kwargs): self.output_dim = output_dim self.init = initializations.get(init) self.inner_init = initializations.get(inner_init) self.activation = activations.get(activation) self.inner_activation = activations.get(inner_activation) self.truncate_gradient = truncate_gradient self.return_sequences = return_sequences self.initial_weights = weights self.go_backwards = go_backwards # for dropout self.p = dropout #dropout rate self.srng = RandomStreams(seed=np.random.randint(10e6)) self.input_dim = input_dim self.input_length = input_length if self.input_dim: kwargs['input_shape'] = (self.input_length, self.input_dim) super(TGRU, self).__init__(**kwargs)
def __init__(self, w_dim, q_dim, output_dim=1, init='glorot_uniform', activation='linear', activation_w='sigmoid', activation_q='sigmoid', weights=None, regularizers=[None]*4, activity_regularizer=None, constraints=[None]*4, input_dim=None, **kwargs): self.max_words = 100 self.w_dim = w_dim self.q_dim = q_dim self.input_dim = self.w_dim + self.q_dim self.activation = activations.get(activation) self.activation_w = activations.get(activation_w) self.activation_q = activations.get(activation_q) self.init = initializations.get(init) self.output_dim = output_dim self.W_regularizer = keras.regularizers.get(regularizers[0]) self.w_regularizer = keras.regularizers.get(regularizers[1]) self.Q_regularizer = keras.regularizers.get(regularizers[2]) self.q_regularizer = keras.regularizers.get(regularizers[3]) self.activity_regularizer = keras.regularizers.get(activity_regularizer) self.W_constraint = keras.constraints.get(constraints[0]) self.w_constraint = keras.constraints.get(constraints[1]) self.Q_constraint = keras.constraints.get(constraints[2]) self.q_constraint = keras.constraints.get(constraints[3]) self.constraints = [self.W_constraint, self.w_constraint, self.Q_constraint, self.q_constraint] self.initial_weights = weights kwargs['input_shape'] = (self.w_dim + self.q_dim, self.max_words,) super(ClasRel, self).__init__(**kwargs)
def __init__(self, output_dim, nb_rows, nb_cols, n_dim = 2, init='glorot_uniform', inner_init='orthogonal', forget_bias_init='one', activation='tanh', inner_activation='hard_sigmoid', weights=None, truncate_gradient=-1, return_sequences=False, input_dim=None, input_length=None, go_backwards=False, **kwargs): self.n_dim = n_dim + 1 self.nb_cols = nb_cols self.nb_rows = nb_rows self.output_dim = 1 #output_dim self.init = initializations.get(init) self.inner_init = initializations.get(inner_init) self.forget_bias_init = initializations.get(forget_bias_init) self.activation = activations.get(activation) self.inner_activation = activations.get(inner_activation) self.truncate_gradient = truncate_gradient self.return_sequences = return_sequences self.initial_weights = weights self.go_backwards = go_backwards # Calculate the number of dimensions self.input_dim = input_dim self.input_length = input_length if self.input_dim: kwargs['input_shape'] = (self.input_length, self.input_dim) super(GridLSTM, self).__init__(**kwargs)
def __init__(self, input_dim, states_dim, causes_dim, init='glorot_uniform', inner_init='orthogonal', activation='sigmoid', gate_activation='sigmoid', weights=None, return_mode='states', truncate_gradient=-1, return_sequences=False): super(FDPCN, self).__init__() self.init = initializations.get(init) self.inner_init = initializations.get(inner_init) self.input_dim = input_dim self.states_dim = states_dim self.causes_dim = causes_dim self.truncate_gradient = truncate_gradient self.activation = activations.get(activation) self.gate_activation = activations.get(gate_activation) self.return_sequences = return_sequences self.return_mode = return_mode self.input = T.tensor3() self.I2S = self.init((self.input_dim, self.states_dim)) self.S2S = self.inner_init((self.states_dim, self.states_dim)) self.Sb = shared_zeros((self.states_dim)) self.S2C = self.init((self.states_dim, self.causes_dim)) self.C2C = self.inner_init((self.causes_dim, self.causes_dim)) self.Cb = shared_zeros((self.causes_dim)) self.CbS = shared_zeros((self.states_dim)) self.C2S = self.init((self.causes_dim, self.states_dim)) self.params = [self.I2S, self.S2S, self.Sb, self.C2S, self.C2C, self.Cb, self.S2C, self.CbS] if weights is not None: self.set_weights(weights)
def __init__(self, output_dim, init='glorot_uniform', inner_init='orthogonal', forget_bias_init='one', activation='tanh', inner_activation='hard_sigmoid', weights=None, truncate_gradient=-1, input_dim=None, input_length=None, hidden_state=None, batch_size=None, return_sequences = False,decoder=None,decoders=[], remember_state=False, go_backwards=False, **kwargs): self.output_dim = output_dim self.init = initializations.get(init) self.inner_init = initializations.get(inner_init) self.forget_bias_init = initializations.get(forget_bias_init) self.activation = activations.get(activation) self.inner_activation = activations.get(inner_activation) self.truncate_gradient = truncate_gradient self.initial_weights = weights self.initial_state = hidden_state self.batch_size = batch_size self.input_dim = input_dim self.input_length = input_length self.remember_state = remember_state self.return_sequences = return_sequences self.go_backwards = go_backwards if self.input_dim: kwargs['input_shape'] = (self.input_length, self.input_dim) super(LSTMEncoder, self).__init__(**kwargs) if decoder is not None: decoders += decoder self.decoders = decoders self.broadcast_state(decoders)# send hidden state to decoders
def __init__(self, input_dim, output_dim=128, init= 'uniform', inner_init='glorot_normal', activation='softplus', inner_activation='hard_sigmoid', gate_activation= 'tanh', weights=None, truncate_gradient=-1, return_sequences=False): super(SGU, self).__init__() self.input_dim = input_dim self.output_dim = output_dim self.truncate_gradient = truncate_gradient self.return_sequences = return_sequences self.init = initializations.get(init) self.inner_init = initializations.get(inner_init) self.activation = activations.get(activation) self.inner_activation = activations.get(inner_activation) self.gate_activation = activations.get(gate_activation) self.input = TT.tensor3() self.W = self.init((self.input_dim, self.output_dim)) self.U = self.inner_init((self.output_dim, self.output_dim)) self.b = shared_zeros((self.output_dim)) self.W_gate = self.init((self.input_dim, self.output_dim)) self.b_gate = shared_zeros((self.output_dim)) self.U_gate = self.inner_init((self.output_dim, self.output_dim)) self.params = [ self.W, self.U, self.b, self.W_gate, self.b_gate, self.U_gate ] if weights is not None: self.set_weights(weights)
def __init__(self, nb_filter, nb_row, nb_col, init='glorot_uniform', inner_init='orthogonal', forget_bias_init='one', activation='tanh', inner_activation='hard_sigmoid', dim_ordering="tf", border_mode="valid", sub_sample=(1, 1), W_regularizer=None, U_regularizer=None, b_regularizer=None, dropout_W=0., dropout_U=0., **kwargs): self.nb_filter = nb_filter self.nb_row = nb_row self.nb_col = nb_col self.init = initializations.get(init) self.inner_init = initializations.get(inner_init) self.forget_bias_init = initializations.get(forget_bias_init) self.activation = activations.get(activation) self.inner_activation = activations.get(inner_activation) self.border_mode = border_mode self.subsample = sub_sample assert dim_ordering in {'tf', "th"}, 'dim_ordering must be in {tf,"th}' self.dim_ordering = dim_ordering kwargs["nb_filter"] = nb_filter kwargs["nb_row"] = nb_row kwargs["nb_col"] = nb_col kwargs["dim_ordering"] = dim_ordering self.W_regularizer = W_regularizer self.U_regularizer = U_regularizer self.b_regularizer = b_regularizer self.dropout_W, self.dropout_U = dropout_W, dropout_U super(LSTMConv2D, self).__init__(**kwargs)
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
def __init__(self, periods, input_dim, output_dim=128, init= 'uniform', inner_init='glorot_normal', activation='softplus', inner_activation='hard_sigmoid', gate_activation= 'tanh', weights=None, truncate_gradient=-1, return_sequences=False): super(ClockworkSGU, self).__init__() self.periods = periods self.input_dim = input_dim self.output_dim = output_dim self.truncate_gradient = truncate_gradient self.return_sequences = return_sequences self.init = initializations.get(init) self.inner_init = initializations.get(inner_init) self.activation = activations.get(activation) self.inner_activation = activations.get(inner_activation) self.gate_activation = activations.get(gate_activation) self.n = self.output_dim // len(self.periods) assert self.output_dim % len(self.periods) == 0 self.input = TT.tensor3() self.W = self.init((self.input_dim, self.output_dim)) self.b = shared_zeros((self.output_dim)) self.W_gate = self.init((self.input_dim, self.output_dim)) self.b_gate = shared_zeros((self.output_dim)) self.clock_h = {} for i, period in enumerate(self.periods): self.clock_h[period] = self.inner_init(( (i + 1) * self.n, self.n )) self.clock_gates = {} for i, period in enumerate(self.periods): self.clock_gates[period] = self.inner_init(( (i + 1) * self.n, self.n )) self.params = [ self.W, self.b, self.W_gate, self.b_gate, ] self.params.extend(self.clock_h.values()) self.params.extend(self.clock_gates.values()) if weights is not None: self.set_weights(weights)
def model(self, s, a): s = s.reshape((-1, 1), ndim=2) a = a.reshape((-1, 1), ndim=2) y = T.concatenate((s, a), axis=1) for i in range(len(self.layers)): act = activations.get(self.activations[i]) y = act(T.dot(y, self.W[i]) + self.b[i]) act = activations.get("linear") y = act(T.dot(y, self.Wy) + self.by) return y
def __init__(self, output_dim, init='glorot_uniform', inner_init='orthogonal', forget_bias_init='one', activation='tanh', inner_activation='hard_sigmoid', **kwargs): self.output_dim = output_dim self.init = initializations.get(init) self.inner_init = initializations.get(inner_init) self.forget_bias_init = initializations.get(forget_bias_init) self.activation = activations.get(activation) self.inner_activation = activations.get(inner_activation) super(PeepHoleLayer, self).__init__(**kwargs)
def __init__(self, output_dim, context_dim, init='glorot_uniform', inner_init='orthogonal', activation='sigmoid', inner_activation='hard_sigmoid', **kwargs): self.output_dim = output_dim self.context_dim = context_dim self.init = initializations.get(init) self.inner_init = initializations.get(inner_init) self.activation = activations.get(activation) self.inner_activation = activations.get(inner_activation) super(BiContextLayer, self).__init__(**kwargs)
def __init__(self, output_dim, init='glorot_uniform', inner_init='orthogonal', forget_bias_init='one', activation='tanh', inner_activation='hard_sigmoid', batch_size = 64, feed_state = False, **kwargs): self.output_dim = output_dim self.init = initializations.get(init) self.inner_init = initializations.get(inner_init) self.forget_bias_init = initializations.get(forget_bias_init) self.activation = activations.get(activation) self.inner_activation = activations.get(inner_activation) self.batch_size = batch_size self.feed_state = feed_state super(LstmAttentionLayer, self).__init__(**kwargs)
def __init__(self, output_dim, depth=1, readout=False, dropout=.5, init='glorot_uniform', inner_init='orthogonal', forget_bias_init='one', activation='tanh', inner_activation='hard_sigmoid', **kwargs): self.output_dim = output_dim self.depth = depth self.readout = readout self.dropout = dropout self.init = initializations.get(init) self.inner_init = initializations.get(inner_init) self.forget_bias_init = initializations.get(forget_bias_init) self.activation = activations.get(activation) self.inner_activation = activations.get(inner_activation) self._kwargs = kwargs super(DeepLSTM, self).__init__(**kwargs)
def __init__(self, n_test, n_support, max_depth, init="glorot_uniform", activation="linear", **kwargs): """ Unlike the AttnLSTM model which only modifies the test vectors additively, this model allows for an additive update to be performed to both test and support using information from each other. Parameters ---------- n_support: int Size of support set. n_test: int Size of test set. max_depth: int Number of LSTM Embedding layers. init: string Type of weight initialization (from Keras) activation: string Activation type (ReLu/Linear/etc.) """ super(ResiLSTMEmbedding, self).__init__(**kwargs) self.init = initializations.get(init) # Set weight initialization self.activation = activations.get(activation) # Get activations self.max_depth = max_depth self.n_test = n_test self.n_support = n_support
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)
def __init__( self, encoder, decoder, code_dim, batch_size, beta=0.5, subsample=2, regularizer_scale=0.5, init="glorot_uniform", activation="linear", weights=None, input_dim=None, **kwargs ): self.regularizer_scale = regularizer_scale self.beta = beta self.max_pool = MaxPooling1D(subsample) self.encoder = encoder self.decoder = decoder self.variational = VariationalDense( code_dim, batch_size, input_dim=self.encoder.output_shape[1], regularizer_scale=regularizer_scale ) self.batch_size = batch_size self.init = initializations.get(init) self.activation = activations.get(activation) self.code_dim = code_dim self.initial_weights = weights self.input_dim = input_dim if self.input_dim: kwargs["input_shape"] = (self.input_dim,) self.input = K.placeholder(ndim=4) super(SlowSiamese, self).__init__(**kwargs)
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)
def __init__(self, input_dim, output_dim, init='glorot_uniform', activation='linear', weights=None, W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None): self.input_dim = input_dim 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 ''' #super(TimeDistributedDense, self).__init__(**kwargs) #def build(self): self.W = self.init((self.input_dim, self.output_dim)) self.b = K.zeros((self.output_dim,)) self.params = [self.W, self.b] '''
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)
def __init__(self, nb_filter, filter_length, init='uniform', activation='linear', weights=None, border_mode='valid', subsample_length=1, input_dim=None): if border_mode not in {'valid', 'same'}: raise Exception('Invalid border mode for Convolution1D:', border_mode) self.nb_filter = nb_filter self.filter_length = filter_length self.init = initializations.get(init) 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.input_dim = input_dim input_dim = self.input_dim self.W_shape = (self.nb_filter, input_dim, self.filter_length, 1) self.W = self.init(self.W_shape) self.b = K.zeros((self.nb_filter,)) self.params = [self.W, self.b]
def __init__(self, input_dim, hidden_dim, init='glorot_uniform', activation='linear', weights=None, corruption_level=0.3): self.init = initializations.get(init) self.activation = activations.get(activation) self.input_dim = input_dim self.hidden_dim = hidden_dim self.output_dim = input_dim self.input = T.matrix() self.W = self.init((self.input_dim, self.hidden_dim)) self.b = shared_zeros((self.hidden_dim)) self.b_prime = shared_zeros((self.input_dim)) numpy_rng = np.random.RandomState(123) self.theano_rng = RandomStreams(numpy_rng.randint(2 ** 30)) self.params = [self.W, self.b, self.b_prime] self.corruption_level = corruption_level if weights is not None: self.set_weights(weights)
def time_distributed_dense(x, w, b=None, dropout=None, input_dim=None, output_dim=None, timesteps=None, activation='linear'): '''Apply y.w + b for every temporal slice y of x. ''' activation = activations.get(activation) if not input_dim: # won't work with TensorFlow input_dim = K.shape(x)[2] if not timesteps: # won't work with TensorFlow timesteps = K.shape(x)[1] if not output_dim: # won't work with TensorFlow output_dim = K.shape(w)[1] if dropout is not None and 0. < dropout < 1.: # apply the same dropout pattern at every timestep ones = K.ones_like(K.reshape(x[:, 0, :], (-1, input_dim))) dropout_matrix = K.dropout(ones, dropout) expanded_dropout_matrix = K.repeat(dropout_matrix, timesteps) x = K.in_train_phase(x * expanded_dropout_matrix, x) # collapse time dimension and batch dimension together x = K.reshape(x, (-1, input_dim)) x = K.dot(x, w) if b: x = x + b # reshape to 3D tensor x = K.reshape(activation(x), (-1, timesteps, output_dim)) return x
def _step(self, x_tm1, h_tm1, c_tm1, H, u_i, u_f, u_o, u_c, w_i, w_f, w_c, w_o, w_x, w_a, v_i, v_f, v_c, v_o, b_i, b_f, b_c, b_o, b_x, b_a): s_tm1 = K.repeat(c_tm1, self.input_length) e = H + s_tm1 def a(x, states): output = K.dot(x, w_a) + b_a return output, [] _, energy, _ = K.rnn(a, e, [], mask=None) energy = activations.get('linear')(energy) energy = K.permute_dimensions(energy, (2, 0, 1)) energy = energy[0] alpha = K.softmax(energy) alpha = K.repeat(alpha, self.hidden_dim) alpha = K.permute_dimensions(alpha, (0, 2 , 1)) weighted_H = H * alpha v = K.sum(weighted_H, axis=1) xi_t = K.dot(x_tm1, w_i) + K.dot(v, v_i) + b_i xf_t = K.dot(x_tm1, w_f) + K.dot(v, v_f) + b_f xc_t = K.dot(x_tm1, w_c) + K.dot(v, v_c) + b_c xo_t = K.dot(x_tm1, w_o) + K.dot(v, v_o) + b_o i_t = self.inner_activation(xi_t + K.dot(h_tm1, u_i)) f_t = self.inner_activation(xf_t + K.dot(h_tm1, u_f)) c_t = f_t * c_tm1 + i_t * self.activation(xc_t + K.dot(h_tm1, u_c)) o_t = self.inner_activation(xo_t + K.dot(h_tm1, u_o)) h_t = o_t * self.activation(c_t) x_t = K.dot(h_t, w_x) + b_x return x_t, h_t, c_t
def __init__(self, activation=None, bias_initializer=-1, **kwargs): super(Highway, self).__init__(**kwargs) self.activation = kact.get(activation) self.bias_initializer = bias_initializer if isinstance(self.bias_initializer, int): self.bias_initializer = kinit.constant(self.bias_initializer) self.input_spec = [InputSpec(min_ndim=2)]
def __init__(self, input_dim, output_dim, init='glorot_uniform', activation='linear', truncate_gradient=-1, gamma=.1, n_steps=10, return_reconstruction=False, W_regularizer=None, activity_regularizer=None, **kwargs): self.init = initializations.get(init) self.input_dim = input_dim self.output_dim = output_dim self.gamma = gamma self.n_steps = n_steps self.truncate_gradient = truncate_gradient self.activation = activations.get(activation) self.return_reconstruction = return_reconstruction self.input = T.matrix() self.W = self.init((self.output_dim, self.input_dim)) self.params = [self.W, ] self.regularizers = [] if W_regularizer: W_regularizer.set_param(self.W) self.regularizers.append(W_regularizer) if activity_regularizer: activity_regularizer.set_layer(self) self.regularizers.append(activity_regularizer) kwargs['input_shape'] = (self.input_dim,) super(SparseCoding, self).__init__(**kwargs)
def __init__( self, units=1, activation=None, use_bias=True, kernel_initializer="zeros", bias_initializer="zeros", kernel_regularizer=None, bias_regularizer=None, **kwargs, ): """Create a Linear Model. Args: units: Positive integer, output dimension without the batch size. activation: Activation function to use. If you don't specify anything, no activation is applied. use_bias: whether to calculate the bias/intercept for this model. If set to False, no bias/intercept will be used in calculations, e.g., the data is already centered. kernel_initializer: Initializer for the `kernel` weights matrices. bias_initializer: Initializer for the bias vector. kernel_regularizer: regularizer for kernel vectors. bias_regularizer: regularizer for bias vector. **kwargs: The keyword arguments that are passed on to BaseLayer.__init__. """ 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) super().__init__(**kwargs) base_layer.keras_premade_model_gauge.get_cell("Linear").set(True)
def __init__(self, filters, kernel_size, strides=(1, 1, 1), padding='valid', data_format=None, dilation_rate=(1, 1, 1), groups=1, 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(Conv3D, self).__init__( rank=3, filters=filters, kernel_size=kernel_size, strides=strides, padding=padding, data_format=data_format, dilation_rate=dilation_rate, groups=groups, activation=activations.get(activation), use_bias=use_bias, kernel_initializer=initializers.get(kernel_initializer), bias_initializer=initializers.get(bias_initializer), kernel_regularizer=regularizers.get(kernel_regularizer), bias_regularizer=regularizers.get(bias_regularizer), activity_regularizer=regularizers.get(activity_regularizer), kernel_constraint=constraints.get(kernel_constraint), bias_constraint=constraints.get(bias_constraint), **kwargs)
def __init__(self, output_dim, support=1, featureless=False, init='glorot_uniform', activation='linear', weights=None, W_regularizer=None, num_bases=-1, b_regularizer=None, bias=False, dropout=0., **kwargs): self.init = initializers.get(init) self.activation = activations.get(activation) self.output_dim = output_dim # number of features per node self.support = support # filter support / number of weights self.featureless = featureless # use/ignore input features self.dropout = dropout assert support >= 1 self.W_regularizer = regularizers.get(W_regularizer) self.b_regularizer = regularizers.get(b_regularizer) self.bias = bias self.initial_weights = weights self.num_bases = num_bases # these will be defined during build() self.input_dim = None self.W = None self.W_comp = None self.b = None self.num_nodes = None super().__init__(**kwargs)
def __init__(self, output_dim, window_size=3, subsample_length=1, init='uniform', activation='linear', W_regularizer=None, b_regularizer=None, W_constraint=None, b_constraint=None, weights=None, bias=True, input_dim=None, input_length=None, **kwargs): self.output_dim = output_dim self.window_size = window_size self.subsample = (subsample_length, 1) self.bias = bias 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.W_constraint = constraints.get(W_constraint) self.b_constraint = constraints.get(b_constraint) self.initial_weights = weights self.supports_masking = False self.input_spec = [InputSpec(ndim=3)] self.input_dim = input_dim self.input_length = input_length if self.input_dim: kwargs['input_shape'] = (self.input_length, self.input_dim) super(GCNN, self).__init__(**kwargs)
def __init__(self, state_sync=False, decode=False, output_length=None, return_states=False, readout=False, readout_activation='linear', teacher_force=False, state_initializer=None, **kwargs): self.state_sync = state_sync self.cells = [] if decode and output_length is None: raise Exception('output_length should be specified for decoder') self.decode = decode self.output_length = output_length if decode: if output_length is None: raise Exception( 'output_length should be specified for decoder') kwargs['return_sequences'] = True self.return_states = return_states super(RecurrentModel, self).__init__(**kwargs) self.readout = readout self.readout_activation = activations.get(readout_activation) self.teacher_force = teacher_force self._optional_input_placeholders = {} if state_initializer: if type(state_initializer) in [list, tuple]: state_initializer = [ initializers.get(init) if init else initializers.get('zeros') for init in state_initializer ] else: state_initializer = initializers.get(state_initializer) self._state_initializer = state_initializer
def __init__(self, output_dim, init='glorot_uniform', inner_init='orthogonal', activation='tanh', W_regularizer=None, U_regularizer=None, b_regularizer=None, dropout_W=0.0, dropout_U=0.0, tau=100, dt=20, noise=.1, dale_ratio=None, **kwargs): self.output_dim = output_dim self.init = initializations.get(init) self.inner_init = initializations.get(inner_init) self.activation = activations.get(activation) self.W_regularizer = regularizers.get(W_regularizer) self.U_regularizer = regularizers.get(U_regularizer) self.b_regularizer = regularizers.get(b_regularizer) self.dropout_W, self.dropout_U = dropout_W, dropout_U self.tau = tau self.dt = dt self.noise = noise self.dale_ratio = dale_ratio if dale_ratio: #make dales law matrix dale_vec = np.ones(output_dim) dale_vec[int(dale_ratio * output_dim):] = -1 dale = np.diag(dale_vec) self.Dale = K.variable(dale) if self.dropout_W or self.dropout_U: self.uses_learning_phase = True super(leak_recurrent, self).__init__(**kwargs)
def __init__(self, rank, filters, kernel_size, strides=1, padding='valid', data_format=None, dilation_rate=1, activation=None, use_bias=True, kernel_initializer='lecun_normal', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, **kwargs): super(WN_Conv, self).__init__(**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) self.data_format = K.normalize_data_format(data_format) self.dilation_rate = conv_utils.normalize_tuple(dilation_rate, rank, 'dilation_rate') 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=self.rank + 2)
def __init__(self, output_dim, init='glorot_uniform', activation='linear', weights=None, W_regularizer=None, b_regularizer=None, bias=True, self_links=True, consecutive_links=True, backward_links=True, edge_weighting=False, **kwargs): self.init = initializers.get(init) self.activation = activations.get(activation) self.output_dim = output_dim # number of features per node self.self_links = self_links self.consecutive_links = consecutive_links self.backward_links = backward_links self.edge_weighting = edge_weighting self.W_regularizer = regularizers.get(W_regularizer) self.b_regularizer = regularizers.get(b_regularizer) self.bias = bias self.initial_weights = weights self.input_dim = None self.W = None self.b = None self.num_nodes = None self.num_features = None self.num_relations = None self.num_adjacency_matrices = None super(SpectralGraphConvolution, self).__init__(**kwargs)
def __init__(self, units, activation=None, use_bias_1=True, use_bias_2=True, kernel_initializer='orthogonal', bias_1_initializer='zeros', bias_2_initializer='zeros', scaler_initializer='ones', kernel_regularizer=None, bias_1_regularizer=None, bias_2_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_1_constraint=None, bias_2_constraint=None, **kwargs): if 'input_shape' not in kwargs and 'input_dim' in kwargs: kwargs['input_shape'] = (kwargs.pop('input_dim'), ) super(Mobius, self).__init__(**kwargs) self.units = units self.activation = activations.get(activation) self.use_bias_1 = use_bias_1 self.use_bias_2 = use_bias_2 self.kernel_initializer = initializers.get(kernel_initializer) self.bias_1_initializer = initializers.get(bias_1_initializer) self.bias_2_initializer = initializers.get(bias_2_initializer) self.kernel_regularizer = regularizers.get(kernel_regularizer) self.bias_1_regularizer = regularizers.get(bias_1_regularizer) self.bias_2_regularizer = regularizers.get(bias_2_regularizer) self.activity_regularizer = regularizers.get(activity_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.bias_1_constraint = constraints.get(bias_1_constraint) self.bias_2_constraint = constraints.get(bias_2_constraint) self.scaler_initializer = scaler_initializer self.input_spec = InputSpec(min_ndim=2) self.supports_masking = True
def __init__(self, units, activation=None, use_bias=True, init_criterion='he', kernel_initializer='complex', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, seed=None, **kwargs): if 'input_shape' not in kwargs and 'input_dim' in kwargs: kwargs['input_shape'] = (kwargs.pop('input_dim'), ) super(ComplexDense, self).__init__(**kwargs) self.units = units self.activation = activations.get(activation) self.use_bias = use_bias self.init_criterion = init_criterion if kernel_initializer in {'complex'}: self.kernel_initializer = kernel_initializer else: 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) if seed is None: self.seed = np.random.randint(1, 10e6) else: self.seed = seed self.input_spec = InputSpec(ndim=2) self.supports_masking = True
def __init__(self, units, activation='tanh', name='SelfAttention', kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, **kwargs): super(SelfAttention, self).__init__(**kwargs) self.units = units self.activation = activations.get(activation) self.name = name self.supports_masking = True self.kernel_initializer = initializers.get(kernel_initializer) self.kernel_regularizer = regularizers.get(kernel_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.bias_initializer = initializers.get(bias_initializer) self.bias_regularizer = regularizers.get(bias_regularizer) self.bias_constraint = constraints.get(bias_constraint)
def __init__(self, units, kl_weight, num_samples_per_epoch=2, activation=None, prior_mu=0., prior_sigma=1., kernel_m=10, bias_m=10, **kwargs): self.units = units self.kl_weight = kl_weight self.activation = activations.get(activation) self.prior_mu = prior_mu self.prior_sigma = prior_sigma self.kernel_m = kernel_m self.bias_m = bias_m self.kernel_beta_dist = VIMLTS_utils.init_beta_dist(self.kernel_m) self.bias_beta_dist = VIMLTS_utils.init_beta_dist(self.bias_m) self.epsilon = tf.constant(0.001) self.init_gauss = True self.num_samples = num_samples_per_epoch super().__init__(**kwargs)
def __init__( self, #[N,F]+[N,F] units, #16 support=1, #3 activation=None, #'RELU' use_bias=True, kernel_initializer='glorot_uniform', #Gaussian distribution L2(5e-4) 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(GraphConvolution, self).__init__(**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.supports_masking = True self.support = support assert support >= 1
def __init__(self, units, activation=None, use_bias=False, kernel_initializer='glorot_uniform', # Gaussian distribution 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(GraphConvolution, self).__init__(**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)
def __init__(self, init='glorot_uniform', transform_bias=-2, n_rel=5, mean=1, activation='linear', 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 = initializations.get(init) self.transform_bias = transform_bias self.activation = activations.get(activation) self.n_rel = n_rel self.mean = mean 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(GraphHighway, self).__init__(**kwargs)
def __init__(self, hidden_dim, hidden_recurrent_dim, init='glorot_uniform', inner_init='orthogonal', activation='tanh', W_regularizer=None, U_regularizer=None, b_regularizer=None, dropout_W=0., dropout_U=0., nb_gibbs_steps=1, persistent=False, finetune=False, Wrbm_regularizer=None, rbm=None, dropout_RBM=0., **kwargs): self.init = initializers.get(init) self.init_rbm = glorot_uniform_sigm self.inner_init = initializers.get(inner_init) self.activation = activations.get(activation) self.W_regularizer = regularizers.get(W_regularizer) self.U_regularizer = regularizers.get(U_regularizer) self.b_regularizer = regularizers.get(b_regularizer) self.dropout_W, self.dropout_U = dropout_W, dropout_U self.dropout_RBM = dropout_RBM self.Wrbm_regularizer = regularizers.get(Wrbm_regularizer) self.rbm = rbm if self.dropout_W or self.dropout_U or self.dropout_RBM: self.uses_learning_phase = True self.supports_masking = True super(RNNRBM, self).__init__(**kwargs) self.finetune = finetune self.hidden_dim = hidden_dim self.hidden_recurrent_dim = hidden_recurrent_dim self.nb_gibbs_steps = nb_gibbs_steps self.persistent = persistent
def __init__(self, units, activation=None, kernel_constraint=None, bias_constraint=None, kernel_regularizer=None, bias_regularizer=None, mu_initializer=None, sigma_initializer=None, **kwargs): super(NoisyNetDense, self).__init__(**kwargs) self.units = units self.activation = activations.get(activation) self.kernel_constraint = constraints.get( kernel_constraint) if kernel_constraint is not None else None self.bias_constraint = constraints.get( bias_constraint) if kernel_constraint is not None else None self.kernel_regularizer = regularizers.get( kernel_regularizer) if kernel_constraint is not None else None self.bias_regularizer = regularizers.get( bias_regularizer) if kernel_constraint is not None else None
def __init__(self, units, window_size=2, stride=1, return_sequences=False, go_backwards=False, stateful=False, unroll=False, activation='tanh', kernel_initializer='uniform', bias_initializer='zero', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, dropout=0, use_bias=True, input_dim=None, input_length=None, **kwargs): self.return_sequences = return_sequences self.go_backwards = go_backwards self.stateful = stateful self.unroll = unroll self.units = units self.window_size = window_size self.strides = (stride, 1) self.use_bias = use_bias self.activation = activations.get(activation) 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.dropout = dropout self.supports_masking = True self.input_spec = [InputSpec(ndim=3)] self.input_dim = input_dim self.input_length = input_length if self.input_dim: kwargs['input_shape'] = (self.input_length, self.input_dim) super(QRNN, self).__init__(**kwargs)
def __init__( self, units, activation=None, use_bias=True, kernel_initializer="glorot_uniform", bias_initializer="zeros", kernel_regularizer=None, minmax_kernel_regularizer=None, bias_regularizer=None, minmax_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(Dense, self).__init__(**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.minmax_kernel_regularizer = regularizers.get( minmax_kernel_regularizer ) self.bias_regularizer = regularizers.get(bias_regularizer) self.minmax_bias_regularizer = regularizers.get( minmax_bias_regularizer ) self.activity_regularizer = regularizers.get(activity_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.bias_constraint = constraints.get(bias_constraint) self.supports_masking = True
def __init__(self, group_stru, 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): self.group_stru=group_stru self.num_var=group_stru.shape[0] self.num_group=group_stru.shape[1] self.output_dim = group_stru.shape[1] 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) super(GKlayer, self).__init__(**kwargs)
def __init__(self, first_dim, last_dim, 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.input_dim = input_dim self.first_dim = first_dim self.last_dim = last_dim 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)] if self.input_dim: kwargs['input_shape'] = (self.input_dim, ) super(Dense3D, self).__init__(**kwargs)
def __init__(self, conv_layer, conv_num=3, return_blocks=False, gate_activation='sigmoid', **kwargs): super(GatedConvBlock, self).__init__(conv_layer,**kwargs) self.conv_num= conv_num self.return_blocks = return_blocks self.gate_activation = activations.get(gate_activation) self.conv_layers = [] self.input_spec = conv_layer.input_spec self.rank = conv_layer.rank if conv_layer.padding != 'same': raise ValueError("The padding mode of this layer must be `same`" ", But found `{}`".format(self.padding)) self.filters = conv_layer.filters//2 # create conv layers import copy for i in range(self.conv_num): new_conv_layer = copy.deepcopy(conv_layer) new_conv_layer.name = 'GatedConvBlock_{}_{}'.format(conv_layer.name, i) self.conv_layers.append(new_conv_layer)
def __init__(self, output_dim, batch_size, init='glorot_uniform', activation='tanh', weights=None, input_dim=None, regularizer_scale=1, prior_mean=0, prior_logsigma=1, **kwargs): self.prior_mean = prior_mean self.prior_logsigma = prior_logsigma self.regularizer_scale = regularizer_scale self.batch_size = batch_size self.init = initializations.get(init) self.activation = activations.get(activation) self.output_dim = output_dim 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(VariationalDense, self).__init__(**kwargs)
def __init__(self, kernel_size, strides=(1, 1), depth_multiplier=1, data_format=None, dilation_rate=(1, 1), activation='relu', depthwise_initializer='glorot_uniform', bias_initializer='zeros', depthwise_regularizer=None, bias_regularizer=None, activity_regularizer=None, depthwise_constraint=None, bias_constraint=None, standardized=False, bn_fused=True, gn_groups=32, **kwargs): super().__init__(activity_regularizer=activity_regularizer, **kwargs) self.input_spec = layers.InputSpec(ndim=4) self.kernel_size = kernel_size self.strides = strides self.depth_multiplier = depth_multiplier self.data_format = data_format self.dilation_rate = dilation_rate self.activation = activations.get(activation) self.depthwise_initializer = initializers.get(depthwise_initializer) self.bias_initializer = initializers.get(bias_initializer) self.depthwise_regularizer = regularizers.get(depthwise_regularizer) self.bias_regularizer = regularizers.get(bias_regularizer) self.depthwise_constraint = constraints.get(depthwise_constraint) self.bias_constraint = constraints.get(bias_constraint) self.standardized = standardized self.bn_fused = bn_fused self.gn_groups = gn_groups
def __init__(self, first_threshold=None, second_threshold=None, use_dimension_bias=False, use_intermediate_layer=False, intermediate_dim=64, intermediate_activation=None, from_logits=False, return_logits=False, bias_initializer=1.0, **kwargs): # if 'input_shape' not in kwargs: # kwargs['input_shape'] = [(None, input_dim,), (None, input_dim)] super(WeightedCombinationLayer, self).__init__(**kwargs) self.first_threshold = first_threshold if first_threshold is not None else INFTY self.second_threshold = second_threshold if second_threshold is not None else INFTY self.use_dimension_bias = use_dimension_bias self.use_intermediate_layer = use_intermediate_layer self.intermediate_dim = intermediate_dim self.intermediate_activation = kact.get(intermediate_activation) self.from_logits = from_logits self.return_logits = return_logits self.bias_initializer = bias_initializer self.input_spec = [InputSpec(), InputSpec(), InputSpec()]
def __init__(self, units=1, 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(Attention, self).__init__(**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.supports_masking = True
def __init__(self, units, output_dim, activation='tanh', return_probabilities=False, name='AttentionDecoder_Class', 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 ): print('__init__ : units' + str(units)) 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
def __init__(self, units, activation='linear', weights=None, kernel_initializer='glorot_uniform', kernel_regularizer=None, kernel_constraint=None, bias_initializer='uniform', bias_regularizer=None, bias_constraint=None, activity_regularizer=None, bias=True, input_dim=None, factorization=simple_tensor_factorization(), **kwargs): self.activation = activations.get(activation) self.units = units self.input_dim = input_dim self.factorization = factorization self.kernel_regularizer = regularizers.get(kernel_regularizer) self.bias_regularizer = regularizers.get(bias_regularizer) self.kernel_initializer = get_initializer(kernel_initializer) self.bias_initializer = get_initializer(bias_initializer) self.kernel_constraint = constraints.get(kernel_constraint) self.bias_constraint = constraints.get(bias_constraint) self.activity_regularizer = regularizers.get(activity_regularizer) self.bias = bias self.initial_weights = weights self.input_spec = [InputSpec(ndim=2)] if self.input_dim: kwargs['input_shape'] = (self.input_dim, ) super(DenseTensor, self).__init__(**kwargs)