Die Gesichtserkennung von Viola-Jones beansprucht 180.000 Funktionen

Ich habe eine Anpassung des Gesichtserkennungsalgorithmus von Viola-Jones implementiert . Die Technik beruht darauf, dass ein Teilrahmen mit 24 x 24 Pixeln in einem Bild platziert wird und anschließend rechteckige Merkmale an jeder Position mit jeder möglichen Größe darin platziert werden.

Diese Features können aus zwei, drei oder vier Rechtecken bestehen. Das folgende Beispiel wird vorgestellt.

Sie behaupten, dass der vollständige Satz mehr als 180.000 beträgt (Abschnitt 2):

Angesichts der Grundauflösung des Detektors von 24 x 24 ist der erschöpfende Satz von Rechteckmerkmalen mit über 180.000 recht groß. Beachten Sie, dass im Gegensatz zur Haar-Basis der Satz von Rechteckmerkmalen übervollständig ist.

Die folgenden Aussagen werden in dem Papier nicht explizit angegeben, daher handelt es sich um Annahmen meinerseits:

1. Es gibt nur 2 Zwei-Rechteck-Features, 2 Drei-Rechteck-Features und 1 Vier-Rechteck-Feature. Die Logik dahinter ist, dass wir den Unterschied zwischen den hervorgehobenen Rechtecken beobachten, nicht explizit die Farbe oder Luminanz oder irgendetwas in dieser Art.
2. Wir können den Feature-Typ A nicht als 1x1-Pixelblock definieren. Es muss mindestens 1x2 Pixel betragen. Außerdem muss Typ D mindestens 2 x 2 Pixel groß sein, und diese Regel gilt entsprechend für die anderen Merkmale.
3. Wir können den Merkmalstyp A nicht als 1x3-Pixelblock definieren, da das mittlere Pixel nicht partitioniert werden kann und das Subtrahieren von sich selbst mit einem 1x2-Pixelblock identisch ist. Dieser Feature-Typ ist nur für gerade Breiten definiert. Außerdem muss die Breite des Merkmalstyps C durch 3 teilbar sein, und diese Regel gilt entsprechend für die anderen Merkmale.
4. Wir können kein Feature mit einer Breite und / oder Höhe von 0 definieren. Daher iterieren wir x und y bis 24 abzüglich der Größe des Features.

Basierend auf diesen Annahmen habe ich die erschöpfende Menge gezählt:

const int frameSize = 24;
const int features = 5;
// All five feature types:
const int feature[features][2] = {{2,1}, {1,2}, {3,1}, {1,3}, {2,2}};

int count = 0;
// Each feature:
for (int i = 0; i < features; i++) {
    int sizeX = feature[i][0];
    int sizeY = feature[i][1];
    // Each position:
    for (int x = 0; x <= frameSize-sizeX; x++) {
        for (int y = 0; y <= frameSize-sizeY; y++) {
            // Each size fitting within the frameSize:
            for (int width = sizeX; width <= frameSize-x; width+=sizeX) {
                for (int height = sizeY; height <= frameSize-y; height+=sizeY) {
                    count++;
                }
            }
        }
    }
}

Das Ergebnis ist 162.336 .

Der einzige Weg, den ich gefunden habe, um die "über 180.000", von denen Viola & Jones sprechen, zu approximieren, besteht darin, die Annahme Nr. 4 fallen zu lassen und Fehler in den Code einzuführen. Dies beinhaltet das Ändern von vier Zeilen in:

for (int width = 0; width < frameSize-x; width+=sizeX)
for (int height = 0; height < frameSize-y; height+=sizeY)

Das Ergebnis ist dann 180.625 . (Beachten Sie, dass dadurch effektiv verhindert wird, dass die Features jemals die rechte und / oder untere Seite des Hilfsrahmens berühren.)

Nun natürlich die Frage: Haben sie einen Fehler bei ihrer Implementierung gemacht? Ist es sinnvoll, Features mit einer Oberfläche von Null zu berücksichtigen? Oder sehe ich das falsch?

Bei näherer Betrachtung sieht Ihr Code für mich korrekt aus. was einen wundern lässt, ob die ursprünglichen Autoren einen Fehler nach dem anderen hatten. Ich denke, jemand sollte sich ansehen, wie OpenCV es implementiert!

