如何在 Keras 中正確實現自定義活動正則化程序？

Question

我想根據安德魯·Ng的講義來實現稀疏自動編碼如圖所示這里。 它要求通過引入懲罰項（KL 散度）在自動編碼器層上應用稀疏約束。 經過一些小的更改后，我嘗試使用此處提供的方向來實現這一點。 這是由 SparseActivityRegularizer 類實現的 KL 散度和稀疏懲罰項，如下所示。

def kl_divergence(p, p_hat):
return (p * K.log(p / p_hat)) + ((1-p) * K.log((1-p) / (1-p_hat)))

class SparseActivityRegularizer(Regularizer):
sparsityBeta = None

    def __init__(self, l1=0., l2=0., p=-0.9, sparsityBeta=0.1):
        self.p = p
        self.sparsityBeta = sparsityBeta

    def set_layer(self, layer):
        self.layer = layer

    def __call__(self, loss):
        #p_hat needs to be the average activation of the units in the hidden layer.      
        p_hat = T.sum(T.mean(self.layer.get_output(True) , axis=0))

        loss += self.sparsityBeta * kl_divergence(self.p, p_hat)
        return loss

    def get_config(self):
        return {"name": self.__class__.__name__,
            "p": self.l1}

模型是這樣構建的

X_train = np.load('X_train.npy')
X_test = np.load('X_test.npy')

autoencoder = Sequential()
encoder = containers.Sequential([Dense(250, input_dim=576, init='glorot_uniform', activation='tanh', 
    activity_regularizer=SparseActivityRegularizer(p=-0.9, sparsityBeta=0.1))])

decoder = containers.Sequential([Dense(576, input_dim=250)])
autoencoder.add(AutoEncoder(encoder=encoder, decoder=decoder, output_reconstruction=True))
autoencoder.layers[0].build()
autoencoder.compile(loss='mse', optimizer=SGD(lr=0.001, momentum=0.9, nesterov=True))
loss = autoencoder.fit(X_train_tmp, X_train_tmp, nb_epoch=200, batch_size=800, verbose=True, show_accuracy=True, validation_split = 0.3)
autoencoder.save_weights('SparseAutoEncoder.h5',overwrite = True)
result = autoencoder.predict(X_test)

當我調用 fit() 函數時，我得到負的損失值，並且輸出根本不像輸入。 我想知道我哪里出錯了。 計算層的平均激活並使用此自定義稀疏正則化器的正確方法是什么？ 任何形式的幫助將不勝感激。 謝謝！

我將 Keras 0.3.1 與 Python 2.7 一起使用，因為最新的 Keras (1.0.1) 版本沒有 Autoencoder 層。

Answer 1

您已定義 self.p = -0.9 而不是原始海報和您引用的講義都使用的 0.05 值。

Answer 2

我糾正了一些錯誤：

class SparseRegularizer(keras.regularizers.Regularizer):
    
    def __init__(self, rho = 0.01,beta = 1):
        """
        rho  : Desired average activation of the hidden units
        beta : Weight of sparsity penalty term
        """
        self.rho = rho
        self.beta = beta
        

    def __call__(self, activation):
        rho = self.rho
        beta = self.beta
        # sigmoid because we need the probability distributions
        activation = tf.nn.sigmoid(activation)
        # average over the batch samples
        rho_bar = K.mean(activation, axis=0)
        # Avoid division by 0
        rho_bar = K.maximum(rho_bar,1e-10) 
        KLs = rho*K.log(rho/rho_bar) + (1-rho)*K.log((1-rho)/(1-rho_bar))
        return beta * K.sum(KLs) # sum over the layer units

    def get_config(self):
        return {
            'rho': self.rho,
            'beta': self.beta
        }