Классификатор огрн: Коды ОГРН – расшифровка, проверка, возможности поиска | Свой бизнес… Отлично!

Достаточно просто, но если вы что-то знаете о классификации изображений, вы поймете, что это:

• Вариант точки обзора
• Изменение шкалы
• Деформация
• Окклюзия
• Фоновый беспорядок
• Внутриклассовая вариация

Проблема значительно сложнее , чем может показаться на поверхности.

Просто случайным образом угадав , вы сможете достичь 50% точности (так как есть только две метки класса).Алгоритм машинного обучения должен достичь точности> 50%, чтобы продемонстрировать, что он действительно чему-то «научился» (или обнаружил базовый шаблон в данных).

Лично мне нравится задача «Собаки против кошек», особенно за обучение глубокому обучению.

Почему?

Набор данных достаточно прост, чтобы осознать — всего два класса: «собака» или «кошка» .

Однако набор данных хорошего размера, содержащий 25000 изображений в обучающих данных.Это означает, что у вас достаточно данных для обучения сверточных нейронных сетей, требующих больших объемов данных, с нуля.

Мы будем часто использовать этот набор данных в будущих публикациях в блогах. Я фактически включил его в раздел «Загрузки» этого сообщения в блоге для вашего удобства, так что прокрутите вниз, чтобы получить код + данные, прежде чем продолжить.

Структура проекта

Скачав архив для этого сообщения блога, распакуйте его в удобное место. Оттуда давайте посмотрим на структуру каталогов проекта:

$ tree --filelimit 10
,├── kaggle_dogs_vs_cats
│ └── train [25000 записей превышает предел файла, не открывает каталог]
└── knn_classifier.py

2 каталога, 1 файл
 

Набор данных Kaggle включен в каталог kaggle_dogs_vs_cats / train (он взят из train.zip , доступного на веб-странице Kaggle).

Сегодня мы рассмотрим один скрипт Python — knn_classifier.py . Этот файл загрузит набор данных, установит и запустит классификатор K-NN и распечатает показатели оценки.

Как работает классификатор k-NN?

Классификатор k-ближайшего соседа — это , безусловно, , самый простой алгоритм машинного обучения / классификации изображений. Фактически, это настолько простое , что фактически ничему не «учится».

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

Проще говоря, алгоритм k-NN классифицирует неизвестные точки данных, находя наиболее распространенного класса среди k-ближайших примеров. Каждая точка данных в k ближайших примерах дает голос, и категория с наибольшим количеством голосов побеждает!

Или простым языком: «Скажите мне, кто ваши соседи, и я скажу вам, кто вы»

Чтобы визуализировать это, взгляните на следующий пример игрушки, где я нанес «пушистость» животных по оси x и легкость их шерсти по оси y :

Здесь мы видим, что есть две категории изображений и что каждая из точек данных в каждой соответствующей категории сгруппирована относительно близко друг к другу в пространстве измерений n-. У наших собак, как правило, темная шерсть, которая не очень пушистая, а у наших кошек очень светлая, но очень пушистая.

Это означает, что расстояние между двумя точками данных в красном круге на намного меньше , чем расстояние между точкой данных в красном круге и точкой данных в синем круге .

Чтобы применить классификацию k-ближайшего соседа, нам нужно определить метрику расстояния или функцию подобия. Обычный выбор включает евклидово расстояние:

И расстояние от Манхэттена до городского квартала:

В зависимости от типа данных могут использоваться другие метрики расстояния / функции подобия (расстояние хи-квадрат часто используется для распределений [i.е., гистограммы]). В сегодняшнем сообщении в блоге для простоты мы будем использовать евклидово расстояние для сравнения изображений на предмет сходства.

Реализация k-NN для классификации изображений с помощью Python

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

Откройте новый файл, назовите его knn_classifier.py , и давайте получим код:

# импортировать необходимые пакеты
из склеарна.соседи импортируют KNeighborsClassifier
из sklearn.model_selection import train_test_split
из путей импорта imutils
импортировать numpy как np
импорт argparse
импорт imutils
импорт cv2
импорт ОС
 

Мы начинаем со строк , строки 2–9, с импорта необходимых пакетов Python. Если вы еще не установили библиотеку scikit-learn, следуйте этим инструкциям и установите ее сейчас.

Примечание: Это сообщение в блоге было обновлено для обеспечения совместимости с будущим scikit-learn == 0.20 , где sklearn.cross_validation был заменен на sklearn.model_selection .

