Определение (начального) набора функций, подобных Хаару

Я полагаю, вы знакомы с оригинальной работой Виолы/Джонса по Эта тема.

Вы начинаете с ручного выбора типа объекта (например, прямоугольник A). Это дает вам маску, с помощью которой вы можете тренировать свои слабые классификаторы. Чтобы избежать перемещения маски попиксельно и переобучения (что заняло бы огромное количество времени и не повысило точность), вы можете указать, насколько функция перемещается в направлении x и y для каждого обученного слабого классификатора. Размер ваших прыжков зависит от размера ваших данных. Цель состоит в том, чтобы маска могла входить и выходить из обнаруженного объекта. Размер объекта также может быть переменным.

После того, как вы обучили несколько классификаторов соответствующей функции (например, положению маски), вы продолжаете обучение AdaBoost и Cascade, как обычно.

Количество функций/слабых классификаторов сильно зависит от ваших данных и экспериментальной установки (т. е. также от типа используемого вами классификатора). Вам нужно будет протестировать параметры, чтобы также узнать, какие типы функций работают лучше всего (прямоугольник/круг/объекты, похожие на тетрис и т. д.). Я работал над этим 2 года назад, и нам потребовалось довольно много времени, чтобы оценить, какие функции и эвристики генерации функций дали наилучшие результаты.

Если вы хотите с чего-то начать, просто возьмите 1 из 4 исходных функций Виолы/Джонса и обучите классификатор, привязав его к (0,0). Обучите следующий классификатор с (x, 0). Следующий с (2x,0)....(0,y), (0,2y), (0,4y),.. (x,y), (x, 2y) и т. д... И посмотрите, что бывает. Скорее всего, вы увидите, что можно использовать менее слабые классификаторы, т. е. вы можете продолжить увеличивать значения шага x/y, которые определяют, как скользит маска. Вы также можете увеличить маску или сделать что-то еще, чтобы сэкономить время. Причина, по которой эта «ленивая» генерация функций работает, заключается в AdaBoost: пока эти функции делают классификаторы немного лучше, чем случайные, AdaBoost будет объединять эти классификаторы в осмысленный классификатор.

Из вашего вопроса я могу понять, что вы хотели знать, что такое 1 62 336 функций.

