keras 自定义：激活函数，神经网络层，损失函数，正则化器，学习率

首先，您需要使用 backend定义一个函数。 例如，这是我实现swish激活功能的方式

from keras import backend as K
def swish(x, beta=1.0):
    return x * K.sigmoid(beta * x)

如果要将字符串用作自定义函数的别名，则必须向Keras注册自定义对象。 可以这样完成：

from keras.utils.generic_utils import get_custom_objects
get_custom_objects().update({'swish': Activation(swish)})

直接将激活名称应用到网络层：

model.add(Conv2D(64, (3, 3), activation='swish'))

MFM是我定义的层函数，要用到了Lambda这个函数。

import os
from keras.layer import Lambda,concatenate
from keras.backend import maximum,expand_dims
import keras.activations as activation
 
def MFM(net):
    n = int(net.get_shape().as_list()[-1]/2)
    tmp = []
    for i in range(n):
        tmp_value = maximum(net[...,i],net[...,-(i+1)])
        tmp.append(expand_dims(tmp_value,axis=-1))
    return concatenate(tmp,axis=-1)
 

应用：

net =Lambda(MFM,name='MFM')(net)

定义损失函数

def mean_squared_error(y_true, y_pred):
    return K.mean(K.square(y_pred - y_true), axis=-1)

应用：

model.compile(optimizer='rmsprop',loss=mean_squared_error)

再如：

from keras.layers import Input,Embedding,LSTM,Dense
from keras.models import Model
from keras import backend as K
word_size = 128
nb_features = 10000
nb_classes = 10
encode_size = 64
input = Input(shape=(None,))
embedded = Embedding(nb_features,word_size)(input)
encoder = LSTM(encode_size)(embedded)
predict = Dense(nb_classes, activation='softmax')(encoder)

def mycrossentropy(y_true, y_pred, e=0.1):
    loss1 = K.categorical_crossentropy(y_true, y_pred)
    loss2 = K.categorical_crossentropy(K.ones_like(y_pred)/nb_classes, y_pred)
    return (1-e)*loss1 + e*loss2
 
model = Model(inputs=input, outputs=predict)
model.compile(optimizer='adam', loss=mycrossentropy)

任何输入一个权重矩阵、返回一个损失贡献张量的函数，都可以用作正则化器，例如：

 from keras import backend as K​
 def l1_reg(weight_matrix):
     return 0.01 * K.sum(K.abs(weight_matrix))
 ​
 model.add(Dense(64, input_dim=64,kernel_regularizer=l1_reg))

def lr_scheduler(epoch):
    return learning_rate * (0.5 ** (epoch // lr_drop))
 
reduce_lr = keras.callbacks.LearningRateScheduler(lr_scheduler)
# 该回调函数是用于动态设置学习率
....

....
historytemp = model.fit_generator(datagen.flow(x_train, y_train,
                                                       batch_size=batch_size),
                                          steps_per_epoch=x_train.shape[0] // batch_size,
                                          epochs=maxepoches,
                                          validation_data=(x_test, y_test), callbacks=[reduce_lr], verbose=2)