Python keras.regularizers 模块,l1_l2() 实例源码
我们从Python开源项目中,提取了以下22个代码示例,用于说明如何使用keras.regularizers.l1_l2()。
def regression(X, Y, epochs, reg_mode):
x, y = np.array(X),np.array(Y)
model = Sequential()
if reg_mode == 'linear':
model.add(Dense(1, input_dim=x.shape[1]))
model.compile(optimizer='rmsprop', metrics=['accuracy'], loss='mse')
elif reg_mode == 'logistic':
model.add(Dense(1, activation='sigmoid', loss='binary_crossentropy')
elif reg_mode == 'regularized':
reg = l1_l2(l1=0.01, l2=0.01)
model.add(Dense(1, W_regularizer=reg, loss='binary_crossentropy')
out = model.fit(x, y, nb_epoch=epochs, verbose=0, validation_split=.33)
return model, out
def _create_layers(self, input_shape, n_output):
""" Create the network layers
:param input_shape:
:param n_output:
:return: self
"""
# Hidden layers
for i, l in enumerate(self.layers):
self._model.add(Dense(units=l,
input_shape=[input_shape[-1] if i == 0 else None],
activation=self.activation[i],
kernel_regularizer=l1_l2(self.l1_reg[i], self.l2_reg[i]),
bias_regularizer=l1_l2(self.l1_reg[i], self.l2_reg[i])))
if self.dropout[i] > 0:
self._model.add(Dropout(rate=self.dropout[i]))
# Output layer
self._model.add(Dense(units=n_output, activation=self.out_activation))
def _create_layers(self, input_layer):
""" Create the encoding and the decoding layers of the autoencoder.
:return: self
"""
encode_layer = Dense(name='encoder',
units=self.n_hidden,
activation=self.enc_activation,
kernel_regularizer=l1_l2(self.l1_reg, self.l2_reg),
bias_regularizer=l1_l2(self.l1_reg, self.l2_reg))(input_layer)
n_inputs = K.int_shape(input_layer)[-1]
self._decode_layer = Dense(name='decoder',
units=n_inputs,
activation=self.dec_activation)(encode_layer)
def _create_layers(self, input_layer):
""" Create the encoding and the decoding layers of the deep autoencoder.
:param input_layer: Input size.
:return: self
"""
encode_layer = input_layer
for i, l in enumerate(self.n_hidden):
encode_layer = Dense(units=l,
name='encoder_%d' % i,
activation=self.enc_activation[i],
kernel_regularizer=l1_l2(self.l1_reg[i],
bias_regularizer=l1_l2(self.l1_reg[i], self.l2_reg[i]))(encode_layer)
self._decode_layer = encode_layer
for i, l in enumerate(self.n_hidden[-2:-(len(self.n_hidden)+1):-1] + [K.int_shape(input_layer)[1]]):
self._decode_layer = Dense(units=l,
name='decoder_%d' % i,
activation=self.dec_activation[i])(self._decode_layer)
def _create_layers(self, n_output):
""" Create the finetuning model
:param input_shape:
:param n_output:
:return: self
"""
# Hidden layers
for i, l in enumerate(self.layers):
self._model.add(Dense(input_shape=[input_shape[1] if i == 0 else None],
units=l.n_hidden,
weights=l.get_model_parameters()['enc'],
activation=l.enc_activation,
kernel_regularizer=l1_l2(l.l1_reg, l.l2_reg),
bias_regularizer=l1_l2(l.l1_reg, l.l2_reg)))
if self.dropout[i] > 0:
self._model.add(Dropout(rate=self.dropout[i]))
# Output layer
self._model.add(Dense(units=n_output, activation=self.out_activation))
def build_output(self):
mean = Dense(self.output_size, activation=MeanAct, kernel_initializer=self.init,
kernel_regularizer=l1_l2(self.l1_coef, self.l2_coef),
name='mean')(self.decoder_output)
# Plug in dispersion parameters via fake dispersion layer
disp = ConstantdispersionLayer(name='dispersion')
mean = disp(mean)
output = ColWiseMultLayer(name='output')([mean, self.sf_layer])
nb = NB(disp.theta_exp)
self.loss = nb.loss
self.extra_models['dispersion'] = lambda :K.function([], [nb.theta])([])[0].squeeze()
self.extra_models['mean_norm'] = Model(inputs=self.input_layer, outputs=mean)
self.extra_models['decoded'] = Model(inputs=self.input_layer, outputs=self.decoder_output)
self.model = Model(inputs=[self.input_layer, self.sf_layer], outputs=output)
if self.ae:
self.encoder = self.get_encoder()
def build_output(self):
disp = Dense(self.output_size, activation=dispAct,
kernel_initializer=self.init,
kernel_regularizer=l1_l2(self.l1_coef,
self.l2_coef),
name='dispersion')(self.decoder_output)
mean = Dense(self.output_size,
kernel_regularizer=l1_l2(self.l1_coef,
name='mean')(self.decoder_output)
output = ColWiseMultLayer(name='output')([mean, self.sf_layer])
output = SliceLayer(0, name='slice')([output, disp])
nb = NB(theta=disp, debug=self.debug)
self.loss = nb.loss
self.extra_models['dispersion'] = Model(inputs=self.input_layer, outputs=disp)
self.extra_models['mean_norm'] = Model(inputs=self.input_layer, outputs=self.decoder_output)
self.model = Model(inputs=[self.input_layer, outputs=output)
if self.ae:
self.encoder = self.get_encoder()
def build_output(self):
disp = Dense(self.output_size,
name='dispersion')(self.last_hidden_disp)
mean = Dense(self.output_size,
name='mean')(self.last_hidden_mean)
output = ColWiseMultLayer(name='output')([mean, outputs=mean)
self.model = Model(inputs=[self.input_layer, outputs=output)
if self.ae:
self.encoder = self.get_encoder()
def get_decoder(node_num, d, K,
n_units, nu1, nu2,
activation_fn):
# Input
y = Input(shape=(d,))
# Decoder layers
y_hat = [None] * (K + 1)
y_hat[K] = y
for i in range(K - 1, 0, -1):
y_hat[i] = Dense(n_units[i - 1],
activation=activation_fn,
W_regularizer=Reg.l1_l2(l1=nu1, l2=nu2))(y_hat[i + 1])
y_hat[0] = Dense(node_num, activation=activation_fn,
W_regularizer=Reg.l1_l2(l1=nu1, l2=nu2))(y_hat[1])
# Output
x_hat = y_hat[0] # decoder's output is also the actual output
# Decoder Model
decoder = Model(input=y, output=x_hat)
return decoder
def test_arg_l1_reg_and_l2_reg(self, model):
model._regularizer = l1_l2(0.01, 0.01)
self._build_and_assert(model)
def build_output(self):
self.loss = mean_squared_error
mean = Dense(self.output_size,
name='mean')(self.decoder_output)
output = ColWiseMultLayer(name='output')([mean, self.sf_layer])
# keep unscaled output as an extra model
self.extra_models['mean_norm'] = Model(inputs=self.input_layer, outputs=output)
if self.ae:
self.encoder = self.get_encoder()
def build_output(self):
mean = Dense(self.output_size, self.sf_layer])
self.loss = poisson_loss
self.extra_models['mean_norm'] = Model(inputs=self.input_layer, outputs=output)
if self.ae:
self.encoder = self.get_encoder()
def build_output(self):
pi = Dense(self.output_size,
name='pi')(self.decoder_output)
disp = Dense(self.output_size, disp, pi])
zinb = ZINB(pi, theta=disp, ridge_lambda=self.ridge, debug=self.debug)
self.loss = zinb.loss
self.extra_models['pi'] = Model(inputs=self.input_layer, outputs=pi)
self.extra_models['dispersion'] = Model(inputs=self.input_layer, outputs=output)
if self.ae:
self.encoder = self.get_encoder()
def build_output(self):
pi = Dense(1,
kernel_regularizer=l1_l2(self.l1_coef,
name='pi')(self.decoder_output)
disp = Dense(1,
kernel_initializer=self.init,
self.l2_coef),
name='dispersion')(self.decoder_output)
mean = Dense(self.output_size,
name='pi')(self.decoder_output)
mean = Dense(self.output_size,
name='mean')(self.decoder_output)
# NB dispersion layer
disp = ConstantdispersionLayer(name='dispersion')
mean = disp(mean)
output = ColWiseMultLayer(name='output')([mean, self.sf_layer])
zinb = ZINB(pi, theta=disp.theta_exp, outputs=pi)
self.extra_models['dispersion'] = lambda :K.function([], [zinb.theta])([])[0].squeeze()
self.extra_models['mean_norm'] = Model(inputs=self.input_layer,
name='pi')(self.last_hidden_pi)
disp = Dense(self.output_size, outputs=output)
if self.ae:
self.encoder = self.get_encoder()
def one_block_model(self, input_tensor):
"""
Method to model one cnn. It doesn't compile the model.
:param input_tensor: tensor,to Feed the two path
:return: output: tensor,the output of the cnn
"""
# localPath
loc_path = Conv2D(64, (7, 7), data_format='channels_first', padding='valid', activation='relu', use_bias=True,
kernel_regularizer=regularizers.l1_l2(self.l1_rate, self.l2_rate),
kernel_constraint=max_norm(2.),
bias_constraint=max_norm(2.), kernel_initializer='lecun_uniform', bias_initializer='zeros')(input_tensor)
loc_path = MaxPooling2D(pool_size=(4, 4), strides=1, padding='valid')(loc_path)
loc_path = Dropout(self.dropout_rate)(loc_path)
loc_path = Conv2D(64, (3, 3),
kernel_initializer='lecun_uniform', bias_initializer='zeros',
kernel_regularizer=regularizers.l1_l2(self.l1_rate,kernel_constraint=max_norm(2.),
bias_constraint=max_norm(2.))(loc_path)
loc_path = MaxPooling2D(pool_size=(2, 2), padding='valid')(loc_path)
loc_path = Dropout(self.dropout_rate)(loc_path)
# globalPath
glob_path = Conv2D(160, (13, 13),
kernel_initializer='lecun_uniform',
kernel_regularizer=regularizers.l1_l2(self.l1_rate,
kernel_constraint=max_norm(2.),
bias_constraint=max_norm(2.))(input_tensor)
glob_path = Dropout(self.dropout_rate)(glob_path)
# concatenation of the two path
path = Concatenate(axis=1)([loc_path, glob_path])
# output layer
output = Conv2D(5, (21, 21), activation='softmax',
kernel_initializer='lecun_uniform', bias_initializer='zeros')(path)
return output
def get_encoder(node_num, n_units, activation_fn):
# Input
x = Input(shape=(node_num,))
# Encoder layers
y = [None] * (K + 1)
y[0] = x # y[0] is assigned the input
for i in range(K - 1):
y[i + 1] = Dense(n_units[i], l2=nu2))(y[i])
y[K] = Dense(d,
W_regularizer=Reg.l1_l2(l1=nu1, l2=nu2))(y[K - 1])
# Encoder model
encoder = Model(input=x, output=y[K])
return encoder
def mlp(X, para):
if para['w_regularizer'] is 'auto':
para['w_regularizer'] = [para['layers']]
l1, l2 = check_w_reg(0, para['w_regularizer'], para['w_reg_values'])
model = Sequential()
model.add(Dense(para['neuron_count'][0],
input_dim=para['dims'],
activation=para['activation'],
W_regularizer=l1_l2(l1=l1, l2=l2)))
model.add(Dropout(para['dropout']))
j = 1
for i in range(para['layers'] - 1):
l1, l2 = check_w_reg(j, para['w_reg_values'])
model.add(Dense(para['neuron_count'][i+1],
activation=para['activation'],
W_regularizer=l1_l2(l1=l1, l2=l2)))
model.add(Dropout(para['dropout']))
j += 1
l1, l2 = check_w_reg(para['layers'], para['w_reg_values'])
model.add(Dense(para['neuron_last'],
activation=para['activation_out'], l2=l2)))
model.compile(loss=para['loss'],
optimizer=para['optimizer'],
metrics=['accuracy'])
if para['verbose'] >= 1:
time.sleep(0.1)
out = model.fit(X, validation_split=para['validation_split'],
epochs=para['epoch'],
verbose=para['verbose'],
batch_size=para['batch_size'])
return model, out
def __init__(self,
learning_rate=None,
vocab_size=None,
embedding_size=None,
rnn_output_size=None,
dropout_rate=None,
bidirectional_rnn=None,
rnn_type=None,
rnn_layers=None,
l1_reg=None,
l2_reg=None,
initializer=None,
word_vector_init=None):
"""
If an arg is None,it will get its value from config.active_config.
"""
self._learning_rate = learning_rate or active_config().learning_rate
self._vocab_size = vocab_size or active_config().vocab_size
self._embedding_size = embedding_size or active_config().embedding_size
self._rnn_output_size = (rnn_output_size or
active_config().rnn_output_size)
self._dropout_rate = dropout_rate or active_config().dropout_rate
self._rnn_type = rnn_type or active_config().rnn_type
self._rnn_layers = rnn_layers or active_config().rnn_layers
self._word_vector_init = (word_vector_init or
active_config().word_vector_init)
self._initializer = initializer or active_config().initializer
if self._initializer == 'vinyals_uniform':
self._initializer = RandomUniform(-0.08, 0.08)
if bidirectional_rnn is None:
self._bidirectional_rnn = active_config().bidirectional_rnn
else:
self._bidirectional_rnn = bidirectional_rnn
l1_reg = l1_reg or active_config().l1_reg
l2_reg = l2_reg or active_config().l2_reg
self._regularizer = l1_l2(l1_reg, l2_reg)
self._keras_model = None
if self._vocab_size is None:
raise ValueError('config.active_config().vocab_size cannot be '
'None! You should check your config or you can '
'explicitly pass the vocab_size argument.')
if self._rnn_type not in ('lstm', 'gru'):
raise ValueError('rnn_type must be either "lstm" or "gru"!')
if self._rnn_layers < 1:
raise ValueError('rnn_layers must be >= 1!')
if self._word_vector_init is not None and self._embedding_size != 300:
raise ValueError('If word_vector_init is not None,embedding_size '
'must be 300')
def build(self):
self.input_layer = Input(shape=(self.input_size,), name='count')
self.sf_layer = Input(shape=(1, name='size_factors')
last_hidden = self.input_layer
for i, (hid_size, hid_drop) in enumerate(zip(self.hidden_size, self.hidden_dropout)):
center_idx = int(np.floor(len(self.hidden_size) / 2.0))
if i == center_idx:
layer_name = 'center'
stage = 'center' # let downstream kNow where we are
elif i < center_idx:
layer_name = 'enc%s' % i
stage = 'encoder'
else:
layer_name = 'dec%s' % (i-center_idx)
stage = 'decoder'
# use encoder-specific l1/l2 reg coefs if given
if self.l1_enc_coef != 0. and stage in ('center', 'encoder'):
l1 = self.l1_enc_coef
else:
l1 = self.l1_coef
if self.l2_enc_coef != 0. and stage in ('center', 'encoder'):
l2 = self.l2_enc_coef
else:
l2 = self.l2_coef
last_hidden = Dense(hid_size, activation=None,
kernel_regularizer=l1_l2(l1, l2),
name=layer_name)(last_hidden)
if self.batchnorm:
last_hidden = Batchnormalization(center=True, scale=False)(last_hidden)
# Use separate act. layers to give user the option to get pre-activations
# of layers when requested
try:
last_hidden = Activation(self.activation, name='%s_act'%layer_name)(last_hidden)
except ValueError: # fallback to advanced activations
last_hidden = keras.layers.__dict__[self.activation](name='%s_act'%layer_name)(last_hidden)
if hid_drop > 0.0:
last_hidden = Dropout(hid_drop, name='%s_drop'%layer_name)(last_hidden)
self.decoder_output = last_hidden
self.build_output()
def one_block_model(self, input_tensor):
"""
Model for the twoPathways CNN.
It doesn't compile the model.
The consist of two streams,namely:
local_path anc global_path joined
in a final stream named path
local_path is articulated through:
1st convolution 64x7x7 + relu
1st maxpooling 4x4
1st Dropout with rate: 0.5
2nd convolution 64x3x3 + relu
2nd maxpooling 2x2
2nd droput with rate: 0.5
global_path is articulated through:
convolution 160x13x13 + relu
dropout with rate: 0.5
path is articulated through:
convolution 5x21x21
:param input_tensor: tensor,
kernel_constraint=max_norm(2.),
bias_constraint=max_norm(2.))(input_tensor)
loc_path = MaxPooling2D(pool_size=(4,
bias_constraint=max_norm(2.))(loc_path)
loc_path = MaxPooling2D(pool_size=(2,
bias_constraint=max_norm(2.))(input_tensor)
glob_path = Dropout(self.dropout_rate)(glob_path)
# concatenation of the two path
path = Concatenate(axis=-1)([loc_path, use_bias=True)(path)
return output
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。