Из 4 оригинальных функций альта Джонса (http://en.wikipedia.org/wiki/Viola%E2%80%93Jones_object_detection_framework)

Мы можем сгенерировать 1 62 336 функций, изменяя размер 4 исходных функций и их положение на входном изображении 24 * 24.

Например, рассмотрим один из исходных объектов, который имеет два прямоугольника, примыкающих друг к другу. Предположим, что размер каждого прямоугольника равен 1 пикселю. Первоначально, если один прямоугольник присутствует на (0,0) изображения 24 * 24, то он считается одним элементом, а теперь, если вы перемещаете его по горизонтали на один пиксель (до (1,0)), он считается вторым элементом как его положение меняется на (1,0). Таким образом, вы можете перемещать его по горизонтали до (22,0), создавая 23 функции. Точно так же, если вы перемещаетесь по вертикальной оси от (0,0) до (0,23), вы можете создать 24 функции. Теперь, если вы перемещаетесь по изображению, охватывающему каждую позицию (например, (1,1), (1,2).....(22,23)), то вы можете создать 24 * 23 = 552 функции.

Теперь, если мы рассмотрим, что ширина каждого прямоугольника составляет 2 пикселя, а высота - 1 пиксель. Первоначально, если один прямоугольник присутствует на (0,0) и перемещается по горизонтальной оси до (20,0), как сказано выше, тогда у нас может быть 21 функция, так как его высота одинакова, если мы двигаемся по вертикальной оси от (0, 0) до (0,23) у нас может быть 24 признака. Таким образом, если мы переместимся так, чтобы покрыть каждую позицию на изображении, то у нас может быть 24 * 21 = 504 функции.

Таким образом, если мы увеличиваем ширину каждого прямоугольника на один пиксель, сохраняя высоту каждого прямоугольника равной 1 пикселю каждый раз, когда мы покрываем полное изображение, так что его ширина изменяется от 1 пикселя до 24 пикселей, мы не получаем. признаков = 24*(23+21+19.....3+1)

Теперь, если мы рассмотрим ширину каждого прямоугольника в 1 пиксель и высоту в 2 пикселя. Первоначально, если один прямоугольник присутствует на (0,0) и перемещается по горизонтальной оси до (23,0), то мы можем иметь 23 функции, поскольку его ширина составляет 1 пиксель, а его высота составляет 2 пикселя, если мы двигаемся по вертикальной оси. от (0,0) до (0,22), то у нас может быть 23 признака. Таким образом, если мы переместимся так, чтобы покрыть каждую позицию на изображении, то у нас может быть 23 * 23 = 529 признаков.

Точно так же, если мы увеличим ширину каждого прямоугольника на один пиксель, сохраняя высоту каждого прямоугольника равной 2 пикселям каждый раз, когда мы покрываем полное изображение, так что его ширина изменится с 1 пикселя на 24 пикселя, мы не получим. признаков = 23*(23+21+19.....3+1)

Теперь, если мы увеличим высоту каждого прямоугольника на 1 пиксель после изменения ширины каждого прямоугольника с 1 пикселя до 24 пикселей, пока высота каждого прямоугольника не станет 24 пикселя, тогда

нет. признаков = 24*(23+21+19...3+1) + 23*(23+21+19...3+1) + 22*(23+21+19... ..3+1) +...................+ 2*(23+21+19.....3+1) + 1*(23+21+ 19.....3+1)

            = 43,200 features

Теперь, если мы рассмотрим 2-й исходный элемент альта Джонса, который имеет два прямоугольника с одним прямоугольником над другим (то есть прямоугольники расположены вертикально), поскольку это похоже на 1-й исходный элемент альта Джонса, он также будет иметь

нет. функций = 43 200

Точно так же, если мы будем следовать описанному выше процессу, из 3-го исходного элемента альта Джонса, который имеет 3 прямоугольника, расположенных вдоль горизонтального направления, мы получим

нет. признаков = 24*(22+19+16+....+4+1) + 23*(22+19+16+....+4+1) + 22*(22+19+16+ ....+4+1) +................+ 2*(22+19+16+....+4+1) + 1*(22 +19+16+....+4+1)

            =27,600

Теперь, если мы рассмотрим другой объект, который имеет 3 прямоугольника, расположенных вертикально (то есть один прямоугольник над другим), мы получим

нет. функций = 27 600 (поскольку это похоже на 3-ю оригинальную функцию Виолы Джонса)

Наконец, если мы рассмотрим 4-й оригинальный элемент альта-джонса, который имеет 4 прямоугольника, мы получим

кол-во признаков = 23*(23+21+19+......3+1) + 21*(23+21+19+......3+1) + 19*(23+ 21+19+......3+1) ...............+ 3*(23+21+19+......3+ 1) + 1*(23+21+19+......3+1)

           = 20,736

Теперь суммируя все эти характеристики получаем = 43 200 + 43 200 + 27 600 + 27 600 + 20 736

                                     = 1,62,336 features

Таким образом, из более чем 1 62 336 функций Adaboost выбирает некоторые из них, чтобы сформировать сильный классификатор.

Мне кажется, тут некоторая путаница.
Даже принятый ответ мне кажется не правильным (может я не так понял). Первоначальный алгоритм Виолы-Джонса, его основные более поздние усовершенствования, такие как алгоритм Лиенхарта-Майдта и реализация Opencv, — все они оценивают каждую функцию набора функций по очереди.
Вы можете проверить исходный код Opencv (и любую реализацию, которую вы предпочитаете).
В конце функции void CvHaarEvaluator::generateFeatures() у вас есть numFeatures, что составляет всего 162 336 для режима BASIC и размера 24x24.
И все они проверяются по очереди, когда весь набор функций предоставляется в виде из featureEvaluator (источник):

bool isStageTrained = tempStage->train( (CvFeatureEvaluator*)featureEvaluator, curNumSamples,
  _precalcValBufSize, _precalcIdxBufSize, *((CvCascadeBoostParams*)stageParams) );

Каждый слабый классификатор строится путем проверки каждого признака и выбора того, который дает наилучший результат в этой точке (в случае дерева решений процесс аналогичен).
После этого выбора соответственно изменяются веса выборок, поэтому что в следующем раунде снова будет выбрана другая функция из всего набора функций. Оценка одного признака требует больших вычислительных затрат, но умножение на число признаков может потребовать больших усилий.
Обучение всего каскада может занять несколько недель, но узким местом является не процесс оценки признаков, а сбор отрицательной выборки на последних этапах.< br> Из предоставленной вами ссылки на Википедию я прочитал:

в стандартном подокне размером 24x24 пикселя имеется в общей сложности M = 162 336 возможных функций, и было бы чрезмерно дорого оценивать их все при тестировании изображения.

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