Во-вторых, мы будем использовать библиотеку imutils, пакет, который я создал для хранения общих функций обработки компьютерного зрения. Если у вас не установлено imutils , вам нужно сделать это сейчас:

$ pip install imutils
 

Далее мы собираемся определить два метода для получения входного изображения и преобразования его в вектор признаков или список чисел, которые количественно определяют содержимое изображения.Первый метод можно увидеть ниже:

def image_to_feature_vector (изображение, размер = (32, 32)):
# изменить размер изображения до фиксированного размера, затем сгладить изображение в
# список яркости необработанных пикселей
вернуть cv2.resize (изображение, размер) .flatten ()
 

Метод image_to_feature_vector — чрезвычайно наивная функция, которая просто берет входное изображение и изменяет его размер до фиксированной ширины и высоты ( размер ), а затем сглаживает яркость пикселей RGB в один список чисел.

Это означает, что наше входное изображение будет уменьшено до 32 x 32 пикселей, и при наличии трех каналов для каждого красного, зеленого и синего компонентов соответственно, наш выходной «вектор характеристик» будет списком 32 x 32 х 3 = 3072 номеров.

Строго говоря, вывод image_to_feature_vector не является истинным «вектором признаков», поскольку мы склонны думать о «характеристиках» и «дескрипторах» как о абстрактных количественных определениях содержимого изображения.

Кроме того, использование яркости необработанных пикселей в качестве входных данных для алгоритмов машинного обучения имеет тенденцию давать плохие результаты, поскольку даже небольшие изменения в повороте, перемещении, точке обзора, масштабе и т. Д. Могут существенно повлиять на само изображение (и, следовательно, на представление выходных характеристик) ,

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

Затем мы определяем наш второй метод, называемый extract_color_histogram :

def extract_color_histogram (изображение, ячейки = (8, 8, 8)):
# извлекаем гистограмму цвета 3D из цветового пространства HSV, используя
# указанное количество бинов на канал
hsv = cv2.cvtColor (изображение, cv2.COLOR_BGR2HSV)
hist = cv2.calcHist ([hsv], [0, 1, 2], Нет, ячейки,
[0, 180, 0, 256, 0, 256])

# обрабатываем нормализацию гистограммы, если мы используем OpenCV 2.4.X
если imutils.is_cv2 ():
hist = cv2.normalize (hist)

# в противном случае выполнить нормализацию "на месте" в OpenCV 3 (I
# лично ненавижу то, как это делается
еще:
cv2.normalize (hist, hist)

# возвращаем сглаженную гистограмму как вектор признаков
вернуть hist.flatten ()
 

Как следует из названия, эта функция принимает на входе изображение , и строит гистограмму цвета для характеристики цветового распределения изображения.

Сначала мы конвертируем наше изображение в цветовое пространство HSV в строке 19 .Затем мы применяем функцию cv2.calcHist для вычисления трехмерной цветовой гистограммы для изображения ( строки 20 и 21 ). Вы можете узнать больше о вычислении гистограмм цвета в этом посте. Вам также может быть интересно применить цветовые гистограммы к поисковым системам изображений и вообще, как сопоставить цветовые гистограммы на предмет сходства.

Получив наш вычисленный hist , мы затем нормализуем его, заботясь об использовании соответствующей сигнатуры функции cv2.normalize на основе нашей версии OpenCV ( строки 24-30 ).

Учитывая 8 бинов для каждого из каналов оттенка, насыщенности и значения соответственно, наш окончательный вектор признаков имеет размер 8 x 8 x 8 = 512 , таким образом, наше изображение характеризуется вектором признаков 512 d . ,

Затем давайте проанализируем аргументы нашей командной строки:

# построить аргумент parse и разобрать аргументы
ap = argparse.ArgumentParser ()
ap.add_argument ("- d", "--dataset", required = True,
help = "путь к входному набору данных")
ап.add_argument ("- k", "--neighbors", type = int, по умолчанию = 1,
help = "# ближайших соседей для классификации")
ap.add_argument ("- j", "--jobs", type = int, по умолчанию = -1,
help = "Количество заданий для расстояния k-NN (-1 использует все доступные ядра)")
args = vars (ap.parse_args ())
 

Нам нужен только один аргумент командной строки, за которым следуют два необязательных аргумента, каждый из которых подробно описан ниже:

