Коробка приора: Коробки предач на Лада Приора, Приора 2 (ВАЗ 2170, 2171, 2172) – ВАЗоригинал.ру

21826-1700014-00

Коробка передач 21826 роботизированная в сборе для Лада Приора

89490й

Купить

Оплачивайте товары банковской картой, с помощью QIWI, Яндекс. Деньги или WebMoney и экономьте на покупке от 4%, избегая почтовые комисии

Понять однократный детектор MultiBox (SSD) и реализовать его в Pytorch | by Hao Gao

SSD (Single Shot MultiBox Detector) — популярный алгоритм обнаружения объектов. Обычно это быстрее, чем Faster RCNN. В этом посте я объясню идеи, лежащие в основе SSD и нейронной архитектуры, а затем расскажу, как их реализовать. После этого, я думаю, вы сможете реализовать свой собственный SSD, проявив некоторое терпение. Вы также можете проверить мою реализацию https://github.com/qfgaohao/pytorch-ssd и попробовать живую демонстрацию. В этом посте я буду следовать оригинальной архитектуре из статьи. В следующем посте мы подключим Mobilenet в качестве базовой сети, чтобы сделать ее быстрее.

Типичная сеть CNN постепенно уменьшает размер карты объектов и увеличивает глубину по мере перехода к более глубоким слоям. Глубокие слои покрывают более крупные рецептивные поля и создают более абстрактное представление, в то время как поверхностные слои покрывают меньшие рецептивные поля. Для получения дополнительной информации о рецептивном поле, проверьте это. Используя эту информацию, мы можем использовать мелкие слои для предсказания маленьких объектов и более глубокие слои для предсказания больших объектов, поскольку маленьким объектам не нужны большие рецептивные поля, а большие рецептивные поля могут сбивать с толку маленькие объекты.

На следующей диаграмме показана архитектура SSD с использованием сети VGG в качестве базовой сети. В средней колонке показаны наборы карт объектов, которые сеть генерирует из разных слоев. Например, первый набор карт объектов создается из слоя 23 сети VGG и имеет размер 38×38 и глубину 512. Каждая точка на карте объектов 38×38 покрывает часть изображения, и 512 каналов могут быть объектами для каждого точка. Используя функции в 512 каналах, мы можем выполнить классификацию изображений, чтобы предсказать метку, и регрессию, чтобы предсказать ограничивающую рамку для небольших объектов в самой точке. Второй набор карт объектов имеет размер 19×19, который можно использовать для немного более крупных объектов, поскольку точки признаков покрывают большие рецептивные поля. Вплоть до последнего слоя в наборе карт объектов есть только одна точка, которая идеально подходит для больших объектов.

Для набора данных Pascal VOC имеется 21 класс (20 объектов + 1 фон). Вы заметили, что для каждой характерной точки в результатах классификации есть выходные данные 4×21. На самом деле число 4 связано с тем, что мы предсказываем 4 объекта с разными ограничивающими рамками для каждой точки. Это обычная уловка, используемая в Yolo и Faster RCNN. В SSD несколько полей для каждой характерной точки называются априорами, а в Faster RCNN — якорями. Я не буду их здесь рисовать. Однако вы можете проверить визуализацию якорей в посте Faster RCNN. Они несут одну и ту же концепцию. Для каждого априора мы предсказываем одну ограничивающую рамку для всех классов, поэтому для каждой характерной точки имеется 4 значения. Остерегайтесь, это отличается от Faster RCNN. Это может привести к ухудшению предсказания ограничивающей рамки из-за путаницы между различными классами.

Приведенная выше сеть представляет собой чистую сеть CNN. Ее построение должно Это не сложно. Мы переходим непосредственно к пикантной части реализации. Кстати, я большой сторонник Pytorch, так как он позволяет мне сосредоточиться на алгоритме, а не на самом фреймворке.

Generate Priors

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

Для лучшего понимания, пожалуйста, ознакомьтесь с генерацией привязки в этом посте о Faster RCNN.

Код — лучший документ. Следующая реализация представляет собой отдельный gist-файл, попробуйте запустить его и прочитать, чтобы понять.

Сопоставление априорных данных с ячейками достоверности

У вас не будет целей обучающего набора данных, пока вы не сопоставите априорные вероятности с ячейками достоверности.

Критерием соответствия априорного и основного блоков является IoU (Intersection Over Union), который также называется индексом Жаккара. Чем больше совпадений, тем лучше совпадение. Процесс сопоставления выглядит следующим образом:

 для каждой коробки истинной истины: 
 сопоставить ячейку достоверной информации с априорным наличием наибольшего IoU для каждого предыдущего: 