Ein Vorschlag, der das Verständnis erleichtert, besteht darin, die Reihenfolge der for- Schleifen umzudrehen, indem zuerst alle Größen und dann die möglichen Positionen in Anbetracht der Größe durchlaufen werden:

#include <stdio.h>
int main()
{
    int i, x, y, sizeX, sizeY, width, height, count, c;

    /* All five shape types */
    const int features = 5;
    const int feature[][2] = {{2,1}, {1,2}, {3,1}, {1,3}, {2,2}};
    const int frameSize = 24;

    count = 0;
    /* Each shape */
    for (i = 0; i < features; i++) {
        sizeX = feature[i][0];
        sizeY = feature[i][1];
        printf("%dx%d shapes:\n", sizeX, sizeY);

        /* each size (multiples of basic shapes) */
        for (width = sizeX; width <= frameSize; width+=sizeX) {
            for (height = sizeY; height <= frameSize; height+=sizeY) {
                printf("\tsize: %dx%d => ", width, height);
                c=count;

                /* each possible position given size */
                for (x = 0; x <= frameSize-width; x++) {
                    for (y = 0; y <= frameSize-height; y++) {
                        count++;
                    }
                }
                printf("count: %d\n", count-c);
            }
        }
    }
    printf("%d\n", count);

    return 0;
}

mit den gleichen Ergebnissen wie die vorherigen 162336

Um dies zu überprüfen, habe ich den Fall eines 4x4-Fensters getestet und alle Fälle manuell überprüft (einfach zu zählen, da die Formen 1x2 / 2x1 und 1x3 / 3x1 nur um 90 Grad gedreht gleich sind):

2x1 shapes:
        size: 2x1 => count: 12
        size: 2x2 => count: 9
        size: 2x3 => count: 6
        size: 2x4 => count: 3
        size: 4x1 => count: 4
        size: 4x2 => count: 3
        size: 4x3 => count: 2
        size: 4x4 => count: 1
1x2 shapes:
        size: 1x2 => count: 12             +-----------------------+
        size: 1x4 => count: 4              |     |     |     |     |
        size: 2x2 => count: 9              |     |     |     |     |
        size: 2x4 => count: 3              +-----+-----+-----+-----+
        size: 3x2 => count: 6              |     |     |     |     |
        size: 3x4 => count: 2              |     |     |     |     |
        size: 4x2 => count: 3              +-----+-----+-----+-----+
        size: 4x4 => count: 1              |     |     |     |     |
3x1 shapes:                                |     |     |     |     |
        size: 3x1 => count: 8              +-----+-----+-----+-----+
        size: 3x2 => count: 6              |     |     |     |     |
        size: 3x3 => count: 4              |     |     |     |     |
        size: 3x4 => count: 2              +-----------------------+
1x3 shapes:
        size: 1x3 => count: 8                  Total Count = 136
        size: 2x3 => count: 6
        size: 3x3 => count: 4
        size: 4x3 => count: 2
2x2 shapes:
        size: 2x2 => count: 9
        size: 2x4 => count: 3
        size: 4x2 => count: 3
        size: 4x4 => count: 1

alles. Es gibt immer noch einige Verwirrung in den Papieren von Viola und Jones.

In ihrem CVPR'01-Papier wird klargestellt, dass

"Insbesondere verwenden wir drei Arten von Merkmalen. Der Wert eines Merkmals mit zwei Rechtecken ist die Differenz zwischen der Summe der Pixel in zwei rechteckigen Bereichen. Die Bereiche haben dieselbe Größe und Form und sind horizontal oder vertikal benachbart (siehe Abbildung) 1) Ein Drei-Rechteck-Merkmal berechnet die Summe innerhalb von zwei äußeren Rechtecken, die von der Summe in einem mittleren Rechteck abgezogen werden. Schließlich ein Vier-Rechteck-Merkmal ".

In der IJCV'04-Zeitung wird genau dasselbe gesagt. Also insgesamt 4 Features . Aber seltsamerweise gaben sie diesmal an, dass der umfassende Funktionsumfang 45396 beträgt! Dies scheint nicht die endgültige Version zu sein. Hier wurden vermutlich einige zusätzliche Einschränkungen eingeführt, wie z. B. min_width, min_height, width / height ratio und sogar position.

Beachten Sie, dass beide Artikel auf seiner Webseite heruntergeladen werden können .

Nachdem ich nicht die ganze Zeitung gelesen habe, fällt mir der Wortlaut Ihres Zitats auf

