Как замаскировать функцию потерь в Keras с помощью бэкэнда TensorFlow?

Если в вашей модели есть маска, она будет распространяться слой за слоем и в конечном итоге применяться к потерям. Поэтому, если вы правильно заполняете и маскируете последовательности, потеря заполнителей заполнения будет проигнорирована.

Некоторые детали:

Объяснить весь процесс немного сложно, поэтому я просто разобью его на несколько этапов:

1. В compile() маска собирается путем вызова compute_mask() и применяется к потерям (нерелевантные строки для ясности игнорируются).

weighted_losses = [_weighted_masked_objective(fn) for fn in loss_functions]

# Prepare output masks.
masks = self.compute_mask(self.inputs, mask=None)
if masks is None:
    masks = [None for _ in self.outputs]
if not isinstance(masks, list):
    masks = [masks]

# Compute total loss.
total_loss = None
with K.name_scope('loss'):
    for i in range(len(self.outputs)):
        y_true = self.targets[i]
        y_pred = self.outputs[i]
        weighted_loss = weighted_losses[i]
        sample_weight = sample_weights[i]
        mask = masks[i]
        with K.name_scope(self.output_names[i] + '_loss'):
            output_loss = weighted_loss(y_true, y_pred,
                                        sample_weight, mask)

2. Внутри Model.compute_mask() вызывается run_internal_graph().
3. Внутри run_internal_graph() маски в модели распространяются слой за слоем от входов модели к выходам путем итеративного вызова Layer.compute_mask() для каждого слоя.

Поэтому, если вы используете в своей модели слой Masking, вам не следует беспокоиться о потере заполнителей для заполнения. Потеря этих записей будет замаскирована, как вы, вероятно, уже видели внутри _weighted_masked_objective().

Небольшой пример:

max_sentence_length = 5
character_number = 2

input_tensor = Input(shape=(max_sentence_length, character_number))
masked_input = Masking(mask_value=0)(input_tensor)
output = LSTM(3, return_sequences=True)(masked_input)
model = Model(input_tensor, output)
model.compile(loss='mae', optimizer='adam')

X = np.array([[[0, 0], [0, 0], [1, 0], [0, 1], [0, 1]],
              [[0, 0], [0, 1], [1, 0], [0, 1], [0, 1]]])
y_true = np.ones((2, max_sentence_length, 3))
y_pred = model.predict(X)
print(y_pred)
[[[ 0.          0.          0.        ]
  [ 0.          0.          0.        ]
  [-0.11980877  0.05803877  0.07880752]
  [-0.00429189  0.13382857  0.19167568]
  [ 0.06817091  0.19093043  0.26219055]]

 [[ 0.          0.          0.        ]
  [ 0.0651961   0.10283815  0.12413475]
  [-0.04420842  0.137494    0.13727818]
  [ 0.04479844  0.17440712  0.24715884]
  [ 0.11117355  0.21645413  0.30220413]]]

# See if the loss computed by model.evaluate() is equal to the masked loss
unmasked_loss = np.abs(1 - y_pred).mean()
masked_loss = np.abs(1 - y_pred[y_pred != 0]).mean()

print(model.evaluate(X, y_true))
0.881977558136

print(masked_loss)
0.881978

print(unmasked_loss)
0.917384

Как видно из этого примера, потери на замаскированной части (нули в y_pred) игнорируются, а выход model.evaluate() равен masked_loss.

РЕДАКТИРОВАТЬ:

Если есть повторяющийся слой с return_sequences=False, то маскировка распространяется (т. Е. Возвращается маска None). В RNN.compute_mask():

def compute_mask(self, inputs, mask):
    if isinstance(mask, list):
        mask = mask[0]
    output_mask = mask if self.return_sequences else None
    if self.return_state:
        state_mask = [None for _ in self.states]
        return [output_mask] + state_mask
    else:
        return output_mask

В вашем случае, если я правильно понимаю, вам нужна маска, основанная на y_true, и всякий раз, когда значение y_true равно [0, 0, 1] (горячая кодировка #), вы хотите, чтобы потеря была замаскирована. Если это так, вам нужно замаскировать значения потерь примерно так, как это сделал Дэниел.

Основное отличие - итоговое среднее значение. Среднее значение следует брать по количеству немаскированных значений, которое составляет всего K.sum(mask). Кроме того, y_true можно напрямую сравнить с вектором с горячим кодированием [0, 0, 1].

def get_loss(mask_value):
    mask_value = K.variable(mask_value)
    def masked_categorical_crossentropy(y_true, y_pred):
        # find out which timesteps in `y_true` are not the padding character '#'
        mask = K.all(K.equal(y_true, mask_value), axis=-1)
        mask = 1 - K.cast(mask, K.floatx())

        # multiply categorical_crossentropy with the mask
        loss = K.categorical_crossentropy(y_true, y_pred) * mask

        # take average w.r.t. the number of unmasked entries
        return K.sum(loss) / K.sum(mask)
    return masked_categorical_crossentropy

masked_categorical_crossentropy = get_loss(np.array([0, 0, 1]))
model = Model(input_tensor, output)
model.compile(loss=masked_categorical_crossentropy, optimizer='adam')

Выходные данные приведенного выше кода показывают, что потери вычисляются только для немаскированных значений:

model.evaluate: 1.08339476585
tf unmasked_loss: 1.08989
tf masked_loss: 1.08339

Значение отличается от вашего, потому что я изменил аргумент axis в tf.reverse с [0,1] на [1].

Если вы не используете маски, как в ответе Ю-Янга, вы можете попробовать это.

Если у вас есть целевые данные Y с длиной и дополнены значением маски, вы можете:

import keras.backend as K
def custom_loss(yTrue,yPred):

    #find which values in yTrue (target) are the mask value
    isMask = K.equal(yTrue, maskValue) #true for all mask values

    #since y is shaped as (batch, length, features), we need all features to be mask values
    isMask = K.all(isMask, axis=-1) #the entire output vector must be true
        #this second line is only necessary if the output features are more than 1

    #transform to float (0 or 1) and invert
    isMask = K.cast(isMask, dtype=K.floatx())
    isMask = 1 - isMask #now mask values are zero, and others are 1

    #multiply this by the inputs:
       #maybe you might need K.expand_dims(isMask) to add the extra dimension removed by K.all
     yTrue = yTrue * isMask   
     yPred = yPred * isMask

     return someLossFunction(yTrue,yPred)

Если у вас есть отступы только для входных данных или если Y не имеет длины, вы можете иметь свою собственную маску вне функции:

masks = [
   [1,1,1,1,1,1,0,0,0],
   [1,1,1,1,0,0,0,0,0],
   [1,1,1,1,1,1,1,1,0]
]
 #shape (samples, length). If it fails, make it (samples, length, 1). 

import keras.backend as K

masks = K.constant(masks)

Поскольку маски зависят от ваших входных данных, вы можете использовать значение маски, чтобы знать, где ставить нули, например:

masks = np.array((X_train == maskValue).all(), dtype='float64')    
masks = 1 - masks

#here too, if you have a problem with dimensions in the multiplications below
#expand masks dimensions by adding a last dimension = 1.

И сделайте так, чтобы ваша функция принимала маски извне (вы должны воссоздать функцию потерь, если вы измените входные данные):

def customLoss(yTrue,yPred):

    yTrue = masks*yTrue
    yPred = masks*yPred

    return someLossFunction(yTrue,yPred)

Кто-нибудь знает, если keras автоматически маскирует функцию потерь ?? Поскольку он предоставляет маскирующий слой и ничего не говорит о выходных данных, может быть, он делает это автоматически?