• --dataset : это путь к нашему входному каталогу набора данных Kaggle Dogs vs. Cats.
• --neighbors : Здесь мы можем указать количество ближайших соседей, которые учитываются при классификации данной точки данных. По умолчанию это значение равно на , что означает, что изображение будет классифицировано путем нахождения ближайшего соседа в пространстве n – размерности и последующего присвоения метки ближайшего изображения. В публикации на следующей неделе я продемонстрирую, как автоматически настроить k для достижения оптимальной точности.
• --jobs : Поиск ближайшего соседа для данного изображения требует, чтобы мы вычислили расстояние от нашего входного изображения до каждого второго изображения в нашем наборе данных .Очевидно, что это операция O (N) , которая масштабируется линейно. Для больших наборов данных это может стать чрезмерно медленным. Чтобы ускорить процесс, мы можем распределить вычисление ближайших соседей по нескольким процессорам / ядрам нашей машины. Установка --jobs на -1 гарантирует, что все процессоров / ядер будут использоваться для ускорения процесса классификации.

Примечание: Мы также можем ускорить классификатор k-NN, используя специализированные структуры данных, такие как kd-деревья или алгоритмы приблизительного ближайшего соседа, такие как FLANN или Annoy.На практике эти алгоритмы могут сократить поиск ближайшего соседа примерно до O (log N) ; однако, для простоты в этом посте, мы выполним исчерпывающий поиск ближайшего соседа.

Теперь мы готовы подготовить наши изображения для извлечения признаков:

# возьмите список изображений, которые мы будем описывать
print ("[ИНФОРМАЦИЯ] с описанием изображений ...")
imagePaths = list (paths.list_images (args ["набор данных"]))

# инициализируем матрицу яркости сырых пикселей, матрицу функций,
# и список ярлыков
rawImages = []
features = []
label = []
 

Строка 47 захватывает пути ко всем 25 000 обучающим изображениям с диска.

Затем мы инициализируем три списка ( строки 51-53 ) для хранения интенсивностей пикселей необработанного изображения (вектор признаков 3072-d ), другой — для хранения признаков гистограммы (вектор признаков 512-d ) и наконец, класс обозначает себя («собака» или «кошка»).

Давайте перейдем к извлечению функций из нашего набора данных:

# перебираем входные изображения
для (i, imagePath) в перечислении (imagePaths):
# загружаем изображение и извлекаем метку класса (предполагая, что наш
# путь в формате: / путь / к / набору данных / {класс}.{IMAGE_NUM} .jpg
изображение = cv2.imread (imagePath)
label = imagePath.split (os.path.sep) [- 1] .split (".") [0]

# извлекаем необработанные "особенности" интенсивности пикселей, за которыми следует цвет
# гистограмма для характеристики цветового распределения пикселей
# на изображении
пикселей = image_to_feature_vector (изображение)
hist = extract_color_histogram (изображение)

# обновить необработанные изображения, функции и матрицы меток,
# соответственно
rawImages.append (пиксели)
функции.Append (Hist)
labels.append (ярлык)

# показывать обновление каждые 1000 изображений
если i> 0 и i% 1000 == 0:
print ("[ИНФОРМАЦИЯ] обработано {} / {}". format (i, len (imagePaths)))
 

Мы начинаем перебирать наши входные изображения на Строке 56 . Каждое изображение загружается с диска, а метка класса извлекается из imagePath ( строки 59 и 60, ).

Мы применяем функции image_to_feature_vector и extract_color_histogram к строкам 65 и 66 — эти функции используются для извлечения наших векторов признаков из входного изображения .

Учитывая наши метки функций, мы затем обновляем соответствующие rawImages , features и списки в строках 70-72 .

Наконец, мы отображаем обновление в нашем терминале, чтобы информировать нас о ходе извлечения признаков каждые 1000 изображений ( строки 75 и 76, ).

Вам может быть любопытно, сколько памяти занимают наши rawImages и с матрицами — следующий блок кода сообщит нам при выполнении:

# показать некоторую информацию о памяти, используемой необработанными изображениями
# матрица и матрица признаков
rawImages = np.Массив (rawImages)
features = np.array (функции)
label = np.array (метки)
print ("[ИНФОРМАЦИЯ] матрица пикселей: {: .2f} МБ" .format (
rawImages.nbytes / (1024 * 1000.0)))
print ("[ИНФОРМАЦИЯ] матрица функций: {: .2f} МБ" .format (
features.nbytes / (1024 * 1000.0)))
 