Angesichts der Grundauflösung des Detektors von 24 x 24 ist der erschöpfende Satz von Rechteckmerkmalen mit über 180.000 recht groß. Beachten Sie, dass im Gegensatz zur Haar-Basis der Satz von Rechteckmerkmalen übervollständig ist.

"Der Satz von Rechteckmerkmalen ist übervollständig" "Vollständiger Satz"

Es klingt für mich wie ein Setup, bei dem ich erwarte, dass der Papierschreiber eine Erklärung dafür abgibt, wie er den Suchraum auf ein effektiveres Set reduziert, indem er beispielsweise triviale Fälle wie Rechtecke mit Null beseitigt Oberfläche.

edit: oder mit einer Art maschinellem Lernalgorithmus, wie die Zusammenfassung andeutet. Vollständiges Set beinhaltet alle Möglichkeiten, nicht nur "vernünftige".

Es gibt keine Garantie dafür, dass ein Autor eines Papiers in all seinen Annahmen und Ergebnissen korrekt ist. Wenn Sie der Meinung sind, dass die Annahme Nr. 4 gültig ist, behalten Sie diese Annahme bei und probieren Sie Ihre Theorie aus. Sie sind möglicherweise erfolgreicher als die ursprünglichen Autoren.

Ziemlich gute Beobachtung, aber sie könnten den 24x24-Frame implizit auf Null setzen oder "überlaufen" und die ersten Pixel verwenden, wenn sie außerhalb der Grenzen liegen, wie bei Rotationsverschiebungen oder wie Breton sagte, sie könnten einige Features als "triviale Features" betrachten. und verwerfen Sie sie dann mit dem AdaBoost.

Außerdem habe ich Python- und Matlab-Versionen Ihres Codes geschrieben, damit ich den Code selbst testen kann (einfacher zu debuggen und für mich zu befolgen), und ich poste sie hier, wenn jemand sie irgendwann nützlich findet.

Python:

frameSize = 24;
features = 5;
# All five feature types:
feature = [[2,1], [1,2], [3,1], [1,3], [2,2]]

count = 0;
# Each feature:
for i in range(features):
    sizeX = feature[i][0]
    sizeY = feature[i][1]
    # Each position:
    for x in range(frameSize-sizeX+1):
        for y in range(frameSize-sizeY+1):
            # Each size fitting within the frameSize:
            for width in range(sizeX,frameSize-x+1,sizeX):
                for height in range(sizeY,frameSize-y+1,sizeY):
                    count=count+1
print (count)

Matlab:

frameSize = 24;
features = 5;
% All five feature types:
feature = [[2,1]; [1,2]; [3,1]; [1,3]; [2,2]];

count = 0;
% Each feature:
for ii = 1:features
    sizeX = feature(ii,1);
    sizeY = feature(ii,2);
    % Each position:
    for x = 0:frameSize-sizeX
        for y = 0:frameSize-sizeY
            % Each size fitting within the frameSize:
            for width = sizeX:sizeX:frameSize-x
                for height = sizeY:sizeY:frameSize-y
                    count=count+1;
                end
            end
        end
    end
end

display(count)

In ihrer ursprünglichen Arbeit von 2001 geben sie nur an, dass drei Arten von Merkmalen verwendet werden:

Wir verwenden drei Arten von Funktionen

Ebenfalls

Die Regionen haben die gleiche Größe und Form

Da jede Art zwei Ausrichtungen hat, ist anzunehmen, dass sie insgesamt 6 Merkmale verwenden (zumindest für die Berechnung der Gesamtzahl der Merkmale): 2 Merkmale mit zwei Rechtecken, 2 Merkmale mit drei Rechtecken und 2 Merkmale mit vier Rechtecken. Mit dieser Annahme gibt es tatsächlich über 180.000 Merkmale:

feature_types = [(1,2), (2,1), (1,3), (3,1), (2,2), (2,2)]
window_size = (24,24)

total_features = 0
for f_type in feature_types:
    for f_height in range(f_type[0], window_size[0] + 1, f_type[0]):
        for f_width in range(f_type[1], window_size[1] + 1, f_type[1]):
            total_features += (window_size[0] - f_height + 1) * (window_size[1] - f_width + 1)
            
print(total_features)
# 183072

Wenn Sie einen Feature-Typ mit vier Rechtecken löschen (was in der späteren Veröffentlichung der Fall zu sein scheint), beträgt die Gesamtzahl der Features 162.336.