Найти неправильно классифицированные образцы на этапе проверки

Question

Я использую нейронную сеть keras для определения категории, к которой относятся данные.

self.model.compile(loss='categorical_crossentropy',
    optimizer=keras.optimizers.Adam(lr=0.001, decay=0.0001),
    metrics=[categorical_accuracy])

Функция соответствия

history = self.model.fit(self.X,
{'output': self.Y},
validation_split=0.3,
epochs=400,
batch_size=32
)

Мне интересно узнать, какие ярлыки неправильно классифицируются на этапе проверки.Похоже, хороший способ понять, что происходит под капотом.

Answer 1

Если вы заинтересованы в поиске «под капотом», я бы предложил использовать

model.predict(validation_data_x)

, чтобы увидеть оценки для каждого класса, для каждого наблюдения валидациизадавать.Это должно пролить некоторый свет на те категории, которые модель не так хорошо классифицирует.Способ прогнозирования окончательного класса -

scores = model.predict(validation_data_x)
preds = np.argmax(scores, axis=1)

. Обязательно используйте правильную ось для np.argmax (я предполагаю, что ваша ось наблюдения равна 1).Затем используйте preds для сравнения с реальным классом.

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

model.evaluate(x=validation_data_x, y=validation_data_y)

Answer 2

Я закончил тем, что создал метрику, которая печатает «идентификатор категории худшего результата + оценка» на каждой итерации.Идеи от ссылка

import tensorflow as tf
import numpy as np

class MaxIoU(object): 

def __init__(self, num_classes):                                                                                                                           
    super().__init__()                                                                                                                                     
    self.num_classes = num_classes                                                                                                                         

def max_iou(self, y_true, y_pred):                                                                                                                         
    # Wraps np_max_iou method and uses it as a TensorFlow op.                                                                                              
    # Takes numpy arrays as its arguments and returns numpy arrays as                                                                                      
    # its outputs.
    return tf.py_func(self.np_max_iou, [y_true, y_pred], tf.float32)                                                                                       

def np_max_iou(self, y_true, y_pred):                                                                                                                      
    # Compute the confusion matrix to get the number of true positives,                                                                                    
    # false positives, and false negatives                                                                                                                 
    # Convert predictions and target from categorical to integer format                                                                                    
    target = np.argmax(y_true, axis=-1).ravel()                                                                                                            
    predicted = np.argmax(y_pred, axis=-1).ravel()                                                                                                         

    # Trick from torchnet for bincounting 2 arrays together                                                                                                
    # https://github.com/pytorch/tnt/blob/master/torchnet/meter/confusionmeter.py                                                                          
    x = predicted + self.num_classes * target                                                                                                              
    bincount_2d = np.bincount(x.astype(np.int32), minlength=self.num_classes**2)                                                                           
    assert bincount_2d.size == self.num_classes**2                                                                                                         
    conf = bincount_2d.reshape((self.num_classes, self.num_classes))                                                                                       

    # Compute the IoU and mean IoU from the confusion matrix                                                                                               
    true_positive = np.diag(conf)                                                                                                                          
    false_positive = np.sum(conf, 0) - true_positive                                                                                                       
    false_negative = np.sum(conf, 1) - true_positive

    # Just in case we get a division by 0, ignore/hide the error and set the value to 0                                                                    
    with np.errstate(divide='ignore', invalid='ignore'):                                                                                                   
        iou = false_positive / (true_positive + false_positive + false_negative)                                                                           
    iou[np.isnan(iou)] = 0

    return np.max(iou).astype(np.float32) + np.argmax(iou).astype(np.float32)                                                                              

~
использование:

custom_metric = MaxIoU(len(catagories))
self.model.compile(loss='categorical_crossentropy',
    optimizer=keras.optimizers.Adam(lr=0.001, decay=0.0001),
    metrics=[categorical_accuracy, custom_metric.max_iou])

Answer 3

Вы можете использовать model.predict_classes(validation_data), чтобы получить прогнозируемые классы для ваших данных проверки и сравнить эти прогнозы с фактическими метками, чтобы выяснить, где модель была неправильной.Как то так:

predictions = model.predict_classes(validation_data)
wrong = np.where(predictions != Y_validation)