如何在keras自定义正则化器中使用初始化图层权重？

Question

I'm trying to create a custom Keras regularizer that uses the distance of the layer's weights from its original weights, but what I used doesn't seem to work. It seems that this regularizer has no effect at all on the training and on the loss function.

Can you please help me find what I'm doing wrong?

class NormReg():
    def __init__(self, coeff):
        self._coeff = coeff
        self._original_weights = None

    def _norm(self, weight_matrix):
        return K.sum(K.square(weight_matrix))

    def __call__(self, weight_matrix):
        if self._original_weights is None:
            self._original_weights = weight_matrix

        diff_matrix = weight_matrix - self._original_weights
        return self._coeff * self._norm(diff_matrix)

(I'm using tensorflow as the backend)

Edit: After playing with this class a bit, I noted something strange: It's as if the regularizer object is being created over and over again in the training in each batch, which will explain why I'm getting zeros. I got to this conclusion by changing the class to -

class NormReg():
    def __init__(self, coeff):
        self._ugly_check = 1
        self._coeff = coeff
        self._original_weights = None

    def _norm(self, weight_matrix):
        return K.sum(K.square(weight_matrix))

    def __call__(self, weight_matrix):
        if self._original_weights is None:
            self._original_weights = weight_matrix
        if self._ugly_check == 1:
            self._ugly_check = 0
            return 10000
        diff_matrix = weight_matrix - self._original_weights
        return self._coeff * self._norm(diff_matrix)

And seeing that the loss does, in fact, suffer the penalty that follows from _ugly_check being 1 throughout the training.

Answer 1

I still don't fully understand all the nuts and bolts behind it, but here is where I got it wrong:

I assumed that the regularizer is used by the model during training, but it is in fact only used once when building the computational graph that the model will use. So what Keras learnt to do in its computational graph was "take the weights, subtract them from themselves, and return the coefficient times the norm". After my edit, what it learnt to do was "take the weights, and return 10000".

So this is all fixed by changing the __call__ function to:

def __call__(self, weight_matrix):
        diff_matrix = weight_matrix - K.eval(weight_matrix)
        return self._coeff * self._norm(diff_matrix)

What this does is that it now subtracts a concrete ndarray from the given weights and then computes the difference. This ndarray is, of course, the initial weights, since these are the first weights that this object encounters.

Feel free to correct me and give a more accurate answer. As I said - I still don't understand this to its fullest.