Jak kategoryzować True Negatives w przesuwaniu obiektów okna?

Question

Zbieram wyniki z mojego algorytmu wykrywającego obraz. Zasadniczo to, co robię, polega na tym, że z zestawu obrazów (o rozmiarze 320 x 480), uruchomiłbym przesuwne okno o wielkości 64x128, a także pod pewnymi predefiniowanymi skalami.

Rozumiem, że:

• prawdziwie dodatnich = kiedy moi wykryte nakładania szyb (w określonych przecięcia Rodzaj/ciężkości) z gruntu prawdy (adnotacją obwiedni)
• fałszywych alarmów = gdy algorytm daje ja pozytywne okna, które są poza prawdą grond.
• Fałszywe Negatywy = gdy nie udało mi się uzyskać pozytywnego okna, podczas gdy prawidłowa adnotacja stwierdza, że ​​istnieje obiekt.

Ale co z True Negatives? Czy te prawdziwe negatywy są wszystkimi oknami, które mój klasyfikator daje mi negatywne wyniki? Brzmi to dziwnie, ponieważ przesuwałam małe okno (64x128) o 4 piksele na raz, a mam około 8 różnych skal używanych do wykrywania. Gdybym to zrobił, miałbym wiele prawdziwych negatywów na obraz.

Czy mogę przygotować zestaw czystych negatywnych obrazów (żadnych obiektów/ludzi w ogóle), gdzie po prostu przesuwam się przez nie, i jeśli jest jeden lub więcej pozytywnych detekcji w każdym z tych obrazów, uważam to za fałszywe Negatywny i na odwrót?

Oto przykład obraz (z zielonymi rects jak prawdy ziemią)

Answer 1

Zawsze widziałem cztery terminy jak:

• Fałszywe negatywne; Wynik powinien być dodatni, ale ujemny.
• Fałszywe pozytywne; Wynik powinien być ujemny, ale pozytywny.
• Prawda pozytywna; Wynik powinien być pozytywny i pozytywny.
• Prawdziwe negatywne; Wynik powinien być ujemny i ujemny.

W twoim przypadku, jeśli dobrze rozumiem, próbujesz wykryć, czy na twoim obrazie znajdują się obiekty. Fałszywy negatyw oznaczałby zatem, że był obiekt (wynik powinien być dodatni), ale algorytm go nie wykrył (i dlatego został zwrócony ujemnie). Prawdziwym negatywem jest po prostu algorytm poprawnie stwierdzający, że obszar, który sprawdził, nie mieści się w obiekcie.

Można wybrać ignorowanie wartości ujemnych, ale mogą one zostać użyte do dalszego szkolenia algorytmu (np. Za pomocą algorytmu, który szuka obu, zamiast ustawiania wszystkiego, co nie jest rozpoznawane jako fałszywe).

Answer 2

Istnieje ładne wyjaśnienie here. Wynik F1 wyjaśniony na wiki i here jest pomocny w mierzeniu sukcesu.

mam próbę napisać funkcję, która oblicza wynik F1:

/// <param name="realClasses">Class names that exists on the image. A class name may exists more than once.</param> 
    /// <param name="foundClasses">Predicted class names. A class name may exists more than once.</param> 
    private static void findPosNeg(List<string> realClasses, List<string> foundClasses, out int truePositive, out int falsePositive, out int falseNegative) 
    {    
     Dictionary<string, int> dicReal = new Dictionary<string, int>(StringComparer.InvariantCultureIgnoreCase); 
     Dictionary<string, int> dicFound = new Dictionary<string, int>(StringComparer.InvariantCultureIgnoreCase); 
     #region fill dictionaries 
     foreach (string className in realClasses) 
     { 
      if (!dicReal.ContainsKey(className)) 
       dicReal[className] = 1; 
      else 
       dicReal[className]++; 
     } 
     foreach (string className in foundClasses) 
     { 
      if (!dicFound.ContainsKey(className)) 
       dicFound[className] = 1; 
      else 
       dicFound[className]++; 
     } 
     #endregion 

     truePositive = 0; 
     falsePositive = 0; 
     falseNegative = 0; 
     foreach (string className in dicFound.Keys) 
     { 
      if (!dicReal.ContainsKey(className)) 
       falsePositive += dicFound[className]; 
      else 
      { 
       int found = dicFound[className]; 
       int real = dicReal[className]; 
       truePositive += Math.Min(found, real); 
       if (real > found) 
        falseNegative += real - found; 
       else if (found > real) 
        falsePositive += found - real; 
      } 
     } 
     foreach (string className in dicReal.Keys) 
      if (!dicFound.ContainsKey(className)) 
       falseNegative += dicReal[className]; 

    } 
    /// <summary> 
    /// Calculates F1Score ref:https://en.wikipedia.org/wiki/Precision_and_recall 
    /// </summary> 
    private static double calc_F1Score(int truePositive, int falsePositive, int falseNegative, out double precision, out double recall) 
    { 
     precision = (double)truePositive/((double)truePositive + (double)falsePositive); 
     recall = (double)truePositive/((double)truePositive + (double)falseNegative); 
     double div = (precision + recall); 
     return (div != 0d) ? 2d * precision * recall/div : 0d; 
    }