वायोला-जोन्स के चेहरे का पता लगाने का दावा 180k की विशेषताएं हैं

Question 1

मैं वियोला-जोन्स के फेस डिटेक्शन एल्गोरिदम के एक अनुकूलन को लागू कर रहा हूं । यह तकनीक एक छवि के भीतर 24x24 पिक्सेल की सबफ़्रेम रखने पर निर्भर करती है, और बाद में हर आकार के साथ हर स्थिति में इसके अंदर आयताकार विशेषताओं को रखती है।

इन सुविधाओं में दो, तीन या चार आयत शामिल हो सकते हैं। निम्नलिखित उदाहरण प्रस्तुत है।

आयत की विशेषताएं

वे दावा करते हैं कि संपूर्ण सेट 180k (धारा 2) से अधिक है:

यह देखते हुए कि डिटेक्टर का आधार रिज़ॉल्यूशन 24x24 है, आयत सुविधाओं का संपूर्ण सेट 180,000 से अधिक है। ध्यान दें कि Haar आधार के विपरीत, आयत सुविधाओं का सेट अधूरा है।

निम्नलिखित कथनों को स्पष्ट रूप से कागज में नहीं बताया गया है, इसलिए वे मेरी ओर से मान्य हैं:

केवल 2 दो-आयत सुविधाएँ, 2 तीन-आयत सुविधाएँ और 1 चार-आयत सुविधाएँ हैं। इसके पीछे तर्क यह है कि हम हाइलाइट किए गए आयतों के बीच के अंतर को देख रहे हैं , न कि स्पष्ट रूप से रंग या चमक या उस तरह की किसी भी चीज़ को।
हम 1x1 पिक्सेल ब्लॉक के रूप में सुविधा प्रकार ए को परिभाषित नहीं कर सकते हैं; यह कम से कम 1x2 पिक्सेल का होना चाहिए। इसके अलावा, टाइप डी कम से कम 2x2 पिक्सेल होना चाहिए, और यह नियम अन्य विशेषताओं के अनुसार है।
हम फ़ीचर प्रकार A को 1x3 पिक्सेल ब्लॉक के रूप में परिभाषित नहीं कर सकते क्योंकि मध्य पिक्सेल को विभाजित नहीं किया जा सकता है, और इसे खुद से घटाकर 1x2 पिक्सेल ब्लॉक के समान है; यह सुविधा प्रकार केवल चौड़ाई के लिए भी परिभाषित किया गया है। साथ ही, सुविधा प्रकार C की चौड़ाई 3 से विभाज्य होनी चाहिए, और यह नियम अन्य विशेषताओं के अनुसार है।
हम ०.० की चौड़ाई और / या ऊंचाई के साथ एक सुविधा को परिभाषित नहीं कर सकते हैं, इसलिए हम x और y को २४ शून्य से सुविधा के आकार में बदल देते हैं।

इन मान्यताओं के आधार पर, मैंने संपूर्ण सेट को गिना है:

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++;
                }
            }
        }
    }
}

परिणाम 162,336 है ।

एक ही तरीका है कि मैं "180,000 से अधिक" वियोला और जोन्स के बारे में बात करने के लिए पाया, # 4 धारणा को छोड़ रहा है और कोड में बगों को पेश करके। इसमें क्रमशः चार लाइनें बदलना शामिल है:

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

परिणाम फिर 180,625 है । (ध्यान दें कि यह प्रभावी रूप से सुविधाओं को कभी भी सबफ़्रेम के दाएं और / या नीचे छूने से रोक देगा।)

अब निश्चित रूप से सवाल: क्या उन्होंने अपने कार्यान्वयन में गलती की है? क्या यह शून्य की सतह के साथ सुविधाओं पर विचार करने के लिए कोई मतलब है? या मैं इसे गलत तरीके से देख रहा हूं?

Question 2

करीब से देखने पर, आपका कोड मुझे सही लगता है; जिससे एक आश्चर्य होता है कि क्या मूल लेखकों के पास एक-एक बग था। मुझे लगता है कि किसी को यह देखना चाहिए कि OpenCV इसे कैसे लागू करता है!

फिर भी, एक सुझाव यह समझने में अधिक आसान बनाने के लिए के आदेश फ्लिप करने के लिए है के लिए पहले सभी आकार के ऊपर जा रहा है, तो संभावित स्थानों से अधिक पाशन आकार दिया द्वारा छोरों:

#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;
}

पिछले परिणाम के समान 162336

इसे सत्यापित करने के लिए, मैंने 4x4 विंडो के मामले का परीक्षण किया और मैन्युअल रूप से सभी मामलों की जांच की (1x2 / 2x1 और 1x3 / 3x1 आकृतियों की गणना केवल 90 डिग्री घुमाई गई):

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

Question 3

सब। वियोला और जोन्स के कागजात में अभी भी कुछ भ्रम है।