, если max_iou > порога: 
 i = argmax(ious) 
 соответствует априору с помощью Ground_truth_boxes[i] 

Масштабирование полей достоверности наземных данных

Интуитивно удобно масштабировать представления полей достоверности наземных данных в одном масштабе. В SSD шкала следующая:

«дисперсия0» и «дисперсия1» в статье 0,1 и 0,2.

Hard Negative Mining

В приведенной выше фазе сопоставления мы усиливаем положительные цели (ящики имеют назначенный им объект) путем сопоставления наземных истинных ящиков с несколькими априорными значениями. Однако есть еще много непревзойденных приоров. Другими словами, огромное количество априорных значений, помеченных как фон, делает набор данных очень несбалансированным. Чтобы сделать набор данных более сбалансированным, часто используется Hard Negative Mining. Идея состоит в том, чтобы с максимальной достоверностью учитывать только фоновые априорные значения при вычислении функции общих потерь. Остальные игнорируются. Соотношение между фоновыми априорами и совпадающими априорами становится намного ниже (соотношение равно 3 в статье).

Функция потерь

Функция потерь представляет собой комбинацию потерь классификации и потерь регрессии. Используемая здесь регрессионная потеря — это потеря Smooth-L1, которая аналогична Faster RCNN и Fast RCNN. У Pytorch есть документация для Smooth-L1 Loss.

Увеличение данных

Теперь у вас есть полные данные обучения. Не хватает только одного шага: увеличения данных. Это может помочь алгоритму изучить инвариантность данных. На самом деле, в отличие от Faster RCNN, увеличение данных играет важную роль в SSD. Расширение данных, используемое в реализации, выглядит следующим образом:

Теперь вы можете приступить к обучению с помощью вашего любимого оптимизатора.

Предсказывать просто. Подавая изображение в сеть, каждый априор будет иметь набор ограничивающих рамок и меток. Помните, мы увеличиваем количество положительных априорных значений, сопоставляя один объект с несколькими априорными значениями? Теперь у нас есть несколько априорных прогнозов для одного и того же объекта. Для удаления дубликатов используется NMS (немаксимальное подавление).

NMS

NMS сохраняет только ограничивающие рамки с наибольшей вероятностью и удаляет ограничивающие рамки с более низкой вероятностью и большими долгами вместе с сохраненными. Этот процесс лучше демонстрируется в псевдокоде.

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

Неглубокие слои в нейронной сети могут не генерировать достаточно высокоуровневых признаков для прогнозирования небольших объектов. Таким образом, SSD работает с меньшими объектами хуже, чем с большими объектами.

Потребность в расширении сложных данных также предполагает, что для обучения требуется большое количество данных. Например, SSD лучше подходит для Pascal VOC, если модель предварительно обучена на наборе данных COCO. Поэтому убедитесь, что ваша модель предварительно обучена на больших наборах данных, таких как Pascal VOC, COCO и Open Images, прежде чем обучать ее на ваших собственных данных. Я думаю, это самый низко висящий фрукт.

Вопрос о дизайне предыдущих коробок остается открытым. Вы должны позаботиться об этом.

Идеи простые, но мощные. Однако реализация не тривиальна. Удачи с деталями! Не стесняйтесь оформить заказ или разветвить мою реализацию https://github. com/qfgaohao/pytorch-ssd. Предложения и сообщения об ошибках более чем приветствуются.

В следующем посте мы заменим VGG Net на MobileNet, чтобы сделать его быстрее.

1. Реализация Pytorch SSD. https://github.com/amdegroot/ssd.pytorch
2. Детектор. https://github.com/facebookresearch/Detectron. Он имеет хорошие реализации NMS.
3. Caffe2 Операторы. https://github.com/pytorch/pytorch/tree/master/caffe2/operators. Вы можете найти некоторые из реализаций полезными.
4. Мягкая NMS. https://arxiv.org/abs/1704.04503. Еще одна версия НМС.
5. Более быстрая реализация RCNN. https://github.com/jwyang/faster-rcnn.pytorch
6. Всемогущая реализация обнаружения объектов тензорного потока. https://github.com/tensorflow/models/tree/master/research/object_detection