Начнем с преобразования наших списков в массивы NumPy. Затем мы используем атрибут .nbytes массива NumPy для отображения количества мегабайт памяти, используемой представлениями (около 75 МБ для необработанных пикселей и 50 МБ для цветовых гистограмм.Это означает, что мы можем легко сохранить () в основной памяти).

Затем нам нужно разделить наши данные на два разделения — одно для обучения и другое для тестирования :

# разделить данные на части для обучения и тестирования, используя 75%
# данных для обучения и оставшиеся 25% для тестирования
(trainRI, testRI, trainRL, testRL) = train_test_split (
rawImages, label, test_size = 0,25, random_state = 42)
(trainFeat, testFeat, trainLabels, testLabels) = train_test_split (
функции, метки, test_size = 0.25, random_state = 42)
 

Здесь мы будем использовать 75% наших данных для обучения, а оставшиеся 25% для тестирования алгоритма k-NN.

Давайте применим классификатор k-NN к яркости необработанных пикселей:

# обучить и оценить классификатор k-NN по яркости необработанных пикселей
print ("[ИНФОРМАЦИЯ] оценка точности сырых пикселей ...")
model = KNeighborsClassifier (n_neighbors = args ["соседи"],
n_jobs = арг [ "работа"])
model.fit (trainRI, trainRL)
acc = model.score (testRI, testRL)
print ("[ИНФОРМАЦИЯ] необработанная точность пикселей: {:.2f}% ". Формат (acc * 100))
 

Здесь мы создаем экземпляр объекта KNeighborsClassifier из библиотеки scikit-learn, используя предоставленное число --neighbours и --jobs .

Затем мы «обучаем» нашу модель, позвонив по номеру .fit на линии Line 99 с последующей оценкой данных тестирования на Line 100 .

Аналогичным образом мы также можем обучить и оценить классификатор k-NN на наших представлениях гистограммы:

# обучить и оценить классификатор k-NN на гистограмме
# представлений
print ("[ИНФОРМАЦИЯ] оценивает точность гистограммы... ")
model = KNeighborsClassifier (n_neighbors = args ["соседи"],
n_jobs = арг [ "работа"])
model.fit (trainFeat, trainLabels)
acc = model.score (testFeat, testLabels)
print ("[ИНФОРМАЦИЯ] точность гистограммы: {: .2f}%". формат (acc * 100))
 

Результаты классификации изображений k-NN

Чтобы протестировать наш классификатор изображений k-NN, убедитесь, что вы загрузили исходный код этого сообщения в блоге, используя форму «Загрузки» , которая находится в нижней части этого руководства.

Набор данных Kaggle Dogs vs. Cats включен в загрузку.

Оттуда просто выполните следующую команду:

$ python knn_classifier.py --dataset kaggle_dogs_vs_cats
 

Сначала вы увидите, что наши изображения описываются и количественно оцениваются с помощью функций image_to_feature_vector и extract_color_histogram :

Этот процесс не должен занимать более 1–3 минут в зависимости от скорости вашего компьютера.

После завершения процесса извлечения признаков мы можем увидеть некоторую информацию о размере (в МБ) наших представлений признаков:

Необработанные пиксельные функции занимают 75 МБ, в то время как цветовые гистограммы требуют только 50 МБ ОЗУ.

Наконец, алгоритм k-NN обучается и оценивается как для яркости необработанных пикселей, так и для цветовых гистограмм:

Как показано на рисунке выше, используя необработанных пикселей с интенсивностью , мы смогли достичь точности 54,42%. С другой стороны, применение k-NN к цветным гистограммам позволило немного улучшить точность 57,58% .

В обоих случаях мы смогли получить точность> 50%, демонстрируя, что в изображениях присутствует базовая закономерность как для яркости необработанных пикселей, так и для цветовых гистограмм.

Впрочем, точность 57% оставляет желать лучшего.

И, как вы могли догадаться, цветовые гистограммы — не лучший способ отличить собаку от кошки:

• Есть коричневые собаки. А еще есть коричневые кошки.
• Есть черные собаки. И есть черные кошки.
• И, конечно же, собака и кошка могут появляться в одной и той же среде (например, в доме, парке, пляже и т. Д.), Где распределение цветов фона схоже.

Из-за этого строгое использование цвета — не лучший выбор для описания разницы между собаками и кошками, но это нормально.Целью этого сообщения в блоге было просто представить концепцию классификации изображений с использованием алгоритма k-NN.

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

Хотите узнать больше о сверточных нейронных сетях прямо сейчас?