उनके CVPR'01 पेपर में यह स्पष्ट रूप से कहा गया है कि

"अधिक विशेष रूप से, हम तीन प्रकार की विशेषताओं का उपयोग करते हैं । दो-आयत सुविधा का मान दो आयताकार क्षेत्रों के भीतर पिक्सेल के योग के बीच का अंतर है। क्षेत्रों का आकार और आकार समान है और क्षैतिज या लंबवत आसन्न हैं (चित्र देखें) 1)। एक तीन-आयत सुविधा एक केंद्र आयत में योग से घटाए गए दो आयतों के भीतर योग की गणना करती है। अंत में एक चार-आयत विशेषता "।

IJCV'04 पेपर में, ठीक यही बात कही गई है। तो कुल मिलाकर, 4 सुविधाएँ । लेकिन अजीब तरह से, उन्होंने इस बार कहा कि संपूर्ण सुविधा सेट 45396 है! यह अंतिम संस्करण नहीं लगता है। मुझे लगता है कि कुछ अतिरिक्त बाधाओं को वहां पेश किया गया था, जैसे कि min_width, min_height, चौड़ाई / ऊंचाई अनुपात, और यहां तक कि स्थिति।

ध्यान दें कि दोनों पेपर उसके वेबपेज पर डाउनलोड करने योग्य हैं ।

Question 4

पूरे पेपर को न पढ़ने के बाद, आपकी बोली का शब्दांकन मुझ पर हावी हो गया

यह देखते हुए कि डिटेक्टर का आधार रिज़ॉल्यूशन 24x24 है, आयत सुविधाओं का संपूर्ण सेट 180,000 से अधिक है। ध्यान दें कि Haar आधार के विपरीत, आयत सुविधाओं का सेट अधूरा है।

"आयत सुविधाओं का सेट अधूरा है" "व्यापक सेट"

यह मुझे एक सेट अप की तरह लगता है, जहां मैं पेपर लेखक से अपेक्षा करता हूं कि वे इस स्पष्टीकरण के साथ कि वे खोज स्पेस को अधिक प्रभावी सेट तक कैसे ले जाते हैं, उदाहरण के लिए, शून्य के साथ आयतों जैसे तुच्छ मामलों से छुटकारा पाएं। सतह क्षेत्र।

संपादित करें: या अमूर्त संकेत के रूप में मशीन लर्निंग एल्गोरिथ्म के किसी प्रकार का उपयोग करना। थकाऊ सेट से तात्पर्य सभी संभावनाओं से है, न कि केवल "उचित" से।

Question 5

इस बात की कोई गारंटी नहीं है कि किसी भी पेपर का कोई भी लेखक अपनी सभी धारणाओं और निष्कर्षों में सही है। यदि आपको लगता है कि धारणा # 4 मान्य है, तो उस धारणा को बनाए रखें, और अपने सिद्धांत को आज़माएं। आप मूल लेखकों की तुलना में अधिक सफल हो सकते हैं।

Question 6

काफी अच्छा अवलोकन, लेकिन वे शून्य-पैड को 24x24 फ्रेम, या "अतिप्रवाह" कह सकते हैं और पहले पिक्सल का उपयोग करना शुरू कर सकते हैं जब यह सीमा से बाहर हो जाता है, जैसा कि घूर्णी पारियों में, या जैसा कि ब्रेटन ने कहा कि वे कुछ सुविधाओं को "तुच्छ सुविधाओं" के रूप में मान सकते हैं। और फिर उन्हें AdaBoost के साथ छोड़ दें।

इसके अलावा, मैंने आपके कोड के पायथन और मैटलैब संस्करणों को लिखा है ताकि मैं खुद कोड का परीक्षण कर सकूं (मेरे लिए आसान और मेरे लिए अनुसरण करना) और इसलिए मैं उन्हें यहां पोस्ट करूं यदि कोई उन्हें किसी समय उपयोगी लगता है।

अजगर:

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)

Question 7

अपने मूल 2001 के पेपर में वे केवल यह कहते हैं कि तीन प्रकार की सुविधाओं का उपयोग किया जाता है:

हम तीन प्रकार की सुविधाओं का उपयोग करते हैं

भी

क्षेत्रों का आकार और आकार समान है

चूंकि प्रत्येक प्रकार में दो झुकाव होते हैं, इसलिए यह मान लेना उचित है कि वे कुल में 6 सुविधाओं का उपयोग करते हैं (कम से कम सुविधाओं की कुल संख्या के लिए): 2 दो-आयत सुविधाएँ, 2 तीन-आयत सुविधाएँ और 2 चार-आयत सुविधाएँ। इस धारणा के साथ वास्तव में 180,000 से अधिक विशेषताएं हैं:

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

यदि आप एक चार-आयत प्रकार की सुविधाओं को छोड़ देते हैं (जो उनके बाद के प्रकाशन में मामला लगता है), तो कुल सुविधाओं की संख्या 162,336 है।