SSD перед созданием коробки · GitHub

	импортный рассол
	импортировать numpy как np
	импорт пдб
	img_width, img_height = 300, 300
	box_configs = [
	{‘layer_width’: 38, ‘layer_height’: 38, ‘num_prior’: 3, ‘min_size’: 30. 0,
	«max_size»: нет, «соотношения сторон»: [1,0, 2,0, 1/2,0]},
	{‘layer_width’: 19, ‘layer_height’: 19, ‘num_prior’: 6, ‘min_size’: 60,0,
	«max_size»: 114,0, «соотношения сторон»: [1,0, 1,0, 2,0, 1/2,0, 3,0, 1/3,0]},
	{‘layer_width’: 10, ‘layer_height’: 10, ‘num_prior’: 6, ‘min_size’: 114,0,
	«max_size»: 168,0, «соотношения сторон»: [1,0, 1,0, 2,0, 1/2,0, 3,0, 1/3,0]},
	{‘layer_width’: 5, ‘layer_height’: 5, ‘num_prior’: 6, ‘min_size’: 168,0,
	«max_size»: 222,0, «соотношения сторон»: [1,0, 1,0, 2,0, 1/2,0, 3,0, 1/3,0]},
	{‘layer_width’: 3, ‘layer_height’: 3, ‘num_prior’: 6, ‘min_size’: 222,0,
	«max_size»: 276,0, «соотношения сторон»: [1,0, 1,0, 2,0, 1/2,0, 3,0, 1/3,0]},
	{‘layer_width’: 1, ‘layer_height’: 1, ‘num_prior’: 6, ‘min_size’: 276,0,
	«max_size»: 330,0, «соотношения сторон»: [1,0, 1,0, 2,0, 1/2,0, 3,0, 1/3,0]},
	]
	дисперсия = [0,1, 0,1, 0,2, 0,2]
	box_paras = []
	по определению create_prior_box():
	для layer_config в box_configs:
	ширина_слоя, высота_слоя = конфигурация_слоя[«ширина_слоя»], конфигурация_слоя[«высота_слоя»]
	num_priors = layer_config[«num_prior»]
	аспект_соотношений = layer_config[«соотношения сторон»]
	минимальный_размер = layer_config[«минимальный_размер»]
	max_size = layer_config[«max_size»]
	step_x = float(img_width) / float(layer_width)
	step_y = float(img_height) / float(layer_height)
	linx = np. linspace(0,5 * step_x, img_width — 0,5 * step_x, layer_width)
	liny = np.linspace(0,5 * step_y, img_height — 0,5 * step_y, layer_height)
	center_x, center_y = np.meshgrid(linx, liny)
	center_x = center_x.reshape(-1, 1)
	center_y = center_y.reshape(-1, 1)
	утверждать (num_priors == len (aspect_ratios))
	prior_boxes = np.concatenate((centers_x, center_y), ось=1)
	prior_boxes = np. tile (prior_boxes, (1, 2 * num_priors))
	box_widths = []
	box_heights = []
	для ar в аспекте_соотношений:
	, если ar == 1 и len(box_widths) == 0:
	box_widths.append(min_size)
	box_heights.append(min_size)
	elif ar == 1 и len(box_widths) > 0:
	box_widths.append(np.sqrt(min_size * max_size))
	box_heights.append(np. sqrt(min_size * max_size))
	Элиф Ар != 1:
	box_widths.append (min_size * np.sqrt (ar))
	box_heights.append (min_size / np.sqrt (ar))
	box_widths = 0,5 * np.array(box_widths)
	box_heights = 0,5 * np.array(box_heights)
	# нормализовать до 0-1
	Prior_Boxes[:, ::4] -= box_widths
	Prior_Boxes[:, 1::4] -= box_heights
	prior_boxes[:, 2::4] += box_widths
	prior_boxes[:, 3::4] += box_heights
	Prior_Boxes[:, ::2] /= img_width
	Prior_Boxes[:, 1::2] /= img_height
	Prior_Boxes = Prior_Boxes. reshape(-1, 4)
	# клип на 0-1
	prior_boxes = np.minimum (np.maximum (prior_boxes, 0.0), 1.0)
	piror_variances = np.tile (дисперсия, (len (prior_boxes), 1))
	box_para = np.concatenate((prior_boxes, piror_variances), ось=1)
	box_paras.append(boxes_para)
	вернуть np.concatenate (boxes_paras, ось = 0)
	если __name__ == «__main__»:
	box_paras = create_prior_box()
	приоры = pickle. Оставить комментарийОтменить комментарий Ваш адрес email не будет опубликован. Обязательные поля помечены *