Блог

Видео текст:

[00:00] => важный пример использования компьютера
[00:01] => видение и машинное обучение — это
[00:03] => самоуправляемые автомобили
[00:04] => в этом курсе sockshare научит вас
[00:06] => как реализовать многие методы, связанные
[00:08] => к восприятию самоуправляемых автомобилей привет
[00:11] => инженеры, я сакшек, добро пожаловать на это
[00:14] => курс по восприятию для самостоятельного вождения
[00:16] => машины
[00:17] => в этом курсе мы рассмотрим ряд
[00:20] => различных проектов, которые связаны
[00:22] => к модулю восприятия
[00:25] => самоуправляемый автомобиль
[00:26] => этот курс предназначен для промежуточного
[00:29] => уровень аудитории
[00:30] => от вас требуется знать основные
[00:32] => концепции python, а также некоторые базовые
[00:36] => концепции, касающиеся глубокого обучения
[00:38] => этот курс предназначен для вас, если вы
[00:40] => хотите попасть в область
[00:42] => самоуправляемые автомобили
[00:44] => или если вам интересно заниматься проектами
[00:47] => которые связаны с компьютерным зрением
[00:49] => использование глубокого обучения
[00:51] => прежде чем начать, нравится ли вам контент
[00:53] => из этого курса вы также можете ознакомиться с моим
[00:55] => канал робототехники с
[00:59] => где я размещаю видео, связанные с робототехникой
[01:02] => и искусственный интеллект
[01:04] => так что теперь давайте начнем
[01:08] => нашим первым проектом будет дорога
[01:10] => сегментация в этом проекте мы будем
[01:12] => выполнение сегментации изображений дорог с использованием
[01:16] => техника глубокого обучения, называемая полностью
[01:18] => сверточные сети
[01:20] => в следующем проекте мы будем делать 2d
[01:22] => обнаружение объектов на различных
[01:24] => сценарии дорожного движения с использованием глубокого обучения
[01:27] => метод, называемый алгоритмом eulo
[01:30] => далее мы будем отслеживать эти объекты
[01:32] => обнаружения с использованием метода, называемого глубоким
[01:35] => сортировать
[01:36] => после того, как мы закончим с 2d-частью в
[01:39] => эти три проекта мы будем продвигать
[01:41] => перейдя к 3d части, мы начнем 3d
[01:44] => часть с 3d визуализацией данных, где мы
[01:47] => будет визуализировать изображения с камеры и лидара
[01:49] => данные
[01:50] => далее мы будем обсуждать многозадачность
[01:53] => обучение, основанное на двух задачах.
[01:55] => оценка и семантическая сегментация
[01:58] => затем мы перейдем к 3d
[02:00] => обнаружение объекта, затем переходим к нашему
[02:02] => финальный проект вид с высоты птичьего полета
[02:04] => визуализация с использованием современного компьютера
[02:07] => техника видения, называемая трансформаторами, все
[02:09] => набор данных и записные книжки с кодом являются
[02:12] => предоставлено для того, чтобы вы могли следовать за
[02:14] => с этим курсом
[02:17] => хорошо, так что же это за дорога
[02:19] => проблема сегментации, которую вы бы сказали в
[02:21] => сегментация дороги с учетом входного изображения
[02:24] => мы обязаны определить, где находятся
[02:27] => дороги, присутствующие на этом изображении
[02:29] => теперь мы, люди, можем видеть, что дорога
[02:32] => присутствует прямо здесь, в некотором роде в
[02:35] => середина изображения так что же мы такое
[02:37] => требуется вывести изображение чего-то
[02:39] => это выглядит так
[02:41] => теперь здесь мы отметили дорогу, которая
[02:44] => присутствующий в этом образе
[02:48] => теперь мы не будем точно выводить
[02:50] => это, но то, что нам нужно, это то, что
[02:53] => мы каким-то образом отмечаем эту дорогу в отдельном
[02:56] => изображение
[02:57] => одним из способов сделать это было бы
[02:59] => для вывода черно-белого изображения, где
[03:02] => белый цвет символизирует место, где проходит дорога
[03:04] => присутствует и 0 или черный цвет представляет
[03:07] => другой фон на этом изображении
[03:10] => давайте взглянем на другое изображение, как
[03:12] => хорошо
[03:14] => теперь это еще один дорожный образ, который мы
[03:16] => теперь я могу видеть
[03:19] => теперь, как люди, легко увидеть, где находится
[03:21] => дорога, представленная на этом изображении для
[03:24] => компьютер то, что он увидит, — это что-то
[03:26] => подобный этому
[03:27] => таким образом, компьютер должен вывести
[03:29] => маска сегментации, которая выглядит как-то
[03:31] => подобный этому
[03:33] => теперь эти два изображения, которые вы видите
[03:35] => вот здесь проходит часть кошачьей дороги
[03:38] => набор данных
[03:39] => теперь набор данных представляет собой набор таких
[03:42] => входные изображения и желаемые выходные изображения
[03:46] => который мы используем для определения базовой линии или проверки того, как
[03:49] => наша модель выполняет
[03:51] => если наша модель способна хорошо работать на
[03:53] => этими изображениями мы можем быть отчасти уверены, что
[03:56] => они собираются хорошо выступить в реальной
[03:58] => мир тоже, но есть некоторые
[04:00] => осложнения, которые также необходимы
[04:03] => хорошо, значит, к этому времени ты бы уже понял
[04:05] => в чем проблема сегментации дорог
[04:07] => и набор данных, над которым вы работаете
[04:09] => какой сейчас набор данных о китти-роуд для
[04:12] => эта задача сегментации дорог существует
[04:14] => существует ряд систем компьютерного зрения
[04:16] => методы, которые мы можем применить
[04:19] => старые методы компьютерного зрения
[04:21] => требовалось, чтобы мы, программисты, на самом деле
[04:24] => жестко закодируйте различные значения по порядку
[04:27] => чтобы отрезать дорогу, которая присутствует в
[04:29] => изображение теперь эта техника склонна к
[04:32] => много ошибок и, как правило, не
[04:34] => обобщать очень хорошо, как эта техника
[04:37] => сработало бы для одного изображения очень хорошо, но
[04:39] => полностью провалился бы для другого изображения
[04:42] => например, если мы разработаем методику
[04:44] => для сегментации дороги на изображении
[04:47] => тогда даже небольшая тень на дороге
[04:50] => это полностью разрушило бы наш параметр
[04:52] => настройка, и нам потребуется настроить
[04:53] => параметры снова
[04:55] => затем, с появлением глубокого обучения, мы
[04:58] => избавился от таких методов ручной работы
[05:01] => в котором компьютер автоматически
[05:03] => изучите эти параметры с учетом разнообразных
[05:06] => набор данных, поэтому один из таких методов, который
[05:08] => мы собираемся обсудить сегодня полностью
[05:10] => сверточные сети теперь полностью
[05:13] => сверточные сети были одним из
[05:15] => первые методы, которые ввели
[05:17] => метод сквозной сегментации
[05:20] => то, что я подразумеваю под сквозным, — это то, что дано
[05:23] => входное изображение, если мы подадим входные данные
[05:25] => изображение в модель fcn, он будет напрямую
[05:29] => выведите сегментацию, которая является
[05:31] => обучен никакой другой предварительной обработке или
[05:33] => последующая обработка потребуется на
[05:35] => этот образ как таковой
[05:37] => теперь мы применяем полностью
[05:39] => техника сверточной сети на
[05:42] => задача сегментации дорог, которая заключается в том, что мы можем
[05:44] => скажем, подмножество задачи сегментации как
[05:47] => хорошо
[05:48] => итак, как выглядит полная картина
[05:50] => заключается в том, что у нас есть изображение входного изображения
[05:52] => в котором присутствует дорога, которую мы проходим
[05:55] => это входное изображение для модели fcn, которая
[05:57] => у нас есть, и к выходу мы получаем
[06:01] => ноль одно изображение двоичное изображение, где один
[06:04] => присутствует везде, где присутствовала полоса движения или
[06:06] => дорога присутствовала, в противном случае у нас есть
[06:08] => ноль в полном изображении
[06:10] => теперь для того, чтобы полностью понять
[06:12] => сверточные сети, которые нам сначала нужно
[06:15] => понять операцию с изображением, вызванную
[06:18] => отбор проб
[06:19] => так что давайте взглянем на это
[06:23] => таким образом, простыми словами, выборка вверх — это
[06:25] => операция, в ходе которой мы увеличиваем размер
[06:27] => заданный ввод, например, если мы
[06:30] => учитывая изображение, подобное этому, 2 креста 2
[06:33] => изображение, то увеличение выборки в 2 раза приведет к
[06:36] => увеличьте вдвое высоту и ширину
[06:38] => поэтому у нас будет 4 креста 4
[06:41] => выход
[06:42] => полная проблема отбора проб заключается в
[06:45] => нам нужно решить, что будет
[06:46] => значения в этой матрице 4 пересекают 4, когда
[06:49] => нам были бы даны значения в этом 2
[06:52] => пересечение 2 заданной матрицы
[06:54] => таким образом, существует целый ряд методов
[06:56] => которые мы можем применить, давайте обсудим некоторые из
[06:58] => их первой первой техникой для до
[07:00] => выборка, которую мы имеем, называется «ложе из гвоздей»
[07:04] => то, что мы делаем в постели из гвоздей, независимо от
[07:06] => значение присутствует в этой матрице
[07:09] => мы собираемся присвоить это значение
[07:10] => этот квартал вот здесь
[07:12] => остальные три значения, которые являются
[07:14] => связанные с этим блоком, которые являются одним двумя
[07:16] => три этим трем блокам присваивается
[07:18] => значение нуля аналогично из этого блока
[07:21] => мы можем взять значение и присвоить его
[07:23] => здесь остальные три взаимосвязанных значения
[07:26] => присваиваются нулю
[07:27] => эти, которые являются этими тремя, аналогично мы
[07:30] => сделайте то же самое для этих двух ячеек
[07:32] => ценности, а теперь это действительно
[07:35] => упрощенная техника, к которой мы идем
[07:36] => чтобы в нашем выводе было много нулей
[07:38] => представьте, что лучший метод, чем этот, — это
[07:41] => метод ближайшего соседа
[07:43] => в методе ближайшего соседа мы делаем следующее
[07:45] => мы берем ту ценность, которая присутствует, за
[07:47] => здесь и во всех четырех связанных ячейках
[07:50] => этой ячейке мы присваиваем то же значение
[07:52] => например, если у нас есть один здесь, мы
[07:54] => собираемся присвоить значение единицы
[07:56] => все 4 квартала отсюда
[07:59] => аналогично, если у нас есть значение 2 более
[08:01] => здесь мы собираемся назначить
[08:02] => значение 2 для этих 4 блоков здесь
[08:06] => и мы делаем это аналогично для
[08:07] => полная матрица здесь
[08:10] => теперь еще лучший метод, чем ближайший
[08:12] => соседство называется интерполяцией
[08:15] => теперь интерполяция больше похожа на
[08:17] => средняя техника поиска, где мы
[08:19] => присваивать значения на основе взвешенного
[08:21] => средний, как мы это делаем
[08:24] => в интерполяции мы пытаемся проложить свой путь
[08:26] => назад, если мы хотим рассчитать
[08:28] => значение этой ячейки здесь, то мы
[08:31] => примерно попробуйте перекрыть эту матрицу
[08:34] => с помощью этой матрицы мы собираемся
[08:36] => видите ли, этот блок будет лежать
[08:39] => где-то здесь
[08:41] => теперь в этой камере почти четыре
[08:44] => значения в этой матрице, которые являются всеми
[08:46] => четыре значения здесь
[08:48] => теперь, основываясь на расстоянии от этих
[08:51] => четыре значения, которые мы собираемся присвоить
[08:53] => среднее значение для этой ячейки вот здесь
[08:56] => точно так же мы собираемся сделать это для
[08:58] => эта клетка тоже будет лежать
[09:00] => где-то здесь и среднее значение
[09:02] => будет присвоен этой ячейке на основе
[09:05] => то
[09:06] => расстояние от четырех ячеек, которые
[09:09] => присутствующий здесь
[09:10] => аналогично, если мы хотим присвоить значение
[09:13] => из этой камеры здесь, тогда эта камера
[09:15] => собираюсь лечь где-нибудь здесь, сейчас мы
[09:17] => собираемся взять среднее из этих
[09:19] => две ячейки только потому, что это
[09:21] => ближайшие соседи присутствуют в этой ячейке
[09:24] => итак, вот как работает метод интерполяции
[09:26] => работает
[09:27] => в настоящее время метод интерполяции является одним из
[09:30] => лучшая техника, которую мы могли бы применить, но
[09:31] => существует еще более совершенная техника
[09:34] => это мы также можем применить, что является
[09:36] => транспонированные извилины
[09:39] => во всех техниках, которые мы обсуждали
[09:41] => до того, как мы начали присваивать значения
[09:43] => основываясь на некоторой эвристике, которую мы усердно
[09:45] => код вместо этого в транспонированной свертке
[09:48] => мы присваиваем значения на основе
[09:50] => обучаемый весовой фильтр
[09:52] => мы определяем фильтр некоторого размера с
[09:55] => затем мы используем некоторые случайные значения веса
[09:57] => эти значения веса для присвоения значения
[09:59] => для всех клеток, присутствующих в
[10:01] => эту матрицу и передайте ее в сеть
[10:04] => когда сеть собирается сделать обратный
[10:07] => распространение мы собираемся вернуться
[10:09] => распространять потерю веса
[10:11] => те тоже фильтруют, и они собираются
[10:13] => быть изученным, а также с целью
[10:15] => в этом проекте я попробовал два метода, которые
[10:18] => были интерполированы и транспонированы
[10:20] => извилины
[10:21] => из того, что я видел, транспонируйте извилины
[10:24] => работал не очень хорошо, но
[10:26] => метод интерполяции работал очень хорошо
[10:28] => для нашего случая сейчас, поскольку у нас есть
[10:30] => понял, в чем дело.
[10:32] => операция — это все, так что давайте сейчас
[10:33] => обсудите архитектуру полностью
[10:35] => сверточная сеть, поэтому для полностью
[10:37] => сверточной сети нам требуется
[10:39] => магистральная сеть, представляющая собой изображение
[10:42] => классификационная сеть теперь называется vggnet
[10:44] => что такое классификация изображений и что такое
[10:47] => vgg net теперь классификация изображений представляет собой
[10:50] => проблема, когда нам дают ввод
[10:52] => изображение, и мы должны решить, что
[10:55] => присутствует в этом изображении
[10:57] => или мы можем сказать, что требуется компьютер
[10:59] => чтобы решить, что присутствует в этом изображении
[11:02] => теперь, прежде чем что-либо предпринять, мы уже
[11:04] => определил классы перед отправкой
[11:06] => входное изображение, например, если в нашем изображении
[11:09] => мы знаем, что их будет три
[11:11] => сущности, присутствующие в самолете
[11:14] => велосипед и человек, то мы едем
[11:17] => чтобы присвоить значение 0 самолету один
[11:20] => к велосипеду и 2 к человеку
[11:23] => затем мы пропускаем изображение через изображение
[11:25] => сеть классификации и ее выходы 0
[11:28] => 1 или 2, представляющие то, что он видел в
[11:31] => изображение теперь классификация изображений является своего рода
[11:33] => решенной проблемы, в которой у нас есть модели
[11:36] => которые дают очень хорошие результаты на некоторых
[11:38] => базовые данные представляют собой одну из таких хороших сетей
[11:41] => является
[11:43] => теперь, поскольку сеть vgcg принимает изображение
[11:45] => ввод и вывод одного числа вывод
[11:48] => нам нужно преобразовать его для нашего варианта использования
[11:51] => в чем заключается проблема сегментации в
[11:53] => проблема сегментации входные данные представляют собой
[11:56] => изображение, и вывод также является изображением
[11:58] => это имеет те же размеры, так что давайте
[12:00] => посмотрите изменения, которые нам необходимо внести
[12:02] => в эту сеть ugc для вывода таких
[12:04] => изображения теперь сеть vgg состоит из
[12:08] => количество сверточных блоков
[12:10] => которые расположены последовательно к каждому
[12:12] => другое каждый блок свертки состоит из
[12:15] => два сверточных слоя, за которыми следует
[12:17] => максимальный объединяющий слой
[12:19] => теперь то, что мы делаем, это извлекаем выходные данные
[12:21] => из последних трех сверточных блоков, которые
[12:23] => являются бассейном 3, бассейном 4 и бассейном 5. итак, что мы
[12:27] => сначала мы пробуем этот пул 5 раз
[12:30] => 2 итак, здесь у нас есть увеличенное изображение
[12:33] => затем мы добавляем этот вывод к выходу
[12:36] => пул 4 тогда что мы получаем здесь
[12:38] => мы снова повторяем выборку этого вывода 2 раза
[12:41] => чтобы получить вывод здесь
[12:43] => и, наконец, снова добавьте этот пул 3 слоя
[12:46] => который затем мы получаем здесь
[12:48] => наконец, мы увеличили выборку этого вывода 8 раз
[12:51] => и конечный результат, который мы получаем, — это
[12:53] => маска сегментации, которая нам требуется
[12:56] => теперь эта длинная последовательность — это то, что
[12:58] => представляет собой архитектуру fcn или
[13:00] => в частности, это fcn 8
[13:04] => архитектура
[13:06] => существуют две другие архитектуры fcn
[13:09] => а также fcn 32 и fcn 16. что мы делаем в
[13:13] => fcn32 мы не проходим через все это
[13:16] => операции, которые мы провели здесь
[13:18] => вместо этого мы просто выбираем этот пул 5
[13:20] => слой 32 раза, и мы получаем результат в
[13:24] => fcn 16 мы снова не делаем всего этого
[13:27] => операции мы просто идем до этого шага
[13:29] => вот здесь, где мы рассчитываем сумму
[13:31] => до 4-го пула, а затем мы пробуем его 16
[13:34] => раз, чтобы получить результат, так как мы
[13:37] => выполнение всех операций, которые
[13:38] => присутствующий здесь и, наконец, образец
[13:41] => 8 раз, поэтому эта архитектура является
[13:44] => называемый fcn 8, в одном смысле мы можем сказать, что
[13:47] => fcn 8 представляет собой комбинацию fcn32 и fcn16
[13:52] => это означает, что
[13:54] => fcn 32 идентифицирует более грубые структуры в
[13:58] => изображение fcn 16 идентифицирует более тонкие
[14:02] => структуры на изображении и fcn 8 даже
[14:05] => более тонкие структуры на изображении с использованием
[14:07] => эти операции сложения, которые у нас есть
[14:09] => здесь мы объединяем знания
[14:11] => из этих трех сетей, чтобы получить окончательный
[14:14] => вывод теперь это полный
[14:16] => детали архитектуры и то, как это
[14:18] => архитектура в некоторой степени работает над
[14:20] => внутри
[14:21] => хорошо, теперь наше обсуждение этого
[14:23] => завершена, теперь давайте посмотрим, как
[14:26] => эта модель была реализована и каковы
[14:28] => различные результаты, которые мы получили так
[14:30] => давайте взглянем на этот набор данных
[14:32] => и код, и то, и другое присутствуют в kaggle
[14:35] => ссылка для обоих из них находится в
[14:37] => описание вы можете взглянуть на них
[14:39] => также
[14:40] => хорошо, итак, это первая реализация
[14:43] => мы определяем входной слой с помощью
[14:45] => форма ввода параметра теперь форма ввода
[14:48] => кортеж, содержащий изображение размера изображения
[14:51] => размер общее количество каналов изображения
[14:53] => размер, который мы установили здесь, составляет 128 крестов
[14:55] => 128, а количество каналов равно трем,
[14:58] => каналы rgb
[15:01] => затем мы определяем сеть vgg, но это
[15:03] => является ли vgg 16 тензорным потоком или keras
[15:06] => уже предоставляет нам
[15:08] => реализация vg16, которая является
[15:10] => предварительно обучен набору данных imagenet
[15:14] => затем мы извлекаем эти три блока, которые
[15:16] => есть бассейн три, бассейн четыре и бассейн
[15:18] => пять слоев для первого шага, который мы делаем
[15:21] => образец два раза, который мы можем видеть более
[15:23] => здесь инструмент 5 слой, затем мы добавляем это
[15:27] => вверх по слою образцов в пул 4, и мы
[15:30] => примените здесь свертку 1 крест 1
[15:33] => как вы можете видеть сейчас, эта свертка
[15:35] => больше похоже на заполнитель, чтобы получить
[15:37] => размеры в нужном размере как таковые
[15:40] => использовать их или не использовать, не имеет значения
[15:41] => оказывают большое влияние на производительность, поскольку
[15:44] => такой
[15:46] => когда мы применяем вторую выборку вверх,
[15:48] => второй этап отбора проб
[15:50] => и добавьте этот образец слоя с
[15:53] => бассейн 3 слоя
[15:54] => снова мы применяем свертку 2d, которая является
[15:57] => опять же, как своего рода заполнитель здесь
[16:01] => наконец, для вывода мы вычисляем
[16:03] => до 8 раз этот финал
[16:06] => свертка является обязательной, теперь это
[16:09] => классы, как говорят, 1 здесь, это
[16:12] => делается потому, что мы хотим установить
[16:15] => выход сети должен быть единым
[16:18] => изображение канала теперь, когда один канал
[16:20] => будет содержать 0 и 1, как мы обсуждали
[16:23] => прежде чем кто-то станет маской, где
[16:26] => дорога присутствует и 0 в противном случае
[16:30] => мы также применяем сигмовидную активацию поверх
[16:33] => здесь для того, чтобы получить окончательные значения
[16:35] => между 0 и 1, а затем мы возвращаем
[16:38] => модель с входами и выходами в виде
[16:40] => такой набор мы и назвали моделью
[16:43] => fcn 8 аналогично
[16:46] => теперь давайте посмотрим на результаты
[16:48] => что мы получили эти изображения, которые были протянуты
[16:50] => от модели, и модель видит
[16:53] => их в первый раз
[16:58] => это второе изображение
[17:55] => теперь, как мы видим, модель работает
[17:57] => действительно хорошо
[17:59] => теперь давайте внесем некоторые изменения в
[18:01] => базовая сеть, которую мы имеем и видим
[18:03] => как меняются результаты
[18:05] => теперь это одно из изменений, которое мы делаем
[18:07] => вместо функции добавления мы используем
[18:10] => функция объединения здесь, в
[18:12] => добавление того, что мы делаем, это добавляем
[18:15] => соответствующие значения, присутствующие в
[18:17] => матрица из двух изображений
[18:19] => однако в объединении мы просто добавляем, что
[18:22] => изображение к задней части изображения и
[18:25] => увеличьте количество каналов
[18:27] => вход
[18:31] => итак, теперь давайте посмотрим, каковы результаты
[18:33] => после того, как мы применим это объединение вместо
[18:36] => от
[19:28] => таким образом, мы можем видеть, что конкатенация также
[19:30] => работает хорошо, но прибавляет немного
[19:33] => лучше, чем эта функция объединения
[19:38] => теперь давайте изменим это на выборку 2d
[19:40] => с помощью сверточного 2d-транспонирования, которое мы
[19:43] => можно видеть отсюда, так что вместо того, чтобы вверх
[19:45] => выборка здесь мы используем транспонирование
[19:47] => свертка, в которой мы собираемся учиться
[19:49] => веса выборки, а также и
[19:52] => мы используем функцию добавления здесь
[19:54] => итак, давайте посмотрим, как будут выглядеть результаты этого
[19:56] => выглядит как
[20:25] => таким образом, мы можем ясно видеть, что транспонирование
[20:27] => свертка не дает такой пользы от
[20:29] => результаты
[20:31] => хотя он выучил задачу, но
[20:34] => вывод является своего рода пикселизированным и не
[20:36] => действительно хорошо смотрится на сегментации, как
[20:39] => хорошо
[20:40] => хорошо, итак, вот результаты
[20:41] => сеть и некоторые из ее расширений
[20:44] => также
[20:47] => итак, прежде чем обсуждать, что такое 2d-объект
[20:50] => проблема обнаружения давайте сначала посмотрим, что
[20:52] => это набор данных, который предоставляется нам
[20:55] => в этом проекте
[20:57] => итак, lyft — это компания по производству самоуправляемых автомобилей
[21:01] => которая разрабатывает программное обеспечение для самоуправляемых автомобилей
[21:03] => в целях дальнейшего исследования в
[21:05] => самоуправляемые автомобили
[21:07] => lyft объявила о двух конкурсах, которые
[21:10] => были проведены ранее эти два
[21:12] => соревнованиями было обнаружение 3d-объектов
[21:15] => и предсказание движения эти два
[21:17] => разделять
[21:18] => набор данных, который мы собираемся использовать
[21:20] => для этого проекта один из
[21:22] => задача обнаружения 3d-объектов lift
[21:26] => итак, что же было дано в объекте
[21:28] => задача обнаружения
[21:31] => итак, что сделал lyft, так это то, что он поехал на
[21:35] => самоуправляемый автомобиль по улицам
[21:37] => пало-Альто, и они записали камеру
[21:40] => данные, а также данные лидарного датчика
[21:43] => теперь лидар — это датчик, который работает на
[21:46] => принцип отражения лазерных лучей
[21:49] => лазер, начинающийся с датчика, идет
[21:51] => и натыкается на препятствие, возвращается обратно в
[21:54] => датчик, и датчик обнаруживает
[21:56] => расстояние до этого объекта, поэтому в этих данных
[21:58] => установлено, что нам также выдаются данные камеры
[22:01] => как данные лидара для той же поездки, что и
[22:04] => мы видим, что это некоторые образцы
[22:06] => фотографии, так что это одно заднее изображение, когда мы
[22:08] => видите, у нас здесь есть определенные машины
[22:12] => у нас есть изображение спереди, у нас есть определенные
[22:14] => машины здесь тоже есть
[22:15] => теперь мы можем сравнить данные лидара с
[22:18] => данные камеры
[22:20] => итак, мы итак, наша машина локализована на этом
[22:24] => пересекать
[22:25] => и мы видим, что там есть одна машина
[22:26] => это присутствует здесь, это пытается
[22:29] => чтобы выйти на полосу движения помимо нас, как мы можем
[22:31] => видите, у нас здесь тоже есть машина
[22:34] => и мы также видим, что у нас есть два
[22:36] => машины за нашей машиной, которые присутствуют
[22:39] => сюда
[22:40] => эти синие ограничивающие рамки представляют
[22:42] => пешеходы
[22:45] => таким образом, у нас также есть переднее левое изображение спереди
[22:48] => правое изображение назад правое изображение и обратно
[22:50] => левое изображение мы также можем визуализировать
[22:52] => данные в видеоформате, так что давайте поиграем
[22:54] => это видео
[23:06] => аналогичным образом мы также можем визуализировать
[23:08] => данные лидара в видеоформате давайте поиграем
[23:10] => это видео
[23:26] => итак, код для этой визуализации данных
[23:28] => будет присутствовать в поле описание
[23:30] => ниже мы конкретно будем работать
[23:33] => на изображениях камеры как таковых, так что теперь давайте
[23:36] => давайте обсудим, что это за обнаружение объекта
[23:38] => проблема и в чем разница
[23:39] => между 2d и 3d обнаружением объектов, поэтому в
[23:42] => обнаружение объекта полная проблема заключается в
[23:45] => оформленный как таковой
[23:47] => что в данном изображении мы обязаны
[23:50] => чтобы найти местоположение объекта
[23:52] => присутствующий в этом изображении, а также
[23:55] => скажите, что это за объект
[23:57] => например, в этом примере мы можем видеть
[24:00] => здесь есть одна собака, которая
[24:02] => присутствует и есть две кошки, поэтому дано
[24:04] => это изображение, которое нам нужно вывести, где находится
[24:06] => собака присутствует в виде прыгающей
[24:09] => коробка и где присутствуют кошки
[24:12] => теперь в случае обнаружения 2d-объекта мы
[24:15] => было бы дано 2d-изображение, и мы
[24:17] => требуется указать ограничительные рамки в
[24:19] => 2d
[24:21] => однако при обнаружении 3d-объектов отдельно
[24:24] => из 2d-изображения нам также будет дано
[24:27] => также некоторые другие представления данных
[24:30] => используя это изображение и дополнительные данные
[24:33] => мы должны вернуть 3d-границу
[24:36] => коробка
[24:37] => этого объекта вместе с его меткой
[24:41] => очень хороший пример — 3d-объект
[24:44] => данные обнаружения, а также
[24:47] => как мы видим, нам даны 3d-границы
[24:49] => коробки различных автомобилей на этом изображении
[24:53] => и нам также предоставляются дополнительные данные
[24:56] => что такое данные лидара
[25:00] => и мы также можем видеть, что мы
[25:02] => прогнозирование пешеходов так же хорошо, как и
[25:05] => как машины
[25:06] => итак, одна классная вещь, которую мы также можем
[25:08] => обратите внимание, что мы также можем
[25:10] => обнаруживать объекты, которые заблокированы в
[25:13] => приведенное изображение того, как мы можем это сделать
[25:16] => это связано с дополнительными данными, которые
[25:18] => обеспечивается лидаром
[25:20] => хорошо, значит, это все для 3d и 2d
[25:23] => обнаружение объектов
[25:25] => в этом видео мы сосредоточимся только на
[25:28] => об обнаружении 2d-объектов, поэтому мы собираемся
[25:31] => чтобы запустить алгоритм на этих заданных
[25:33] => изображения и предсказывать 2d ограничительные рамки, чтобы
[25:37] => давайте подробно обсудим этот алгоритм
[25:40] => как вы, возможно, видели при обнаружении объектов
[25:42] => мы также должны локализовать объект
[25:45] => а также что это за объект
[25:48] => теперь в случае самоуправляемых автомобилей, как мы
[25:50] => можете посмотреть здесь, если нам дадут два
[25:52] => автомобили, то нам также нужно найти
[25:54] => положение этих двух автомобилей, а также
[25:56] => решите, это машины, не так ли
[25:58] => пешеходы ездят туда на велосипедах и так далее
[26:00] => теперь об алгоритме, который мы собираемся
[26:03] => решение для обнаружения 2d-объектов является
[26:05] => желтый
[26:06] => йоло, и это означает только для просмотра
[26:10] => посмотрите один раз сейчас, давая общую картину
[26:13] => мы можем разделить желтый алгоритм на
[26:15] => три ступени, которые являются якорными ящиками
[26:18] => пересечение над союзом и
[26:21] => предсказания ограничивающей рамки
[26:23] => итак, как это работает сейчас, йоло тоже
[26:26] => техника глубокого обучения, которую мы используем для
[26:28] => обнаружение объекта в этом нам дается
[26:31] => входное изображение мы передаем это входное изображение
[26:33] => через сверточную нейронную сеть
[26:36] => и в качестве вывода мы получаем еще одну матрицу
[26:40] => обычно для желтого алгоритма это
[26:42] => размер матрицы принимается равным 19 на 19.
[26:46] => что означает это сопоставление ввода-вывода
[26:48] => представим, если мы рассмотрим эту матрицу как
[26:51] => матрица 19 крест 19, если мы возьмем нашу
[26:54] => входное изображение как таковое и перекрывает это 19
[26:57] => 19 матрица над ней затем 19 крест 19
[27:00] => коробки, которые мы можем видеть поверх нашего изображения, все
[27:03] => эти отдельные коробки расскажут
[27:05] => что находится в этой коробке
[27:09] => это может быть либо автомобиль, либо грузовик, либо даже
[27:12] => мотоцикл, и также возможно, что
[27:14] => в этом нет ничего полезного
[27:16] => конкретный ящик, например, в нашем случае
[27:19] => это была бы, можно сказать, дорога для каждого
[27:22] => ячейка, в которой мы собираемся разместить этот вектор
[27:25] => место, где эта вещь также может быть визуализирована
[27:27] => поскольку эта матрица на самом деле является объемом, поэтому
[27:31] => 19 крест 19 — это ширина и высота
[27:34] => этой матрицы и в глубине
[27:36] => перспектива у нас есть этот полный вектор
[27:39] => теперь давайте посмотрим, что описывает этот вектор
[27:41] => этот вектор, который мы обсуждали, описывает
[27:44] => информация, которая присутствует в этом
[27:46] => конкретной ячейке значение пк будет
[27:48] => скажите, есть ли что-то интересное
[27:50] => присутствует в этой камере или нет, если что-то
[27:52] => интересного в этой камере нет
[27:55] => тогда другие ценности просто будут
[27:57] => быть неопределенным, или мы не собираемся
[28:00] => учитывайте их в расчетах как
[28:02] => такой
[28:03] => если мы предположим, что пк равен 1 и есть
[28:05] => в этом есть что-то интересное
[28:07] => ячейку, то x и y будут описывать
[28:10] => положение центра этого
[28:12] => объект относительно данной ячейки, так что x
[28:16] => и вы собираетесь сказать, начнем ли мы с
[28:18] => этот верхний левый угол этой ячейки, как
[28:21] => как много нам нужно, чтобы идти правильно, и как много мы
[28:23] => нужно спуститься вниз, чтобы добраться до
[28:25] => средняя точка этого объекта
[28:27] => w и h описывают ширину и высоту
[28:30] => опять же в отношении этой ячейки
[28:33] => теперь эти переменные c1 c2 c3 описывают
[28:36] => какой объект присутствует в этой ячейке
[28:40] => например, если у нас есть три объекта
[28:42] => тогда один из этих трех будет
[28:44] => один, остальные будут равны нулю
[28:46] => если мы учтем, что у нас есть четыре объекта
[28:48] => по нашему мнению, тогда мы собираемся
[28:50] => чтобы здесь было четыре переменные c1 c2
[28:52] => c3 и c4
[28:54] => теперь мы можем видеть, что будет
[28:56] => присутствует в выводе часть вывода
[28:59] => ячейки, как мы видим, они считываются
[29:01] => здесь мы опишем это
[29:03] => в этом присутствует что-то особенное
[29:05] => конкретная ячейка, поэтому вывод здесь
[29:07] => дает нам представление о том, каким будет объект
[29:10] => и что будет ограничивающим прямоугольником
[29:12] => этого конкретного объекта, одного определенного
[29:15] => пример, который мы можем увидеть здесь для этого
[29:17] => конкретный автомобиль, мы видим, что есть
[29:19] => несколько ограничивающих рамок, которые были
[29:21] => сгенерированный
[29:22] => по этому выходу
[29:24] => и для того, чтобы различать, у меня есть
[29:26] => также нарисована одна машина в углу над
[29:28] => здесь также есть несколько
[29:30] => ограничивающие рамки, описывающие его
[29:33] => наряду с этими ограничивающими рамками и
[29:35] => метки мы также вычисляем вероятность
[29:38] => эта вероятность также описывает, насколько
[29:40] => уверенность — это наша ограничивающая рамка
[29:42] => предсказания, например, это ограничение
[29:45] => коробка вон там, во внешней может быть
[29:47] => более низкая вероятность, однако, та, которая
[29:50] => находится внутри, будет иметь более высокий
[29:52] => вероятность итак, вот как одна часть
[29:56] => часть предсказания ограничительной рамки Эйлера
[29:58] => работает
[29:59] => теперь для того, чтобы отделить эти ограничивающие
[30:01] => коробки и получите единую ограничивающую рамку для
[30:04] => каждый объект, который мы используем, пересекается над
[30:07] => союз
[30:08] => и эта техника получения единственного
[30:10] => ограничивающий прямоугольник и разделяющий различные
[30:12] => ограничивающие рамки называются не максимальными
[30:15] => подавление
[30:16] => хорошо, сначала давайте посмотрим, что это
[30:18] => пересечение над союзом или мы можем сказать
[30:21] => долговая расписка
[30:22] => таким образом, вы привыкли вычислять, сколько
[30:26] => две ограничивающие рамки, разные
[30:28] => вы могли бы увидеть это в его
[30:29] => математическое описание
[30:31] => итак, если у нас есть две ограничивающие рамки, как мы
[30:33] => сдались здесь
[30:35] => сначала мы вычисляем их пересечение
[30:38] => и разделите это на их союз
[30:41] => таким образом, это дает нам представление о том, как два
[30:44] => ограничивающие рамки похожи друг на друга
[30:46] => таким образом, мы можем использовать вас, чтобы отделить
[30:49] => ограничивающие рамки двух разных объектов
[30:51] => например, эти два
[30:53] => мы вычисляем долговую расписку ограничивающего
[30:56] => коробки по отношению к максимальному
[30:59] => вероятностный ограничивающий прямоугольник так что же это
[31:02] => означает, что если мы снова рассмотрим, что
[31:04] => внутренняя ограничивающая рамка имеет самый высокий
[31:06] => вероятность, и мы вычисляем
[31:09] => оценка для остальных четырех ограничивающих рамок
[31:12] => относительно этой максимальной вероятности
[31:15] => ограничивающая рамка
[31:16] => мы видим, что эти две ограничивающие рамки
[31:18] => будете иметь очень высокую ценность для вас
[31:21] => так как они очень высоко вас ценят
[31:23] => это означает, что они на самом деле
[31:25] => представляющий один и тот же объект, следовательно
[31:28] => мы отбрасываем эти два других ограничения
[31:30] => рамки теперь эти две другие ограничивающие рамки
[31:32] => они очень низко вас ценят за это
[31:34] => изображает, что они представляют какой-то другой
[31:37] => возражать, и мы собираемся применить
[31:39] => не максимальное разделение отдельно на
[31:42] => эти ограничивающие рамки
[31:43] => и вот как перекресток закончился
[31:45] => профсоюзная часть eulo работает сейчас, там можно
[31:48] => быть сценарием, в котором одна ячейка
[31:50] => здесь представлено множество различных
[31:53] => объекты одним небольшим примером могут быть два
[31:56] => автомобили, припаркованные бок о бок
[31:59] => итак, в одной из этих камер мы собираемся
[32:02] => захватите обе эти машины
[32:04] => одновременно
[32:05] => для того чтобы решить эту проблему, мы
[32:08] => используйте эту концепцию якорных ящиков, которые
[32:11] => анкерные коробки представляют собой грубую форму для
[32:14] => различные объекты, которые собираются
[32:15] => присутствовать в нашем образе эти якоря
[32:17] => коробки могут быть спроектированы нами, людьми, или ит
[32:20] => может быть решено другой машиной
[32:22] => алгоритм обучения также, так как же
[32:25] => этот якорный ящик помогает в обнаружении
[32:27] => несколько объектов, поэтому каждый якорный ящик
[32:30] => описывает, какую форму объекта они
[32:32] => ищете, например, этот якорь
[32:35] => коробка ищет квадратный объект, этот
[32:38] => якорная коробка ищет прямоугольную
[32:40] => объект с большей высотой, чем ширина
[32:43] => и этот якорный ящик ищет
[32:45] => объект, который больше по ширине, но
[32:48] => меньше по высоте каждая анкерная коробка собирается
[32:50] => чтобы предсказать определенный конкретный объект
[32:53] => и как это изменит нашу
[32:55] => выход
[32:56] => для каждой ячейки вместо того, чтобы иметь это
[32:59] => единый вектор, который мы собираемся расширить
[33:01] => этот вектор в нашем случае трижды
[33:04] => так как у нас есть три якорных ящика
[33:06] => это позволяет нам прогнозировать несколько
[33:08] => объекты, которые присутствовали бы в
[33:10] => одиночная ячейка
[33:12] => таким образом, все эти методы в совокупности дают нам
[33:15] => желтый алгоритм алгоритм yolo представляет собой
[33:18] => действительно быстрый и точный объект
[33:20] => метод обнаружения, который делает его
[33:22] => чрезвычайно полезен для
[33:24] => восприятие в самоуправляемых автомобилях существует
[33:27] => большая работа, которая была проделана над этим
[33:29] => алгоритм йоло слишком велик, чтобы мы
[33:32] => есть несколько вариантов алгоритма yolo
[33:35] => с каждым вариантом желтого
[33:37] => алгоритм был улучшен
[33:39] => в скорости, а также в точности
[33:42] => хорошо, а теперь давайте посмотрим на этого йоло
[33:44] => алгоритм в действии yolo — это очень
[33:46] => сложный алгоритм, который занял бы довольно
[33:49] => много времени на разработку, следовательно, это
[33:52] => ни выполнимый, ни разумный способ
[33:55] => что мы внедряем yolo с нуля
[33:58] => следовательно, мы собираемся использовать этот керас
[34:00] => реализация yellow v3, предоставленная
[34:03] => опыт или извинения, если я произнес
[34:06] => это неправильно
[34:07] => это реализация с открытым исходным кодом, которую я
[34:09] => предоставил бы ссылку на репозиторий
[34:12] => в разделе описания ниже это
[34:14] => записная книжка, которая у нас есть
[34:16] => ссылка для этой записной книжки также будет
[34:18] => присутствует в разделе описания ниже
[34:21] => так как обсуждать особо нечего
[34:22] => что касается реализации, мы будем
[34:24] => непосредственно переходим к результатам, которые у нас есть
[34:27] => на этом наборе данных
[34:28] => поэтому я увеличил масштаб, чтобы показать изображения
[34:30] => лучше, как мы видим, камера была
[34:32] => прикрепленный к автомобилю, так что мы также
[34:34] => обнаружение нашей части автомобиля, а также
[34:36] => мы также обнаруживаем другие автомобили
[34:41] => однако мы видим, что этот автобус
[34:43] => быть обнаруженным как грузовик
[34:48] => у нас есть прогнозы и по автомобилю.
[34:50] => здесь
[34:52] => машины вон там
[34:54] => машины
[34:56] => итак, мы видим, что у нас тоже есть один грузовик
[34:59] => обнаружение здесь
[35:01] => у нас есть обнаружение автобуса здесь
[35:03] => а также, и у нас также есть грузовик, который
[35:06] => сильно отстал
[35:19] => хорошо, итак, это были результаты, которые
[35:21] => мы продолжили движение по желтой трассе v3
[35:23] => алгоритм на объекте lift 3d
[35:26] => набор данных обнаружения
[35:28] => теперь обнаружение 2d-объектов — это в значительной степени
[35:30] => решена проблема, и у нас уже есть очень
[35:34] => хорошие алгоритмы, такие как желтый, которые выполняют наши
[35:36] => задача
[35:37] => однако есть некоторые исследования, которые
[35:40] => все еще требуется для обнаружения 3d-объектов
[35:43] => что также было мотивацией того, почему
[35:45] => лайфт провел это
[35:47] => конкуренция тоже хорошо, так что это
[35:50] => это для этого видео
[35:53] => для этого конкретного проекта мы собираемся
[35:55] => для использования нескольких видео, которые были записаны
[35:59] => с помощью камеры, которая была установлена перед
[36:01] => автономный автомобиль, так что давайте посмотрим
[36:03] => на одном из видеороликов
[36:06] => в этом видео мы видим, что есть
[36:08] => две машины, которые движутся
[36:15] => и это еще одно видео того же самого
[36:18] => сценарий шоссе
[36:28] => таким образом, набор данных содержит шесть видеороликов, которые содержат
[36:32] => этот сценарий шоссе для объекта
[36:34] => отслеживание нам нужно отслеживать оба
[36:36] => из этих машин, которые движутся впереди
[36:39] => из нас, если мы присвоим идентификатор обоим
[36:42] => эти машины, если мы скажем, что это черный
[36:44] => машина, и это белая машина, затем в
[36:47] => каждый кадр видео, который нам нужно сохранить
[36:50] => определить, где находится черная машина и
[36:52] => где белая машина
[36:54] => это должно быть сделано для полного
[36:56] => продолжительность видео
[36:58] => в отслеживании объектов мы не только
[37:00] => требуется для определения того, где находится автомобиль
[37:02] => присутствует в этом конкретном кадре
[37:06] => но мы также должны помнить, что это
[37:09] => является ли автомобиль, которому был присвоен идентификационный номер
[37:12] => черная машина
[37:13] => и это та машина, которая была
[37:15] => присвоен идентификационный номер белой машины
[37:18] => ссылка на этот набор данных будет
[37:20] => присутствует в поле с описанием ниже
[37:22] => хорошо, теперь мы определили объект
[37:24] => проблема обнаружения и взглянул на
[37:26] => набор данных итак, теперь давайте разберемся, как
[37:29] => этот алгоритм глубокой сортировки работает
[37:31] => как вы, возможно, видели раньше в объекте
[37:33] => отслеживание нам нужно не только обнаруживать
[37:35] => объекты, но также отслеживать, где они
[37:38] => собираемся так, если мы рассмотрим это
[37:40] => коллекция изображений, или мы можем сказать,
[37:43] => видео мы видим, что у нас есть два
[37:45] => объекты, которые движутся в этом видео, это
[37:47] => этот круглый предмет, который входит
[37:49] => горизонтальное направление и один объект
[37:51] => это происходит в вертикальном направлении
[37:53] => в отслеживании объектов мы не только
[37:55] => определение того, где присутствуют объекты
[37:58] => в этом изображении
[37:59] => но мы также отслеживаем, где
[38:01] => объекты с идентификаторами один и два собираются
[38:05] => так вот в чем вся проблема объекта
[38:07] => отслеживание в нашем случае это был бы трафик
[38:10] => отслеживание нам нужно отслеживать
[38:13] => разные машины, которые движутся вокруг
[38:16] => наше автономное транспортное средство, поэтому алгоритм
[38:20] => которые мы собираемся использовать для решения этой проблемы
[38:21] => проблема отслеживания объектов называется
[38:24] => алгоритм глубокой сортировки
[38:26] => прежде чем обсуждать глубокий вид
[38:27] => алгоритм, с которого мы бы сначала начали наш
[38:29] => обсуждение с помощью простого вида
[38:31] => алгоритм сортировки расшифровывается как простой онлайн
[38:34] => отслеживание в реальном времени
[38:36] => и простой алгоритм сортировки использует
[38:38] => предсказание ограничивающей рамки фильтры калмана
[38:41] => и вы соответствуете методам
[38:43] => сначала давайте начнем с ограничительной рамки
[38:45] => предсказания — первый шаг в этом
[38:48] => алгоритм заключается в создании ограничивающих рамок
[38:50] => или определить, где присутствуют объекты
[38:53] => на изображении теперь это может быть
[38:55] => выполнено с использованием любой архитектуры cnn
[38:57] => это может быть желтый, это может быть rcnn или это
[39:00] => может быть даже простое компьютерное зрение
[39:02] => модель ручной работы
[39:04] => для нашего проекта мы использовали yolo v3
[39:07] => алгоритм кратко о том, что такое алгоритм yolo v3
[39:10] => дает ли входное изображение, которое оно собирается
[39:12] => обнаруживать все присутствующие объекты
[39:15] => на этом изображении нарисуйте ограничивающую рамку вокруг
[39:17] => их, а также расскажите нам, что это за объект
[39:20] => является
[39:21] => после того, как мы сгенерировали ограничивающую рамку
[39:22] => итак, мы переходим к следующему шагу
[39:24] => который сейчас является фильтром Калмана кельвин
[39:27] => фильтр — это очень широкая тема, которая будет
[39:29] => возьмите целое видео, чтобы объяснить, но
[39:32] => тем не менее, у нас осталось бы много
[39:34] => почву для обсуждения, поэтому кратко обсудим
[39:36] => фильтр Калмана мы можем сказать очень просто
[39:39] => условия, что фильтр Кельвина является линейным
[39:41] => приближение итак, какова роль
[39:44] => фильтр Калмана здесь фильтр Кельвина
[39:46] => необходимо предсказать, что будет
[39:49] => будущее местоположение данного обнаруженного
[39:51] => объект
[39:52] => используя эти прогнозы на будущее, мы можем
[39:54] => определите, является ли объект, который мы
[39:56] => отслеживали не один и тот же объект или
[39:59] => нет
[40:00] => наряду с этим, используя предсказание, мы можем
[40:03] => также займитесь проблемой прикуса
[40:07] => так что же такое окклюзия
[40:08] => в приведенном выше примере мы можем видеть между
[40:11] => эти эти два кадра
[40:13] => два шара будут перекрывать друг друга
[40:15] => другой
[40:16] => и какой бы объект ни был впереди, он
[40:18] => собирается закрыть объект, который
[40:20] => присутствующий за ним
[40:22] => для того чтобы решить эту проблему в
[40:24] => полезны прогнозы отслеживания объектов
[40:28] => итак, как работает фильтр Калмана
[40:30] => фильтр предполагает модель линейной скорости
[40:33] => и генерирует прогнозы в соответствии
[40:35] => к нему, как только мы получим реальные данные, где
[40:38] => цель состоит в том, чтобы мы снова ввели это в
[40:40] => фильтр калмана
[40:42] => фильтр Кельвина улучшает его
[40:43] => прогнозы, основанные на реальных данных, которые
[40:45] => он получил и снова генерирует новый набор
[40:49] => прогнозы
[40:50] => таким образом, фильтр Кельвина работает в
[40:52] => итеративным способом и продолжает совершенствовать свой
[40:54] => прогнозы
[40:56] => в качестве выходного сигнала фильтр Кальвина не
[40:58] => выведите одно число на самом деле это
[41:01] => выводит распределение вероятностей
[41:03] => где объект может находиться в заданном наборе
[41:06] => из местоположений
[41:07] => если мы примем максимальное значение этого
[41:09] => вероятность того, что мы сможем каким-то образом
[41:11] => приблизительное местоположение объекта
[41:13] => быть может, это работа угольного фильтра
[41:16] => он генерирует будущие прогнозы для
[41:18] => объекты
[41:20] => следующий шаг, который у нас есть, называется
[41:23] => соответствие
[41:25] => долговая расписка означает пересечение через союз
[41:28] => вкратце мы можем сказать, что вы даете нам
[41:31] => количественный балл для определения того, насколько
[41:34] => две ограничивающие рамки похожи друг на друга
[41:37] => другие в зависимости от их местоположения в
[41:39] => изображение, а также размер, что это такое
[41:42] => вы соответствуете в контексте сортировки
[41:44] => алгоритм давайте рассмотрим этот случай, когда мы
[41:46] => у нас есть n разных машин, которыми мы являемся
[41:48] => обнаружение в определенном кадре, и мы
[41:51] => есть идентификаторы, которые нам нужно назначить
[41:53] => эти конкретные автомобили, как в данном случае
[41:56] => идентификаторы полезны для определения того, какой объект
[41:59] => мы отслеживаем, поэтому нам нужно назначить
[42:01] => обнаружения сцены для этих n идентификаторов для
[42:05] => у каждого из NID у нас есть счет по долговым распискам
[42:09] => соответствующий каждому обнаружению в
[42:11] => описательный способ, которым мы имеем обнаруженный
[42:13] => объекты в строке, и у нас есть идентификаторы
[42:17] => в столбцах так для каждого i-го идентификатора
[42:20] => и при j-м обнаружении у нас есть долговая расписка
[42:23] => оценка теперь мы хотим назначить
[42:25] => оценки для этих конечных обнаружений в таком
[42:28] => таким образом, чтобы общий балл по долговым распискам составлял
[42:31] => максимальное решение этой проблемы с помощью
[42:33] => подход грубой силы требует порядка
[42:35] => сложность n факториал, который очень
[42:38] => большой для того, чтобы решить эту проблему, вид
[42:40] => алгоритм использует венгерский алгоритм
[42:42] => венгерский алгоритм решает эту проблему
[42:45] => задача линейного присваивания
[42:47] => в порядке сложности n в кубе
[42:50] => что является большим улучшением по сравнению с
[42:53] => факторный алгоритм, как только мы получим
[42:55] => присвоив эти n прогнозов nid, мы
[42:58] => в некотором смысле решили проблему отслеживания
[43:00] => проблема для i-го кадра, тогда мы можем
[43:03] => запустите этот алгоритм еще раз в цикле и
[43:06] => снова следите за объектами, которые
[43:08] => в следующем кадре видео так это
[43:11] => вот как работает простой алгоритм сортировки
[43:14] => теперь глубокая сортировка является продолжением
[43:16] => простой алгоритм сортировки теперь глубоко в
[43:18] => глубокий сорт происходит от этого шага
[43:20] => называется глубоким описателем внешнего вида
[43:22] => шаг
[43:24] => наряду с этим у нас также есть каскад
[43:26] => соответствующий шаг, который добавляется к
[43:28] => простой алгоритм сортировки, такой глубокий внешний вид
[43:31] => дескриптор представляет собой сверточный нейронный
[43:33] => сеть, которая обучена обнаруживать
[43:36] => похожий объект на разных изображениях, что
[43:38] => это означает, что это
[43:40] => эта сеть может сказать, учитывая ряд
[43:43] => изображения одного и того же человека в разных
[43:45] => мнения, является ли это одним и тем же лицом или
[43:48] => не так, как ввод глубокого дескриптора
[43:51] => получает обрезанное изображение объекта
[43:54] => обнаружен, и в качестве вывода мы пытаемся
[43:57] => получите вектор, который кодирует
[43:59] => информация, которая присутствует в этом
[44:01] => обрезанное изображение этих закодированных векторов
[44:05] => позволило бы нам сравнить различные
[44:07] => объекты
[44:08] => итак, теперь у нас есть две модели, которые
[44:10] => описывая нам похожие объекты в
[44:13] => различные кадры видео, которые мы объединяем
[44:16] => оценка, полученная этими двумя моделями в
[44:18] => линейная мода оценка по глубине
[44:21] => дескриптор задается с использованием косинуса
[44:23] => показатель расстояния и оценка по
[44:26] => фильтр Калмана задается мужчиной и
[44:28] => расстояние от ожирения, прежде чем обсуждать, как
[44:30] => эти показатели вычисляются давайте сначала
[44:32] => обсудите понятие метрики расстояния
[44:35] => показатель расстояния — это оценка, которую мы
[44:38] => назначенный двум разным сущностям a и
[44:41] => б, чтобы сказать, насколько они похожи
[44:44] => например, если мы рассмотрим двумерную плоскость
[44:48] => на этой плоскости у нас есть две точки a и b
[44:52] => мы вычисляем их расстояние от
[44:54] => происхождение
[44:56] => если две сущности a и b близки к
[44:58] => друг друга, то расстояние от
[45:00] => происхождение также будет аналогичным в
[45:03] => значение, если две сущности a и b являются
[45:06] => очень непохожие друг на друга, то эти
[45:08] => у двух сущностей будет
[45:10] => евклидово расстояние, которое очень
[45:12] => непохожие, мы можем сказать, что один собирается
[45:14] => имеют отрицательное значение, другое —
[45:16] => будут иметь положительное значение, если они
[45:18] => лежат по обе стороны от оси y
[45:21] => в этих двух случаях нам нужно использовать
[45:24] => другое понятие метрики расстояния для
[45:26] => в глубоких дескрипторах мы используем косинус
[45:28] => метрика расстояния, как мы это вычисляем
[45:32] => если нам даны две сущности a и b
[45:37] => и от начала координат мы рисуем вектор
[45:40] => присоединяясь к этим
[45:43] => а затем мы вычисляем угол между
[45:46] => эти два вектора
[45:47] => значение косинуса этого угла будет
[45:50] => чтобы дать нам метрику косинусного расстояния
[45:52] => давайте рассмотрим пример, если у нас есть
[45:55] => два вектора, которые перекрывают друг друга
[45:57] => другой угол между ними будет
[45:59] => быть 0
[46:00] => и значение косинуса 0 будет равно
[46:02] => 1 это означает, что эти два вектора являются
[46:05] => очень похожи друг на друга
[46:07] => однако, если два вектора перпендикулярны
[46:09] => друг к другу значение косинуса 90 равно
[46:11] => будет 0
[46:13] => это означало бы, что эти два вектора
[46:15] => очень непохожи друг на друга в
[46:17] => таким образом, мы могли бы определить
[46:19] => являются ли два объекта, которые мы обнаружили
[46:22] => насколько они похожи друг на друга
[46:24] => для случая фильтра Калмана мы не
[46:26] => используя косинусное подобие, причина
[46:28] => для этого используется фильтр Калмана
[46:31] => выводить не одну точку, а
[46:33] => распределение вероятностей для того, чтобы
[46:36] => сравните сходство между точкой
[46:38] => и распределение вероятностей, которое мы используем
[46:41] => дыня очевидное расстояние
[46:44] => если мы примем во внимание, что это
[46:46] => распределение, которое выводится с помощью
[46:48] => фильтр Кельвина это означает, что
[46:50] => вероятность того, что объект окажется над
[46:53] => здесь очень высоко по сравнению со значениями
[46:56] => наружу
[46:58] => и это тот момент, когда мы хотим
[47:00] => сравните с этой вероятностью
[47:02] => распределение
[47:04] => говоря очень простыми словами, что такое миелин, очевидно
[47:06] => расстояние делает для 2d-версии, которую мы
[47:08] => вычислите два направления, в которых
[47:11] => разброс данных в этом случае самый высокий
[47:14] => мы видим, что распространение данных является
[47:16] => самый высокий в этом направлении и
[47:18] => перпендикулярно этому направлению
[47:20] => затем мы нормализуем и преобразуем
[47:22] => ось координат таким образом, чтобы эти
[47:25] => две оси становятся осью координат
[47:29] => в этом преобразованном пространстве мы вычисляем
[47:32] => расстояние этой точки от
[47:33] => происхождение значение этого расстояния равно
[47:36] => расстояние меланотуса
[47:39] => используя этот показатель, мы решаем, сколько
[47:42] => данное предсказание с помощью фильтра Калмана
[47:44] => совпадает с объектом, который мы только что обнаружили
[47:48] => объединяя эти два, мы получаем общую
[47:50] => скалярное значение оценки, которое мы можем использовать для
[47:52] => назначьте обнаружения их идентификаторам, используя
[47:55] => венгерский алгоритм, однако, в
[47:58] => в реализации есть небольшой подвох
[48:01] => авторы глубокого рода
[48:03] => алгоритм заметил, что предсказания
[48:05] => по фильтру Калмана не очень полезны
[48:08] => и оценка за эти предсказания может
[48:10] => пренебрегать, однако вы бы увидели, что
[48:12] => в нашем проекте это работает не очень
[48:14] => что ж, следующий шаг, который у нас есть, — это
[48:16] => каскадное сопоставление каскадное сопоставление — это
[48:19] => расширение алгоритма сопоставления векселей
[48:22] => для задачи назначения каскад
[48:24] => сопоставление учитывает временные
[48:26] => размер, а также для того, чтобы уменьшить
[48:29] => временная сложность для венгерского
[48:31] => алгоритм каскадного сопоставления пытается и
[48:34] => сопоставьте последние обнаружения с
[48:36] => последние идентификаторы и более поздние или старые
[48:39] => обнаружения со старыми идентификаторами все это
[48:42] => объединенный процесс дает нам глубокую сортировку
[48:45] => алгоритм
[48:47] => и мы можем снова запустить этот алгоритм в
[48:50] => цикл для отслеживания объектов в полном
[48:53] => видео
[48:54] => хорошо, значит, это все для
[48:56] => объяснение часть глубокого рода
[48:57] => алгоритм теперь давайте кратко рассмотрим
[49:00] => код и результаты и посмотрите, как это
[49:03] => работал над нашим проектом, так что давайте сделаем это
[49:05] => ссылка на этот код или записную книжку будет
[49:08] => должно быть указано в поле с описанием ниже
[49:10] => также
[49:11] => итак, это разные подразделы
[49:13] => полный алгоритм глубокой сортировки
[49:15] => первая часть — это сеть eulo v3, которая
[49:17] => используется для создания ограничивающих рамок
[49:21] => второй шаг — это часть обнаружения
[49:23] => где мы кодируем данное обрезанное изображение
[49:28] => третья часть — это фильтр Калмана
[49:30] => где мы используем фильтр Кельвина для
[49:32] => генерировать прогнозы
[49:34] => следующая часть — это соответствие долговым распискам в
[49:37] => в этой части мы решаем линейное задание
[49:39] => проблема
[49:40] => и каскадное соответствие, которое мы
[49:42] => обсуждалось ранее
[49:45] => следующий — ближайший сосед, соответствующий
[49:48] => это содержит код для евклидовой
[49:50] => расстояние, а также косинусное расстояние
[49:55] => следующая часть — отслеживание этого процесса
[49:59] => все различные модули, которые мы
[50:00] => разработан до создания окончательного
[50:02] => объект, который выполняет полное отслеживание
[50:06] => наконец-то у нас есть отслеживание объекта
[50:08] => где мы запускаем полный алгоритм этого
[50:11] => файл здесь содержит предварительно обученный
[50:13] => сеть для глубокого описания внешнего вида
[50:16] => у нас есть такая функция отслеживания объектов
[50:18] => который принимает вход видеотрансляции и
[50:21] => также принимает путь вывода, где сохранить
[50:23] => выходное видео теперь давайте посмотрим
[50:26] => по результатам того, как финальное видео
[50:29] => выглядит как
[50:30] => итак, это первое видео, как мы можем видеть
[50:33] => этот один и два — это идентификаторы, которые
[50:36] => закреплены за этими двумя автомобилями
[50:38] => соответственно
[50:49] => это второе видео
[50:58] => как мы видим, машина здесь была
[51:00] => присвоен идентификатор 9 и даже в некоторых
[51:02] => кадры, которые желтый алгоритм не смог
[51:04] => чтобы обнаружить эту машину
[51:09] => даже после этих пропущенных обнаружений
[51:12] => алгоритм смог определить, что
[51:14] => это была машина с надписью id9
[51:18] => до сих пор мы просматривали видео
[51:20] => где алгоритм выполнял
[51:22] => действительно хорошо, а теперь давайте взглянем на
[51:23] => видео, в котором алгоритм не сработал
[51:25] => этот колодец
[51:27] => в этом видео мы видим, что у нас есть
[51:29] => эта машина с надписью 12
[51:31] => и у нас есть эта новая машина с надписью
[51:33] => 35 теперь вы увидите, в чем проблема
[51:36] => что этот алгоритм сталкивается
[51:39] => из-за окклюзии, которая была дана
[51:41] => эта черная машина
[51:42] => этот автомобиль теперь повторно идентифицирован как идентификационный
[51:46] => 36 и не тот
[51:49] => 12, что он был назначен до
[51:53] => так что это одна из проблем такого глубокого рода
[51:55] => алгоритм столкнулся из-за более длительного
[51:58] => период окклюзии алгоритм не был
[52:00] => способный обнаруживать
[52:01] => правильный идентификатор для автомобиля
[52:04] => даже после проверки разных гипер
[52:06] => значения параметров, которые я не смог получить
[52:08] => избавьтесь от этой проблемы с назначением идентификатора
[52:11] => я полагаю, что это было бы связано с
[52:14] => присвоение незначительного веса
[52:17] => к предсказаниям фильтра Кельвина
[52:19] => возможно, если мы увеличим вес для
[52:22] => фильтр Кельвина предсказывает это
[52:24] => проблема была бы решена
[52:26] => но это дополнение к проекту
[52:28] => которые мы разработали в этом видео и будем
[52:31] => следует рассматривать как будущую работу по этому
[52:32] => проект
[52:33] => хорошо, вот и все для этого видео
[52:39] => хорошо, итак, это изображения, которые
[52:41] => часть данных об обнаружении 3d-объектов
[52:44] => установлено, как мы можем видеть
[52:51] => и это данные лидара, представленные в
[52:53] => набор данных также
[53:01] => например, мы можем видеть стену в этом
[53:03] => изображение здесь на той же стене, на которой есть
[53:06] => соответствие в лидарном сканировании, а также
[53:09] => как мы можем видеть здесь
[53:12] => эти извилистые линии являются проекциями
[53:14] => лжецы, которые упали на самой дороге
[53:19] => кроме того, если мы рассмотрим другой пример, мы
[53:22] => могу видеть эту машину перед
[53:26] => изображение этот же автомобиль можно увидеть над
[53:29] => здесь
[53:30] => который блокирует сигналы лидара
[53:33] => еще одна классная визуализация, которая у нас есть
[53:35] => представлены ли данные лидара в виде
[53:38] => из камеры
[53:39] => как мы можем видеть здесь
[53:46] => как мы видели на изображении ранее, у нас был
[53:49] => машина перед нами, мы видим эту машину
[53:51] => аналогично и в этих лидарных сканированиях
[53:54] => другой пример — вот эта машина
[54:00] => эта машина эта машина а также движение
[54:03] => сигнал можно увидеть в этом лидарном сканировании как
[54:06] => хорошо
[54:07] => и это еще одна визуализация
[54:09] => данные лидара, а также ограничивающая рамка
[54:12] => которые даны в этом 3d-объекте
[54:14] => набор данных обнаружения
[54:21] => хорошо, значит, это все
[54:22] => визуализации
[54:24] => теперь давайте разберемся, что это за теория
[54:27] => за тем, как мы создаем эти
[54:29] => визуализации
[54:30] => хорошо, теперь для того, чтобы понять, как
[54:33] => мы создаем эти визуализации данных
[54:36] => во-первых, нам нужно понять
[54:38] => концепция однородных преобразований
[54:41] => в общей обстановке самоуправляемого автомобиля мы
[54:44] => обычно имеют два основных датчика, которые
[54:47] => лидар и камера
[54:52] => как правило, это датчики лидара и камеры
[54:55] => не будут размещены в одном и том же
[54:57] => местоположение, которое они собираются иметь
[54:59] => различные места на автомобиле для
[55:01] => например, в этом случае лидар включен
[55:03] => верхней части автомобиля, а камера находится на
[55:06] => передняя часть автомобиля
[55:09] => камера, как мы все знаем, является визуальным датчиком
[55:12] => мы используем его для съемки 2d-сцены
[55:16] => данная 3d-среда
[55:18] => лидар, с другой стороны, — это восприятие
[55:20] => датчик он используется для отображения 3d
[55:22] => окружающая среда с использованием вращающегося лазерного лидара
[55:25] => генерирует то, что называется точкой
[55:28] => облака
[55:29] => облака точек обеспечивают очень хорошую
[55:31] => представление заданной 3d-среды
[55:34] => теперь это очень общий вариант использования, который
[55:38] => мы хотим увидеть данные, которые были
[55:40] => захваченный лидаром в кадре
[55:43] => камера, что я имею в виду под этим, если через
[55:47] => нашими глазами мы видим, как
[55:49] => окружающая среда выглядит так, как отсюда
[55:52] => нам также нужно увидеть, как то же самое
[55:55] => окружающая среда в то же время собирается
[55:57] => похоже на то, когда мы видим это отсюда
[56:00] => в месте расположения камеры
[56:01] => для того, чтобы конвертировать между этими данными
[56:04] => точки отсчета, которые мы используем, называются
[56:06] => однородные преобразования, если мы
[56:09] => считайте, что нам даны два
[56:11] => оси координат синяя вот здесь
[56:14] => и этот красный вот здесь, и у нас есть
[56:16] => этот объект эта черная точка которую мы хотим
[56:19] => чтобы видеть сквозь обе эти координаты
[56:22] => ось
[56:23] => математически эта проблема переводится
[56:26] => к
[56:27] => если нам задан вектор из
[56:30] => начало этой оси координат к этому
[56:32] => точка вот здесь, которую мы называем x
[56:35] => нам нужно найти x тире, которое является вектором
[56:39] => начиная с происхождения этого
[56:40] => координатной оси в ту же точку, заданную
[56:43] => эта координатная ось называется
[56:46] => преобразование
[56:47] => теперь любое общее преобразование может быть
[56:50] => разделен на две подзадачи, которые являются
[56:52] => перевод и ротация
[56:55] => перевод — это просто перемещение источника
[56:58] => этой оси координат к какой-то другой
[57:01] => местоположение в пространстве
[57:03] => если у нас есть такая координатная ось, как эта
[57:05] => и мы просто переносим это на новый
[57:07] => местоположение, то у нас есть то, что называется
[57:09] => перевод
[57:11] => в порядке ротации, однако, мы хотели бы
[57:13] => измените направление, в котором эти оси
[57:16] => указывают
[57:18] => однако происхождение будет оставаться на
[57:20] => в том же месте, чтобы понять
[57:22] => вращение лучше, если мы сможем разделить
[57:25] => операция поворота на три подэлемента
[57:27] => операции, которые вращаются вокруг
[57:29] => вращение оси x вокруг оси y и
[57:32] => вращение вокруг оси z
[57:35] => комбинация всех этих трех
[57:37] => вращения дают нам фактическое вращение
[57:39] => это, наконец, произойдет
[57:42] => не вдаваясь в подробности, давайте посмотрим
[57:45] => как математические представления
[57:47] => они выглядят как
[57:48] => для того, чтобы получить переведенный вектор, мы
[57:51] => просто нужно добавить еще один вектор к нашему
[57:53] => исходный вектор
[57:56] => в этом случае мы добавляем эту азбуку
[57:58] => вектор к нашему исходному x, чтобы получить x t
[58:00] => который является переведенным вектором
[58:03] => операцию вращения можно понять
[58:05] => как матричное умножение
[58:08] => если мы рассмотрим эту матрицу 3 креста 3 и
[58:11] => мы умножаем эту матрицу на нашу
[58:13] => исходный вектор x мы получаем повернутый
[58:15] => вектор x r
[58:17] => однако мы должны иметь это в виду
[58:20] => значения этого вектора трансляции
[58:22] => может быть взято все, что угодно, кроме параметров
[58:26] => из этой матрицы являются
[58:28] => ограниченный между диапазоном
[58:31] => объединение этих двух подопераций
[58:33] => перевод и вращение мы получаем то, что есть
[58:36] => называется однородным преобразованием
[58:38] => что делает однородное преобразование
[58:41] => это просто сокращает перевод и
[58:44] => вращение в единую матрицу
[58:46] => умножение, как мы можем видеть здесь
[58:50] => итак, как мы получаем этот матричный множитель
[58:53] => сначала мы берем матрицу вращения и
[58:56] => поместите его в верхний левый угол над
[58:58] => здесь мы берем этот вектор перевода, который мы
[59:00] => поместите его в правом верхнем углу над
[59:02] => здесь и оставшаяся часть этого последнего
[59:05] => строка заполнена тремя нулями и единицей
[59:10] => это будет выглядеть примерно так
[59:12] => эта матрица из трех перекрестных трех является
[59:14] => матрица вращения и эти три
[59:16] => размерный вектор — это перевод
[59:18] => остальные нули и единицы вектора помещаются
[59:21] => сюда
[59:22] => теперь, следуя правилам матрицы
[59:24] => умножение, учитывая, что это 4 крест 4
[59:27] => матрица, которую можно умножить только на
[59:30] => вектор размерности 4.
[59:33] => для того, чтобы сделать этот 3-мерный
[59:35] => вектор 4 мерный вектор что мы делаем
[59:38] => здесь есть место а 1
[59:40] => следовательно, наша полная операция выглядит следующим образом
[59:42] => это мы берем эту матрицу и умножаем
[59:45] => эта матрица с этим расширенным вектором
[59:47] => и что мы получаем в результате, так это
[59:50] => расширенный вектор здесь
[59:52] => из-за структуры этой матрицы
[59:54] => вон тот, что здесь, — это
[59:56] => гарантированное количество
[59:58] => используя эту операцию, мы, наконец, получаем
[60:00] => вектор x тире, представляющее точку x
[60:04] => в новой системе координат
[60:07] => теперь для того, чтобы преобразовать это заданное 3d
[60:10] => данные на 2d-репрезентативный экран
[60:13] => точно так же, как у нас в камере, мы используем
[60:16] => операции, которые мы обсудим в течение
[60:17] => вот теперь математически, как делает
[60:19] => операторская работа
[60:21] => если мы рассмотрим эту красную координатную ось
[60:24] => в качестве оси камеры
[60:25] => у нас есть этот момент в 3d-сцене, который
[60:28] => мы можем видеть через эту ось камеры
[60:31] => теперь мы определяем новую точку, которая является
[60:33] => называется центром камеры, который снимается
[60:36] => быть началом этой координатной оси
[60:39] => вот здесь теперь все точки, которые
[60:41] => расположенный на расстоянии одной единицы от
[60:45] => эта камера центрируется в направлении z
[60:47] => ось
[60:48] => это то, что мы называем плоскостью изображения
[60:52] => теперь эта плоскость изображения является плоскостью 2d
[60:54] => поверхность, которая определила свои x и y
[60:57] => координаты в этом направлении x
[60:59] => направление берется вверх и
[61:01] => направление берется в этом направлении
[61:04] => мы также можем понять эту плоскость изображения
[61:07] => как
[61:08] => сидя в центре камеры
[61:10] => и смотреть на экран кинотеатра, который является одним
[61:13] => подразделение вдали от нас
[61:15] => теперь эта полная проблема сводится к
[61:20] => если нам дана эта трехмерная точка, мы хотим
[61:23] => спроецируйте эту 3d-точку на это изображение
[61:29] => вот как бы выглядела эта 3d точка
[61:31] => как если бы мы увидели это в
[61:34] => плоскость 2d проецируемого изображения
[61:37] => и это именно то, что делает камера
[61:40] => преобразует 3d-сцену в 2d-изображение
[61:43] => мы достигаем этого, используя аналогичный
[61:46] => однородные преобразования
[61:48] => если нам дана матрица преобразования
[61:50] => m мы можем просто умножить это на наш
[61:53] => вектор 3d-объекта x прочерк и получите новый
[61:56] => вектор, представляющий собой x двойное тире
[61:59] => также для того, чтобы понять, как эти точки
[62:02] => будет выглядеть так, как в этой плоскости изображения
[62:04] => нам нужно разделить x и y
[62:08] => координаты этого нового x двойной черточки
[62:10] => вектор с его координатой z, который мы
[62:14] => можете видеть здесь
[62:17] => решая обе эти операции, мы
[62:18] => бы получить трансформацию 3d
[62:21] => точка на плоскости 2d-изображения
[62:24] => в нашем случае, как это работает, если мы
[62:27] => учитывая облако точек, которое генерируется
[62:29] => с помощью лидара, использующего эти операции
[62:34] => мы можем видеть, как выглядит это облако точек лидара
[62:36] => будет выглядеть так, как если бы мы надели его на
[62:39] => изображение, создаваемое камерой
[62:42] => теперь это полное понятие однородного
[62:44] => преобразования очень важны для
[62:46] => робототехника, а также компьютерное зрение
[62:49] => он используется в мобильных самоуправляемых автомобилях
[62:52] => роботы и даже роботы-манипуляторы
[62:56] => в компьютерном зрении, помимо этого
[62:57] => приложение оно также используется в 3d сцене
[63:00] => реконструкция
[63:02] => теперь параметры, используемые для
[63:04] => операции, которые мы проводили по эту сторону
[63:06] => платы называются внешними
[63:08] => параметры
[63:10] => и параметры, которые мы использовали для этого
[63:12] => стороны платы называются внутренними
[63:15] => параметры
[63:16] => внешние параметры являются внешними по отношению к
[63:19] => камера и зависит от того, как камера
[63:22] => помещенный
[63:24] => внутренние параметры зависят от
[63:26] => внутренние части камеры, например,
[63:28] => фокусное расстояние объектива камеры
[63:32] => существует множество различных способов, которыми мы
[63:34] => можно использовать для определения того, какие
[63:36] => внешние и внутренние параметры
[63:38] => данной камеры
[63:40] => один из очень популярных способов определить эти
[63:43] => является методом шахматной доски
[63:45] => в этом методе мы делаем распечатанную фотографию
[63:48] => из шахмат или шахматной доски, и мы
[63:50] => щелкайте по его изображениям в разных положениях
[63:53] => и углы
[63:55] => мы применяем ряд различных
[63:57] => операции с этими изображениями для определения
[63:59] => внешнее и внутреннее
[64:01] => параметры камеры
[64:03] => это вся теория, которая нам нужна была для
[64:05] => обсуждать
[64:06] => для визуализации данных теперь давайте
[64:09] => кратко взгляните на код того, как
[64:12] => эта визуализация данных работает так
[64:14] => давайте перейдем ко всему коду, которым мы являемся
[64:16] => использование для создания этих 3d
[64:18] => визуализации будут присутствовать в
[64:20] => поле с описанием также ниже
[64:22] => хорошо, а теперь давайте сначала обсудим, как
[64:25] => мы создаем это
[64:26] => лидарные данные в виде камеры
[64:30] => для того, чтобы конвертировать, у нас есть эти очки
[64:32] => массив здесь этот массив содержит все
[64:35] => точки облака точек, которые были
[64:37] => захваченный лидаром
[64:39] => мы передаем этот массив точек
[64:42] => к функции, называемой velo to cam
[64:45] => наряду с этим мы также передаем
[64:47] => внешняя матрица камеры
[64:50] => значение для того, чтобы прийти сюда, означает
[64:52] => камера velodyne 2
[64:55] => velodyne — это лидарный датчик, который был
[64:57] => используется здесь
[65:00] => в общем, что этот парень должен
[65:02] => функция выполняет
[65:04] => он берет этот облачный массив и берет
[65:06] => эта матрица v-c, и она просто выполняет
[65:09] => матричное умножение на них
[65:12] => как только мы получим очки в камере
[65:14] => ссылка
[65:15] => затем мы вычисляем матрицу
[65:16] => умножение этих точек на
[65:20] => встроенная матрица камеры
[65:24] => и мы проводим операцию разделения снова
[65:26] => здесь
[65:27] => и, наконец, мы заливаем разными цветами
[65:29] => используя это выражение здесь
[65:32] => и вызывая эту функцию на разных
[65:33] => набор облаков точек дает нам это
[65:36] => следующая визуализация, которую мы видим над
[65:38] => здесь
[65:42] => создание этого представления лидара также
[65:44] => называемый вид с высоты птичьего полета относительно
[65:47] => простой
[65:49] => мы просто берем точки зрения точки
[65:52] => облако
[65:53] => и масштабировать их таким образом, чтобы они
[65:56] => занимают полный кадр данного
[65:59] => изображение
[66:02] => и затем, наконец, заполните разные
[66:04] => цвета, которые присутствуют здесь
[66:07] => и вот как мы получаем изображение с высоты птичьего полета
[66:09] => просмотр данных лидара
[66:12] => получение этой визуализации изображения — это
[66:15] => довольно просто
[66:16] => и эти данные уже предоставлены, и мы
[66:19] => не нужно выполнять какую-либо обработку над
[66:21] => здесь как таковой
[66:24] => получение коробок для печати здесь — это
[66:26] => также просто, как и то, как мы сделали для
[66:28] => лидар
[66:30] => мы используем внешнее и внутреннее
[66:31] => параметры камеры для достижения того же
[66:35] => и это всего лишь комбинированный взгляд на
[66:37] => лидар и коробки
[66:42] => хорошо, значит, это все для этого видео
[66:47] => хорошо, итак, проблема многозадачности
[66:50] => обучение таково, что мы хотим извлечь
[66:52] => единую сеть, которую можно использовать для
[66:55] => различные задачи компьютерного зрения
[67:00] => набор данных, который мы собираемся использовать
[67:02] => для этого конкретного проекта является
[67:05] => набор данных городских пейзажей ссылка для этого
[67:07] => фрагмент данных будет присутствовать в
[67:09] => поле описания под городским пейзажем
[67:11] => набор данных состоит из разных улиц
[67:13] => просмотр изображений
[67:15] => это изображения, снятые с автомобиля, который
[67:17] => быть ведомым по дороге
[67:19] => этот набор данных, в частности, используется для
[67:22] => оценка глубины и семантический
[67:24] => сегментация давайте взглянем на
[67:26] => изображения, присутствующие в наборе данных, и что
[67:29] => этими двумя задачами являются
[67:31] => итак, это разные образы, которые
[67:32] => присутствуют в наборе данных
[67:48] => хорошо, теперь давайте обсудим, что такое
[67:49] => задача оценки глубины в качестве названия
[67:52] => подразумевает, что в этой задаче мы хотим
[67:54] => вычислите глубину любого объекта, который
[67:57] => присутствует в изображении
[67:59] => позвольте нам взглянуть на некоторые из
[68:01] => примеры изображений, чтобы подчеркнуть этот момент подробнее
[68:03] => понятно
[68:04] => на этом изображении у нас есть этот грузовик, который
[68:07] => перед вашей машиной
[68:09] => и с помощью цветового градиента мы можем
[68:11] => видите, что глубина почти постоянна в
[68:13] => перед этим
[68:15] => мы также можем наблюдать другие подобные особенности
[68:17] => из этого градиентного цвета
[68:19] => участки, прилегающие к автомобилю, слегка
[68:22] => темнее по цвету и по мере того, как мы удаляемся от
[68:25] => в машине цвета становятся немного светлее
[68:28] => как мы можем видеть здесь
[68:32] => похожий вид мы можем иметь и здесь
[68:34] => рядом с нашей машиной стоит машина и
[68:37] => мы можем видеть очень темный цвет для этого
[68:40] => машина
[68:41] => и по мере того, как объекты исчезают, цвет
[68:44] => становится все светлее и светлее, давайте устроим
[68:46] => посмотрите еще несколько примеров изображений
[69:02] => таким образом, общая работа в этой задаче заключается в том, чтобы
[69:04] => расчет карт глубины
[69:06] => и карты глубины без
[69:09] => базовое изображение выглядит примерно так
[69:11] => этот
[69:24] => для задачи сегментации изображения нам нужно
[69:26] => для сегментации различных объектов, которые
[69:29] => присутствующий на изображении давайте посмотрим
[69:31] => на некоторых примерах изображений в этом примере
[69:33] => все автомобили и транспортные средства сегментированы
[69:36] => в желтом цвете
[69:38] => а деревья и фон — это
[69:40] => сегментированный красным цветом
[69:44] => нечто подобное можно наблюдать в
[69:46] => это изображение также давайте взглянем на
[69:48] => другие примеры изображений, а также
[70:05] => таким образом, общая работа в этой задаче заключается в том, чтобы
[70:08] => вычисление меток сегментации
[70:11] => что мы можем видеть на примерах изображений
[70:13] => сюда
[70:27] => хорошо, итак, это визуализация
[70:29] => данных, которые мы собираемся использовать
[70:32] => теперь давайте взглянем на технику
[70:34] => которые мы собираемся использовать для решения
[70:36] => многозадачная проблема обучения
[70:38] => хорошо, итак, проблема многозадачности
[70:40] => обучение происходит следующим образом
[70:43] => мы хотим создать сеть, которая может быть
[70:45] => используемые для решения различных задач эти
[70:48] => различными задачами могут быть обнаружение объектов
[70:51] => классификация объектов и объект
[70:53] => сегментация
[70:55] => ограничение в этой проблеме заключается в том, что
[70:57] => у нас не может быть разных сетей для
[70:59] => для этих различных задач мы должны использовать
[71:02] => единая сеть, которая запускается один раз и
[71:04] => обученный однажды решать все разные
[71:07] => задачи преимущество, которое он имеет перед
[71:09] => распределенные сети — это то, что мы не
[71:12] => придется обучать каждую сеть без исключения
[71:14] => индивидуально для различных задач
[71:17] => что приводит к экономии некоторого времени, так что
[71:19] => техника, которую мы собираемся обсудить
[71:21] => для этого многозадачного обучения m10 m10
[71:25] => расшифровывается как многозадачная сеть внимания
[71:29] => и это та архитектура, которая m10
[71:32] => следует заданному входному изображению, первое
[71:35] => шаг, который мы делаем, — это вычисляем общий
[71:38] => особенности данного входного изображения
[71:41] => затем у нас есть модули для конкретных задач, которые
[71:45] => используйте эти общие функции для решения своих
[71:48] => поставленная задача
[71:50] => для n-го числа задач мы собираемся
[71:52] => уделяйте особое внимание модулям, которые
[71:55] => модули внимания берут некоторые данные из
[71:57] => общие функции
[71:59] => и увеличить его таким образом
[72:01] => это полезно для их конкретной задачи
[72:04] => слово «внимание» здесь относится к
[72:07] => внимание, которое каждый модуль уделяет
[72:09] => его особая задача
[72:11] => для техники m10 мы можем использовать любую
[72:14] => сверточная сеть для вычисления
[72:17] => общие функции
[72:18] => для нашего конкретного проекта мы собираемся
[72:20] => использовать сегмент для расчета общего
[72:23] => особенности
[72:24] => теперь сегмент — это сеть, которая используется для
[72:26] => решите задачу сегментации изображения в
[72:29] => задача сегментации изображений, которую мы будем
[72:31] => дано входное изображение, и задача состоит в том, чтобы
[72:34] => сегментируйте различные объекты, которые
[72:36] => присутствующий в этом образе
[72:38] => для этой задачи сегментации изображения
[72:40] => используемые сети имеют общую
[72:42] => структура общая структура такова
[72:44] => что нам дается входное изображение,
[72:46] => первый шаг, который мы делаем, — это пробуем
[72:49] => изображение и извлекать из этого функции
[72:51] => изображение, как только мы уменьшим выборку изображения и
[72:53] => достигнем узкого места, мы увеличим выборку
[72:55] => изображение в том же размере, что и заданное
[72:58] => входное изображение и с помощью
[73:00] => характеристики, полученные при понижающей дискретизации
[73:02] => задача вывести маску сегментации
[73:05] => часть сети с понижающей дискретизацией — это
[73:07] => также называемый кодировщиком и
[73:09] => часть сети с повышающей дискретизацией также
[73:12] => вызвал дешифратор
[73:14] => единственная разница между сегментом и
[73:16] => полностью сверточные нейронные сети — это
[73:19] => операция, которую мы используем для до
[73:21] => отбор проб
[73:22] => таким образом, сегментная архитектура имеет
[73:24] => различные блоки свертки, как мы можем
[73:25] => смотри сюда
[73:28] => эти блоки свертки состоят из
[73:30] => слои свертки, за которыми следуют некоторые
[73:32] => объединение слоев
[73:34] => теперь архитектура m10 находится в таком
[73:36] => таким образом, для каждой из этих сверток
[73:38] => блоки у нас есть подмодули внимания
[73:42] => эти подмодули предназначены для синей задачи
[73:44] => и эти подмодули предназначены для красного
[73:46] => задача
[73:48] => стрелки здесь показывают поток данных
[73:51] => это происходит между общим
[73:52] => сеть
[73:53] => теперь есть некоторые различия в восходящем
[73:56] => модули выборки внимания и снижение
[73:58] => модули внимания к выборке
[74:01] => давайте обсудим их немного подробнее
[74:04] => для модуля up sample внимание
[74:06] => мы получаем входные данные из предыдущего
[74:08] => модуль внимания, который мы можем видеть над
[74:10] => здесь
[74:11] => и мы берем другой вход, который
[74:13] => полученный из первого слоя
[74:15] => блок свертки, как мы можем видеть на
[74:17] => здесь
[74:19] => эти две матрицы объединены
[74:22] => операция свертки над ними такова
[74:24] => вычисленный дважды
[74:27] => а затем мы рассчитываем по элементам
[74:30] => умножение произведенной продукции
[74:32] => сюда
[74:33] => и вход одного из фильтров
[74:36] => эта свертка блокируется, как мы можем видеть
[74:38] => сюда
[74:41] => тогда это поэлементное умножение равно
[74:43] => еще раз отправил через сверток
[74:45] => блок, и вывод возвращается в
[74:48] => следующий модуль внимания для нижестоящих
[74:50] => модуль отбора проб мы
[74:53] => мы берем исходные данные из предыдущего
[74:56] => модуль натяжения, который мы можем видеть над
[74:57] => здесь
[75:00] => этот ввод передается через свертку
[75:03] => блок, который затем объединяется с
[75:06] => ввод первого слоя
[75:07] => блок свертки, который присутствует над
[75:09] => здесь
[75:12] => этот объединенный фильтр передается дважды
[75:14] => через блоки свертки
[75:17] => тогда поэлементное умножение равно
[75:19] => рассчитанный для этого вывода и входного
[75:22] => это взято из одного из слоев
[75:24] => блок свертки, как мы можем видеть на
[75:26] => здесь
[75:28] => и этот конечный результат отправляется в
[75:30] => следующий модуль внимания модуль натяжения
[75:33] => отличается только для выборки вверх
[75:35] => и этап отбора проб общего
[75:37] => сеть функций
[75:39] => для различных задач внимание
[75:41] => архитектура модуля точно такая же
[75:45] => и это полная сеть
[75:46] => архитектура сети m10
[75:50] => один дополнительный прием, который m10
[75:52] => это то, что называется динамическим
[75:55] => усреднение веса
[75:57] => для любой многозадачной обучающей сети
[76:00] => мы рассчитываем потери с помощью взвешенного
[76:03] => среднее значение потерь, рассчитанных для
[76:05] => разные задачи, как мы можем видеть здесь
[76:09] => корректировка весов этих
[76:11] => потери очень важны для сети
[76:13] => чтобы действительно сойтись и изучить
[76:15] => разные задачи
[76:18] => динамическое усреднение веса — это метод
[76:20] => который используется для определения этих весов
[76:23] => основываясь на скорости изменения
[76:25] => потеря градиента теперь, какова скорость
[76:28] => изменение потери градиента, если мы рассмотрим
[76:30] => две обучающие партии изображений, вводимые в
[76:33] => сеть в момент времени t и время t плюс 1
[76:36] => разница между потерей, которая составляет
[76:39] => обратно распространяется в момент времени t плюс 1 и
[76:42] => время t — это то, что называется скоростью
[76:45] => изменение потери градиента
[76:47] => мы рассчитываем эти значения веса по
[76:49] => принимая мягкое максимальное среднее значение, используя
[76:52] => скорость изменения потерь и это
[76:54] => техника дает нам оптимальное значение
[76:57] => веса, которые мы должны иметь для
[76:58] => эти индивидуальные потери
[77:00] => итак, это два основных вклада
[77:02] => сети многозадачного внимания
[77:04] => техника
[77:06] => так что это вся теория, которая нам нужна
[77:07] => чтобы прикрыть технику m10, теперь позвольте
[77:10] => давайте кратко ознакомимся с кодом и
[77:12] => результаты, полученные с использованием этой техники
[77:16] => хорошо, итак, код или записная книжка для этого
[77:19] => m10 будет присутствовать в описании
[77:21] => вставка ниже также
[77:23] => итак, первое, что мы сделали
[77:25] => здесь реализован набор данных
[77:27] => класс загрузчика, который мы можем видеть здесь
[77:30] => теперь этот класс загрузчика наборов данных является
[77:31] => специфичный для набора данных о городских пейзажах
[77:34] => архитектура, которую мы обсуждали, может
[77:36] => может быть применен к ряду различных данных
[77:38] => наборы и для этих наборов данных мы бы
[77:41] => должны реализовать эти конкретные классы
[77:46] => затем мы определили полезность
[77:48] => функции
[77:49] => модель подходит, которая используется для обучения
[77:52] => модель
[77:53] => у нас также есть различные показатели, которые
[77:55] => матрица путаницы
[77:57] => и ошибка глубины
[78:00] => и тогда у нас есть эта функция, называемая
[78:02] => многозадачный тренажер
[78:04] => который занимается полным обучением
[78:06] => сеть
[78:08] => мы также определили сеть в этом
[78:11] => класс сегмента
[78:14] => наконец мы загружаем набор данных и тренируемся
[78:17] => это в наборе данных
[78:19] => следует отметить, что авторы
[78:22] => этот метод обучил сеть на
[78:24] => 200 эпох со скоростью обучения 10
[78:28] => повышен до мощности -4
[78:30] => однако из-за наложенных ограничений
[78:32] => путем манипулирования временем тренировки не
[78:34] => позвольте нам поэкспериментировать с этими значениями
[78:40] => следовательно, для этого конкретного эксперимента
[78:42] => эпохи принимаются равными 100, а
[78:44] => скорость обучения считается увеличенной на 10
[78:45] => до степени минус 3.
[78:47] => результаты тренинга достойные
[78:49] => и хороший
[78:51] => однако
[78:52] => было бы лучше, если бы мы использовали
[78:55] => параметры, которые были предоставлены
[78:57] => авторы
[78:58] => позвольте нам взглянуть на некоторые из
[79:00] => результаты левый — оригинал
[79:02] => карта сегментации, а правая — это
[79:04] => прогнозируемая карта сегментации
[79:31] => как мы видим, есть небольшие проблемы
[79:33] => с которыми сталкивается эта сеть при сегментации
[79:36] => по циклам
[79:38] => но в целом результаты действительно выглядят хорошо
[79:42] => это результаты сегментации
[79:44] => наложенный на изображение
[79:58] => теперь давайте взглянем на карты глубины
[80:00] => левая — это исходная карта глубины
[80:02] => и правильный — это предсказанная глубина
[80:04] => карта
[80:23] => для карты глубины мы также можем сказать, что там
[80:26] => есть небольшие ошибки здесь и там, но
[80:27] => результаты в целом кажутся хорошими
[80:30] => теперь это карты глубины, наложенные на
[80:33] => изображение
[80:54] => хорошо, вот и все для этого видео
[80:59] => хорошо, итак, набор данных, который мы
[81:00] => собираюсь использовать для этого видео котенка
[81:03] => набор данных для обнаружения 3d-объектов, который мы будем
[81:05] => быстро просмотрите этот набор данных в этом
[81:07] => видео также
[81:09] => этот набор данных содержит изображения, которые были сделаны
[81:11] => с передней камеры самоуправляемого
[81:14] => машина, как мы можем видеть их здесь
[81:21] => нам также предоставляются данные лидара
[81:24] => это было зафиксировано лидаром, присутствующим на
[81:27] => самоуправляемый автомобиль, каким мы его видим
[81:29] => сюда
[81:39] => и это данные лидара, спроецированные
[81:42] => в поле зрения камеры
[81:50] => итак, это набор данных, которым мы являемся
[81:52] => собираюсь работать с
[81:53] => теперь самое классное в sfa 3d
[81:56] => техника заключается в том, что
[81:58] => эта сеть использует данные лидара только для
[82:01] => выполните задачу обнаружения 3d-объектов
[82:04] => отсюда и образы, которые присутствуют в
[82:06] => этот набор данных вообще не используется
[82:10] => следует также отметить еще одну вещь
[82:12] => эти данные, которые мы визуализируем над
[82:15] => вот обработанная форма kt3d
[82:17] => набор данных об обнаружении объекта
[82:20] => однако для получения конечного результата
[82:22] => о технике
[82:24] => мы собираемся использовать необработанную форму
[82:27] => набор данных kt, предоставленный в форме
[82:30] => видеопотока
[82:32] => видеопоток в реальном времени и лидар
[82:34] => поле данных будет использоваться для окончательного
[82:37] => задача прогнозирования
[82:39] => хорошо, значит, это все для данных
[82:40] => набор теперь давайте обсудим технические
[82:43] => детали этой технологии sfv 3d
[82:46] => хорошо, итак, как мы уже обсуждали, мы собираемся
[82:48] => используйте sfa 3d для обнаружения 3d-объектов
[82:52] => задача
[82:53] => sfa 3d означает сверхбыстрый и
[82:57] => точное обнаружение 3d-объектов
[83:00] => итак, sfa 3d как целостная техника
[83:04] => обнаруживает ли 3d-объект, используя только
[83:07] => данные лидара
[83:08] => в качестве входных данных мы предоставляем sfa 3d в качестве
[83:12] => входное изображение с высоты птичьего полета на
[83:15] => сеть
[83:16] => сеть предсказывает различные
[83:18] => объекты, присутствующие на этом изображении
[83:21] => а также классифицирует их также
[83:24] => данные, собранные с помощью лидара, представляют собой 3d
[83:27] => данные, когда мы просматриваем эти 3d-данные с
[83:30] => вид сверху этот вид сверху также называется
[83:33] => вид этой сцены с высоты птичьего полета
[83:36] => как только вы предоставите сети
[83:38] => изображение лидарной сцены с высоты птичьего полета
[83:41] => в качестве результата мы получаем семь выходов
[83:45] => эти семь результатов являются
[83:48] => тепловые карты различных классов, которые
[83:51] => присутствуют в изображении
[83:53] => расстояние от центра других
[83:55] => объекты из нашей машины эго или
[83:58] => самоуправляемый автомобиль
[84:00] => углы, под которыми другие объекты
[84:02] => сталкиваются
[84:04] => размеры объектов, которые мы
[84:06] => определили длину ширину и
[84:08] => высота
[84:09] => и z-координата центра
[84:12] => этот объект, как мы видим, находится над
[84:14] => вот так вот теперь мы обсудили ввод
[84:18] => а также список результатов, которые sfa
[84:20] => 3d предоставляет нам
[84:22] => в настоящее время sfa 3d в основном состоит из трех
[84:26] => компоненты, которые являются ключевым моментом fpn
[84:30] => различные потери, которые мы переживаем
[84:32] => использовать для этой сети и обучения
[84:35] => методика планирования ставок, которую мы используем
[84:38] => для обучения
[84:41] => давайте обсудим эти техники по очереди
[84:43] => один
[84:44] => первый компонент, который мы собираемся
[84:46] => обсуждение является ключевым моментом fpn
[84:48] => прежде чем обсуждать ключевой момент fpn, давайте
[84:51] => сначала обсудите, что такое fpn
[84:54] => fbn расшифровывается как сеть пирамид функций
[84:58] => особенность пирамидальной сети — это особенность
[85:00] => метод извлечения, который дает один
[85:03] => входное изображение выводит другую функцию
[85:06] => карты, которые различаются по размеру
[85:09] => это кое-что, как мы можем видеть здесь
[85:11] => учитывая одно входное изображение, выходы
[85:14] => являются различными картами объектов разных
[85:16] => размеры итак, что такое извлечение объектов и
[85:19] => функция отображает все важные данные, которые
[85:22] => содержится внутри изображения — это то, что
[85:25] => называемые объектами они могут быть точками ребрами
[85:29] => узоры и узоры или даже человеческие лица
[85:33] => в сверточной нейронной сети мы
[85:35] => есть так называемые блоки свертки
[85:38] => эти блоки свертки состоят из
[85:40] => различные слои свертки и охлаждение
[85:43] => слои
[85:44] => мы предоставляем входное изображение для этих
[85:47] => блоки свертки, и мы получаем вывод
[85:50] => изображение или, можно сказать, матрица этого вывода
[85:53] => изображение или матрица — это то, что называется
[85:54] => функция отображает процесс извлечения
[85:57] => особенности данного изображения — это то, что есть
[86:00] => называется функция извлечения объектов, теперь функция
[86:02] => пирамидальные сети — это не сеть, созданная
[86:05] => название на самом деле это общая техника
[86:08] => которые мы можем использовать в ряде
[86:10] => различные нейронные сети
[86:12] => например, мы можем применить эту функцию
[86:15] => метод пирамидальной сети для создания
[86:18] => карты объектов в архитектуре resnet как
[86:21] => хорошо путем последующей обработки этих выходных данных
[86:24] => карты объектов мы можем выполнить ряд
[86:26] => различные задачи, такие как обнаружение объектов
[86:29] => особенность метода пирамидальной сети
[86:31] => работает таким образом
[86:33] => учитывая это входное изображение, мы передаем его
[86:36] => с помощью ряда различных
[86:37] => блоки свертки и убедитесь, что эти
[86:41] => изображения становятся меньше по размеру
[86:44] => как мы можем видеть здесь, входное изображение
[86:47] => становится все меньше в размерах по мере того, как мы
[86:49] => подойдите к вершине пирамиды
[86:52] => затем мы используем последовательные итерации
[86:55] => блоки свертки, гарантирующие, что они до
[86:58] => пример данного изображения, как мы можем видеть
[87:00] => сюда
[87:02] => изображение увеличивается в размерах по мере того, как мы
[87:05] => подойдите к основанию пирамидальной сети
[87:08] => вместе с извилинами, которые мы
[87:10] => подать заявку в этой части сети мы
[87:12] => тоже
[87:16] => предоставлять информацию в этой части
[87:18] => сеть из предыдущей части
[87:20] => сеть, как мы можем видеть через пропуск
[87:22] => связи здесь
[87:25] => и мы генерируем выходные карты объектов
[87:27] => из этой части сети, как мы можем
[87:29] => смотри сюда
[87:31] => теперь функциональные пирамидальные сети являются отличным
[87:34] => техника, которую следует использовать, если мы хотим создать
[87:36] => сети, которые масштабируются в варианте
[87:40] => итак, что такое масштабно-инвариантная сеть
[87:43] => давайте предположим, что мы хотим предсказать
[87:46] => шар, присутствующий на изображении с использованием
[87:49] => простая сверточная сеть, если шар
[87:52] => что присутствует в этом изображении большого
[87:54] => размер или этот шар небольшого размера,
[87:58] => нейронная сеть должна быть способна обнаруживать
[88:00] => шар, который присутствует на этом изображении
[88:03] => это свойство обнаруживать независимо
[88:06] => от размера этого объекта зависит то, что
[88:08] => называемый масштабом дисперсии
[88:11] => для таких задач, как обнаружение объектов, нам нужно
[88:14] => чтобы предсказать ограничивающую рамку, которая говорит нам
[88:17] => где этот объект присутствует в этом
[88:19] => изображение
[88:20] => для подобных задач масштабная инвариантность равна
[88:23] => важное свойство, которое нейронное
[88:25] => предполагается, что сети должны иметь
[88:27] => однако для обнаружения точек в данном
[88:30] => инвариантность масштаба изображения не играет
[88:33] => главная роль
[88:34] => если мы хотим обнаружить единственную точку в
[88:37] => учитывая изображение, эта точка будет
[88:39] => оставаться в том же месте, независимо
[88:43] => о масштабировании, которое мы применяем к этому
[88:45] => изображение, следовательно, непосредственно применяющее функцию
[88:48] => пирамидальные сети для обнаружения точек в
[88:51] => изображение не является эффективным методом
[88:53] => ключевой особенностью пирамидальных сетей являются
[88:56] => расширение для данных сетей fpn
[88:58] => которые помогают нам обнаруживать точки в данном
[89:01] => изображение
[89:02] => общая архитектура ключевой точки
[89:04] => fpl остается прежним
[89:07] => выходы fpn могут быть визуализированы
[89:09] => как мы можем видеть здесь
[89:11] => эти выходы в форме гаусса, которые мы
[89:14] => смотри сюда
[89:15] => указывают на то, что сеть действительно
[89:18] => уверенный в том, что точка присутствует в
[89:21] => заданное местоположение на изображении, но так как мы
[89:24] => отойдите от этой точки уверенности
[89:26] => уровень сети снижается так, как мы можем
[89:29] => видите по форме вот здесь
[89:33] => итак, как только у нас появятся эти функции, выводите
[89:35] => карты мы преобразуем эти карты объектов в
[89:38] => аналогичный размер
[89:39] => в данном конкретном случае мы предприняли
[89:42] => эталонный размер должен быть самым большим
[89:44] => карта объектов, которая присутствует у нас
[89:47] => мы увеличиваем выборку небольших карт объектов, чтобы
[89:50] => соответствует размеру самого большого объекта
[89:52] => карта, которая у нас есть, как мы можем видеть на этом
[89:54] => колонка здесь
[89:57] => затем мы вычисляем средневзвешенное значение
[89:59] => эти карты функций и получить окончательный
[90:02] => один выход, как мы можем видеть здесь
[90:06] => веса средневзвешенного значения составляют
[90:08] => зависит от значения достоверности, которое
[90:10] => сеть имеет в этом разные
[90:13] => карты объектов
[90:14] => из этой карты объектов мы можем взять
[90:16] => точка, которая имеет наивысшую степень достоверности
[90:19] => значение и выводите это как точку, которая
[90:22] => мы хотели обнаружить
[90:24] => эта полная постобработка, которую мы
[90:26] => сделали после простой сети fpn
[90:29] => это то, что составляет ключевой момент fpn
[90:31] => сеть
[90:33] => хорошо, так что это полный
[90:34] => сетевая архитектура sfa 3d
[90:37] => техника теперь давайте обсудим
[90:39] => различные функции потерь, которые являются
[90:41] => нанятый для обучения этой сети
[90:44] => во-первых, мы собираемся обсудить
[90:46] => результаты, которые генерируются этим
[90:48] => сеть
[90:49] => первый вывод — это тепловая карта
[90:52] => тепловая карта разных классов представляет собой данные
[90:54] => техника визуализации, которая говорит нам
[90:57] => величина данного явления
[90:59] => происходящее на заданном входе, грубо говоря, мы
[91:03] => может визуализировать тепловую карту с помощью
[91:05] => горный рельеф
[91:06] => обычно в горном массиве у нас есть
[91:10] => гора, имеющая самую высокую вершину и
[91:12] => имеет сопутствующие холмы или горы, которые
[91:15] => имеют меньшие пики, чем этот самый высокий
[91:17] => вершина горы
[91:19] => по мере того как мы удаляемся от этой высочайшей вершины
[91:21] => высота земли также начинается
[91:23] => уменьшающийся во всех направлениях
[91:26] => что-то вроде этого
[91:29] => по мере того как мы удаляемся от этой высочайшей вершины
[91:32] => мы приближаемся к другой соседней горе
[91:34] => или холм
[91:35] => после уменьшения высоты высота
[91:38] => снова начинает увеличиваться, пока мы не достигнем
[91:40] => вершина или вершина соседнего
[91:42] => гора
[91:44] => и еще раз, когда мы уходим от этого
[91:47] => пик высота снова начинает уменьшаться
[91:50] => если мы рассмотрим такой горный регион
[91:52] => вид сверху
[91:54] => и визуализируйте высоту земли
[91:56] => на этом изображении мы получаем то, что называется
[91:59] => тепловая карта
[92:00] => если мы обозначим большую высоту темным
[92:03] => красный цвет и меньшая высота на белом
[92:07] => цвет
[92:08] => мы будем наблюдать, что самый высокий
[92:10] => пик имеет сплошной красный цвет, когда мы двигаемся
[92:13] => подальше от этого пика этого сплошного красного цвета
[92:16] => собирается распасться до белого цвета
[92:20] => снова, когда мы приближаемся к другой вершине, которая
[92:22] => белый цвет собирается сойтись в
[92:26] => снова сплошной красный цвет
[92:28] => тепловая карта также может быть визуализирована в
[92:31] => условия уверенности сети в том, что она
[92:34] => зависит от его предсказаний
[92:36] => в нашем конкретном случае, если мы хотим
[92:39] => обнаружить три объекта, скажем, автомобиль,
[92:42] => грузовик и пешеход, которых мы собираемся
[92:44] => создайте три разные тепловые карты
[92:48] => в этом случае красный цвет означает, что
[92:50] => есть автомобиль, который присутствует в этом
[92:53] => изображение в этом конкретном месте и
[92:55] => сеть уверена в этом
[92:57] => местоположение
[92:59] => точно так же пешеход присутствует в
[93:01] => это местоположение и сеть являются
[93:03] => уверенный в своем предсказании в этом
[93:05] => конкретное местоположение
[93:08] => по мере того как мы отдаляемся от обоих этих
[93:10] => повышает доверие к сети
[93:12] => опускается
[93:14] => используя эту тепловую карту, мы определяем класс
[93:17] => объекта, будь то автомобиль или
[93:19] => пешеход
[93:21] => в целях поощрения сети к
[93:23] => изучайте правильные классы, мы используем то, что есть
[93:25] => называется очаговой потерей
[93:29] => математическое выражение фокусного
[93:31] => потеря — это что-то вроде этого
[93:34] => фокальная потеря обычно используется, когда есть
[93:36] => существует классовый дисбаланс в данных
[93:40] => классовый дисбаланс обычно возникает, когда
[93:42] => существует меньший объем данных для
[93:44] => особый класс и очень большое количество
[93:46] => данных для другого конкретного класса
[93:49] => здесь pt — доверительное значение
[93:52] => подключите этот коэффициент масштабирования сюда
[93:54] => позволяет сети сосредоточить свое обучение
[93:57] => больше о прогнозах, что это меньше
[94:00] => уверенный в себе и меньше фокусирующийся на
[94:03] => предсказания, что он более уверен
[94:05] => о
[94:06] => следующий результат, который у нас есть, — это
[94:09] => расстояние от карты эго и
[94:12] => направление, в котором находятся другие объекты
[94:14] => но для того, чтобы научиться этому, мы используем
[94:17] => то, что называется потерей l1,
[94:19] => математическое выражение — это нечто
[94:21] => подобный этому
[94:23] => потеря l1 просто принимает разницу в
[94:26] => прогноз и фактическое значение и
[94:29] => вычисляет абсолютное значение этого
[94:31] => разница
[94:33] => следующий результат, который у нас есть, — это
[94:35] => размеры объекта, который мы пытаемся
[94:37] => для обнаружения
[94:38] => и его z-координата расстояния или
[94:41] => высота от земли
[94:45] => для того, чтобы изучить эти четыре параметра
[94:47] => мы используем так называемый сбалансированный убыток l1
[94:51] => теперь, учитывая обучающие данные, мы можем разделить
[94:54] => точки в этих данных примерно на две
[94:57] => категории
[94:58] => выбросы и в слоях во время обучения
[95:02] => сеть точек данных, которые генерируют
[95:04] => величина потерь, которая меньше некоторой
[95:07] => порог, допустим, один вызывается в
[95:10] => лжецы
[95:11] => и
[95:12] => точки данных, у которых есть потеря, которая
[95:15] => превышающие этот порог называются
[95:17] => выбросы
[95:18] => из-за большей величины потерь
[95:21] => выбросы, как правило, привлекают
[95:24] => нейронная сеть весит в сторону
[95:26] => сам
[95:28] => из-за меньшего значения потерь
[95:30] => внутренние слои не способны притягивать
[95:32] => нейронная сеть взвешивает себя по отношению к себе
[95:35] => это достаточно хорошо
[95:37] => для того, чтобы эффективно бороться с такими
[95:40] => дисбаланс значений потерь, которые мы используем, что
[95:43] => называется сбалансированной потерей l1
[95:46] => сбалансированный убыток l1 уравновешивает убыток
[95:49] => значения, которые генерируются обоими
[95:51] => эти внутренние слои и выбросы, чтобы получить
[95:54] => сеть, которая хорошо работает на обоих этих
[95:56] => типы данных
[95:58] => хорошо, значит, это все потери
[96:00] => которые используются в этой сети в следующем
[96:02] => компонент, который мы собираемся обсудить
[96:04] => является ли планирование скорости обучения
[96:07] => при обучении нейронной сети
[96:09] => скорость обучения является важным фактором
[96:11] => параметр, о котором нам нужно позаботиться
[96:13] => особая техника, которую мы применяем к
[96:16] => лучше обучать сеть называется
[96:18] => планирование скорости обучения во время
[96:20] => тренировочный процесс мы склонны уменьшать или
[96:23] => увеличьте значения скорости обучения в
[96:26] => чтобы точно настроить нашу оптимизацию
[96:28] => процесс
[96:29] => метод снижения скорости обучения, который
[96:31] => мы используем в этом
[96:33] => сеть — это косинусный отжиг
[96:36] => график скорости обучения в косинусе
[96:39] => отжиг выглядит примерно так
[96:42] => ближе к началу скорость обучения
[96:44] => медленно уменьшается к середине
[96:47] => скорость обучения начинает снижаться в
[96:50] => линейная мода
[96:51] => и ближе к концу скорость обучения
[96:53] => снижение снова начинает замедляться
[96:56] => сочетание всех этих трех
[96:58] => компоненты — это то, что составляет sfa
[97:01] => 3d-техника в порядке, так что это все
[97:03] => технические детали там заключаются в том, чтобы
[97:05] => обсуждение для 3d-техники sfa
[97:08] => теперь давайте посмотрим на этот алгоритм в действии
[97:11] => хорошо, итак, давайте кратко взглянем на
[97:14] => код
[97:18] => ссылка на этот код и записную книжку
[97:20] => будет указано в поле с описанием
[97:22] => ниже также
[97:23] => первый шаг, который у нас есть, — это
[97:25] => шаг настройки здесь мы настраиваем
[97:28] => различные параметры и переменные, которые
[97:30] => мы собираемся использовать для нашей сети
[97:33] => далее у нас есть другие данные
[97:35] => функции обработки, которые мы используем
[97:38] => одним из таких методов обработки данных является
[97:41] => преобразуйте данные лидара в изображение с высоты птичьего полета
[97:44] => просмотр предоставленных данных
[97:46] => далее у нас есть другая полезность
[97:48] => такие функции, как ведение журнала, которые мы используем для
[97:52] => регистрируйте процесс обучения
[97:54] => изучение отличного планирования, которое мы используем
[97:56] => во время обучения сети и различных
[97:58] => функции утилиты визуализации, которые мы
[98:01] => используйте для визуализации и создания окончательного
[98:03] => выход
[98:04] => далее в этом разделе мы определяем
[98:07] => различные функции потерь, которые мы
[98:09] => использование для обучения сети
[98:11] => наконец, мы определяем сеть fpn resnet
[98:15] => здесь, в этом разделе
[98:17] => и в этом разделе мы, наконец, обучаем
[98:19] => нейронная сеть
[98:21] => одна конкретная проблема в том, что 3d-объект
[98:24] => лицо сети обнаружения
[98:26] => это тренировка
[98:28] => обучение этих сетей действительно
[98:30] => отнимает много времени и требует очень
[98:33] => дорогое и качественное оборудование
[98:36] => поскольку у нас есть ограничение по времени и некоторые
[98:38] => ограничения на аппаратное обеспечение в kaggle
[98:41] => я не смог обучить сеть с помощью
[98:44] => себя
[98:45] => поэтому я использовал предварительно обученный
[98:47] => веса, которые предоставляются вместе с
[98:50] => эта сетевая архитектура
[98:52] => итак, теперь давайте взглянем на финал
[98:54] => вывод итак, это окончательный вывод, который
[98:57] => у нас есть на дороге набор данных для
[99:00] => цель визуализации я замедлил
[99:02] => посмотрите это видео
[99:46] => хорошо, итак, некоторые ключевые наблюдения, которые мы
[99:48] => можете отметить здесь
[99:50] => красные флажки описывают автомобили, которые находятся в
[99:53] => сцена
[99:54] => синие ограничительные рамки предназначены для велосипедистов
[99:57] => которые присутствуют на сцене и желтом
[99:59] => ограничительные рамки предназначены для пешеходов на
[100:01] => данная сцена
[100:02] => одно интересное наблюдение состоит в том, что
[100:05] => сеть не в состоянии обнаружить трамвай
[100:07] => что присутствует в этом изображении
[100:10] => поскольку он не был обучен этим данным
[100:13] => также эти синие линии описывают
[100:16] => ориентация различных
[100:18] => окружающие автомобили
[100:20] => хорошо, значит, это все, что нужно
[100:21] => обсуждение технологии sfa 3d
[100:26] => итак, давайте начнем с проблемы
[100:27] => определение
[100:29] => в этой задаче дан набор изображений
[100:32] => снятый с разных присутствующих камер
[100:35] => на самоуправляемом автомобиле или роботе мы
[100:38] => требуется для обработки этих изображений и
[100:40] => вывести изображение данного объекта с высоты птичьего полета
[100:43] => окружающая среда
[100:45] => вид с высоты птичьего полета или вид сверху просматривают
[100:49] => 3d-сцены сверху
[100:52] => в качестве входных данных мы можем либо иметь один
[100:55] => изображение или у нас может быть несколько разных
[100:57] => изображения, снятые с разных камер
[101:00] => в данном случае мы видим, что это наш
[101:02] => самоуправляемый автомобиль и в данном случае для
[101:05] => наша конкретная проблема у нас есть четыре
[101:07] => камеры спереди слева справа и
[101:11] => назад
[101:12] => учитывая эти четыре изображения, мы должны
[101:14] => для их обработки и вывода птичьего
[101:17] => взгляд на окружающую среду вокруг
[101:20] => машина, как мы видим здесь, красная
[101:22] => прямоугольник — это машина эго или наш
[101:25] => самоуправляемый автомобиль и другой синий
[101:27] => прямоугольники — это другие машины, теперь зачем
[101:30] => нам нужно рассчитать это с высоты птичьего полета
[101:32] => взгляд на окружающую среду
[101:34] => есть в основном две причины, по которым мы бы
[101:36] => нравится вычислять с высоты птичьего полета
[101:38] => первое приложение — это объект
[101:40] => обнаружение
[101:41] => вычисление вида с высоты птичьего полета на
[101:44] => данная среда предоставляет нам
[101:46] => другой способ обнаружения объектов
[101:49] => по сравнению с другими различными компьютерами
[101:51] => методы видения
[101:53] => второй или более важный
[101:55] => приложение — это планирование пути
[101:58] => этот вид с высоты птичьего полета дает нам
[102:00] => краткое представление о
[102:02] => окружающая среда отличается
[102:04] => автомобили и предметы, присутствующие в
[102:07] => сцена и дорога, по которой мы должны
[102:09] => продолжать
[102:11] => используя это краткое представление, мы можем
[102:13] => легко реализовать планирование пути
[102:15] => алгоритмы на нашем самоуправляемом автомобиле
[102:18] => итак, это полное введение в
[102:20] => постановка задачи теперь давайте рассмотрим
[102:23] => посмотрите на набор данных, который мы собираемся
[102:24] => для работы в рамках этого проекта
[102:26] => хорошо, итак, ссылка на эти данные и
[102:29] => этот блокнот для визуализации данных будет
[102:31] => должно быть указано в поле с описанием ниже
[102:34] => точно так же, как в описании проблемы
[102:36] => нам даны четыре изображения передняя часть
[102:39] => сзади слева и справа вместе с этим мы
[102:43] => даны определенные изображения с высоты птичьего полета
[102:47] => теперь изображения, которые нам были даны
[102:49] => это не совсем изображения в реальном времени, но
[102:52] => семантика сегментированных изображений
[102:55] => у нас уже есть разные классы в
[102:58] => эти изображения семантически сегментированы и
[103:01] => мы должны получить представление с высоты птичьего полета
[103:03] => изображение для того же самого
[103:05] => самое классное в этом наборе данных то, что
[103:07] => что сайт данных получен из
[103:09] => моделирование вождения самоуправляемого автомобиля
[103:12] => вокруг среды моделирования, и мы
[103:14] => захватите различные изображения с
[103:16] => четыре разных камеры, которые присутствуют
[103:18] => на самоуправляемом автомобиле летает беспилотник
[103:21] => чуть выше самоуправляемого автомобиля в порядке
[103:23] => чтобы запечатлеть землю с высоты птичьего полета
[103:26] => просмотр изображений
[103:27] => как мы видим, у нас есть эти четыре изображения
[103:29] => взято с камер самоуправляемых автомобилей
[103:32] => изображение спереди изображение сзади изображение слева
[103:34] => изображение и правильное изображение
[103:37] => и это истинная правда с высоты птичьего полета
[103:39] => просмотр изображения 3d-среды
[103:43] => это следующее изображение вид с высоты птичьего полета
[103:45] => изображение окклюзии содержит окклюзию в виде
[103:47] => отдельный класс
[103:49] => это означает, что сцена, которая скрыта
[103:51] => или перекрыты различными предметами в
[103:54] => окружающая среда
[103:55] => представлены с использованием отдельного класса
[103:59] => как мы можем видеть в этом сером цвете над
[104:01] => здесь
[104:06] => этот автомобиль присутствует за самоуправляемым
[104:08] => автомобиль загораживает обзор камеры
[104:12] => в этом сером пространстве
[104:14] => кроме того, некоторые здания также
[104:17] => закрывая пространство, как мы можем видеть над
[104:19] => здесь и из-за этой закупорки мы находимся
[104:21] => не в состоянии увидеть эту машину, которая присутствует
[104:23] => за зданием и не видно
[104:26] => через нашу камеру
[104:28] => это изображение гомографии похоже на
[104:30] => изображение с высоты птичьего полета, которое мы имеем над
[104:32] => здесь, но содержит много шума
[104:36] => так что же такое операция гомографии
[104:39] => проще говоря, используя гомографию
[104:41] => операция, которую мы можем конвертировать из одного изображения
[104:44] => плоскость к другой плоскости изображения
[104:47] => в данном конкретном случае мы
[104:49] => преобразование из этих четырех изображений
[104:52] => спереди сзади слева и справа и с помощью
[104:55] => они создают вид с высоты птичьего полета
[104:58] => изображение
[104:59] => это преобразование с высоты птичьего полета
[105:00] => операция также называется обратной
[105:02] => перспективное отображение
[105:05] => подробнее об этой гомографии и обратном
[105:07] => перспективное картирование будет обсуждаться в
[105:09] => последняя часть видео, и мы будем
[105:11] => поймите, почему мы не используем это
[105:13] => техника непосредственного получения птичьего
[105:15] => изображение с высоты птичьего полета
[105:16] => теперь давайте рассмотрим несколько примеров
[105:18] => из этого набора данных
[105:23] => да
[105:50] => хорошо, итак, техника, которой мы являемся
[105:52] => собираюсь подать заявку на решение этой проблемы, это
[105:55] => единица измерения xst
[105:57] => как следует из названия, эта техника
[106:00] => расширение семантической единицы
[106:03] => архитектура сегментации
[106:05] => следовательно, единица xst имеет два
[106:07] => компоненты сама архитектура устройства
[106:10] => и его расширение давайте обсудим два
[106:12] => компоненты один за другим, так что первый
[106:15] => компонент — это единичная сеть
[106:18] => единица измерения — это сеть, которая используется для
[106:21] => семантическая сегментация в проблеме
[106:24] => семантическая сегментация мы обязаны
[106:26] => сегментировать интересующий регион из
[106:29] => данное изображение, например, в изображении
[106:32] => захваченные самоуправляемым автомобилем, мы
[106:35] => требуется сегментировать автомобили, которые
[106:37] => присутствует в образе и дороге, которая
[106:39] => присутствует в изображении
[106:41] => мы можем сделать это, выделив их с помощью
[106:43] => разные цвета
[106:45] => архитектура устройства аналогична
[106:47] => другая семантическая сегментация
[106:49] => архитектуры, в которых у нас есть кодировщик
[106:52] => часть сети, и у нас есть
[106:54] => декодер часть сети
[106:56] => кодирующая часть уменьшает дискретизацию изображения
[106:58] => получение различных визуальных характеристик в
[107:01] => изображение, а затем у нас есть декодер
[107:03] => часть, которая увеличивает выборку изображения и
[107:06] => возвращает нам выходные данные
[107:08] => помимо информации, полученной из
[107:10] => саму часть декодера декодер использует
[107:13] => информация от части кодировщика с использованием
[107:16] => пропускайте соединения, как мы можем видеть здесь
[107:21] => первоначально была разработана модульная архитектура
[107:24] => для сегментации биомедицинских изображений
[107:27] => однако его варианты использования применимы к другим
[107:30] => домены, а также, например, в нашем случае
[107:32] => самоуправляемые автомобили
[107:34] => unite формирует базовую архитектуру для
[107:36] => эта техника
[107:37] => теперь давайте обсудим xst или
[107:40] => расширительная часть сети устройств
[107:43] => расширительная часть техники заключается в
[107:45] => что мы используем то, что называется
[107:48] => пространственные трансформаторы
[107:50] => итак, прежде чем обсуждать, что такое пространственные
[107:52] => трансформаторы давайте обсудим концепцию
[107:55] => о гомографии
[107:57] => например, у нас есть объект, и мы
[108:00] => возьмите его изображение с камеры, которая
[108:02] => размещенный здесь, мы меняем камеру
[108:05] => положение, а также его ориентация на
[108:07] => что-нибудь здесь, и мы возьмем
[108:09] => изображение снова
[108:11] => трансформация между этими двумя
[108:13] => изображения — это то, что называется гомографией
[108:17] => в математических терминах гомография — это
[108:20] => простое умножение матриц
[108:22] => классное применение гомографии заключается в том, что
[108:26] => если мы знаем матрицу гомографии, которая
[108:29] => преобразует из одной плоскости изображения в другую
[108:32] => плоскость изображения
[108:33] => затем из одного изображения мы можем напрямую
[108:36] => вычислите, как будет выглядеть этот объект
[108:38] => в отдельной плоскости изображения даже без
[108:41] => делаю другой снимок
[108:43] => однако в приложении нам потребуется
[108:45] => эти плоскости изображения должны быть близки друг к другу
[108:48] => другой
[108:48] => в общем, трансформация не нужна
[108:51] => быть таким сложным
[108:53] => они могут быть такими же простыми, как перевод
[108:55] => плоскость камеры или даже поворот камеры
[108:58] => плоскость в заданной фиксированной точке
[109:00] => например, учитывая этот образ, мы
[109:03] => поворот плоскости изображения с помощью
[109:04] => примерно 15 градусов
[109:07] => теперь теоретически казалось бы, что мы
[109:09] => можно просто взять изображение и умножить его
[109:12] => по матрице гомографии h и получаем
[109:15] => конечное результирующее изображение hx
[109:18] => однако это не так просто
[109:21] => проще говоря, гомография — это простое
[109:24] => преобразование, которое отображает пиксели из одного
[109:26] => изображение на другое изображение
[109:28] => следовательно, у нас был бы такой образ
[109:31] => пиксель, сопоставленный с некоторым пикселем изображения в этом
[109:34] => изображение здесь
[109:35] => при выполнении этого матричного умножения это
[109:38] => легко заметить, что выход h x
[109:42] => не будет выводить целочисленные значения
[109:45] => это означает, что данный пиксель
[109:48] => здесь будет нанесено на карту несколько
[109:51] => разные пиксели здесь
[109:53] => следовательно, для того, чтобы применить это
[109:54] => трансформация у нас будет
[109:56] => множество различных средних вычислений
[109:59] => чтобы итоговое изображение выглядело не совсем
[110:02] => хороший
[110:03] => следовательно, решение этой проблемы состоит в том, чтобы сделать
[110:06] => вычисление обратной гомографии что это
[110:09] => означает, что вместо вычисления
[110:10] => преобразование, которое переходит от ввода к
[110:13] => вывод мы вместо этого вычисляем
[110:15] => преобразование, исходящее из выходных данных
[110:17] => пиксель к входным пикселям, например
[110:21] => этот выходной пиксель здесь будет
[110:24] => сопоставьте входное изображение с повернутым
[110:26] => сделай что-нибудь вроде этого здесь
[110:30] => мы рассчитываем среднее значение
[110:32] => окружающие пиксели во входном изображении
[110:36] => например, этот пиксель будет отображаться
[110:39] => чтобы окружить эти четыре пикселя поверх
[110:41] => здесь, следовательно, мы собираемся рассчитать
[110:43] => их средневзвешенные значения пикселей для
[110:46] => выведите значение этого пикселя
[110:49] => это средневзвешенное значение рассчитывается
[110:51] => используя технику, называемую
[110:53] => билинейная интерполяция
[110:55] => средневзвешенное значение берется с
[110:58] => уважение к расстоянию от
[111:00] => окружающие пиксели
[111:02] => вместо билинейной интерполяции мы
[111:04] => может применять другие различные методы
[111:06] => как линейная интерполяция или ближайшая
[111:09] => соседи тоже
[111:11] => однако для пространственных трансформаторов
[111:13] => билинейная интерполяция — это выбор, обусловленный
[111:16] => к его дифференцируемой природе, поэтому обладающий
[111:20] => понял этот полный процесс
[111:22] => гомография
[111:24] => давайте обсудим использование этого
[111:25] => гомография в пространственном трансформаторе
[111:28] => пространственный трансформатор — это расширение
[111:31] => модуль, который может быть применен к любому
[111:34] => сеть свертки это позволяет
[111:37] => сеть свертки, чтобы также изучить
[111:40] => различные пространственные свойства, которые являются
[111:42] => присутствует в наборе данных
[111:44] => пространственный трансформатор изучает
[111:47] => различные параметры гомографии
[111:49] => матрица для того, чтобы помочь свертке
[111:52] => сеть
[111:54] => в том же примере, если у нас есть объект
[111:56] => вот здесь, и мы берем его изображение с
[111:58] => этот момент
[112:00] => и давайте предположим, что по какой-то причине
[112:02] => архитектура cnn не способна классифицировать
[112:05] => этот объект точно так же, как пространственный
[112:08] => трансформаторы собираются помочь
[112:10] => пространственные трансформаторы собираются учиться
[112:12] => параметры матрицы гомографии в таких
[112:15] => способ, которым они представляют изображение для
[112:19] => си-эн-эн с другой точки зрения, так что
[112:22] => cnn может классифицировать этот объект
[112:26] => более точно
[112:28] => итак, поняв, что такое пространственный
[112:31] => трансформатор и как он помогает
[112:34] => давайте посмотрим, как мы применим это к нашему подразделению
[112:37] => техника xst
[112:39] => для техники unit xst мы не
[112:41] => собираюсь изучить параметры
[112:43] => матрица гомографии
[112:45] => вместо этого мы собираемся предоставить
[112:47] => пространственные трансформаторы с фиксированным
[112:49] => матрица гомографии
[112:52] => так где же мы возьмем эту гомографию
[112:54] => параметры
[112:55] => поскольку гомография является общей
[112:57] => приложение мы также можем применить это к
[113:00] => сценарий самостоятельного вождения автомобиля, а также
[113:03] => например, учитывая это изображение с
[113:05] => камеру, обращенную вправо, мы можем легко вывести
[113:08] => гомография, которая соответствует этому праву
[113:11] => камеру к виртуальной камере, которая
[113:14] => присутствующий на вершине
[113:16] => мы можем сделать это для всех четырех камер
[113:19] => и получить представление об окружающей среде сверху
[113:22] => таким образом, мы легко получили бы
[113:25] => параметры гомографии
[113:26] => эта техника получения вида сверху
[113:29] => из этих данных изображений также называется
[113:32] => отображение обратной перспективы
[113:35] => но есть естественный вопрос, который нужно задать
[113:37] => почему мы применяем сложную сеть
[113:39] => архитектуры, такие как unit xst, тогда как мы
[113:42] => можем решить нашу проблему с помощью простого
[113:44] => гомографии
[113:46] => ответ на этот вопрос — вид сверху
[113:48] => гомография или обратная перспектива
[113:51] => отображение делает предположение о том, что
[113:53] => мир вокруг этих камер плоский
[113:56] => мы можем легко заметить, что это
[113:58] => предположение не соответствует действительности ни в каком
[114:01] => какой бы то ни было случай
[114:02] => автомобили грузовики пешеходы и
[114:04] => разные памятники у них есть
[114:06] => значительная высота для того, чтобы
[114:09] => отображение обратной перспективы для работы
[114:12] => хотя мы можем получить вид сверху на
[114:14] => среде путем применения обратного
[114:16] => перспективное отображение, однако, результатов
[114:19] => которые мы получаем от этой техники, не являются
[114:22] => действительно точный и полезный для нашей задачи
[114:26] => следовательно, нам нужны такие сложные архитектуры
[114:28] => как единица измерения xst
[114:30] => хорошо, итак, два компонента единицы
[114:32] => xst не обсуждаются, теперь давайте посмотрим, как
[114:36] => эти два компонента объединяются, чтобы дать
[114:38] => окончательная архитектура
[114:40] => для этой сети у нас будет
[114:42] => четыре входа для четырех различных
[114:44] => изображения, которые у нас есть, как мы можем видеть на
[114:46] => здесь
[114:48] => у нас будет аналогичный кодировщик
[114:50] => сеть для каждого из этих четырех изображений
[114:53] => как видно из красных линий
[114:58] => для декодера у нас снова есть аналогичный
[115:00] => архитектура, однако, существует единая
[115:03] => конвейер, который дает нам конечный результат
[115:06] => пропущенные соединения здесь — это то, что
[115:09] => использует специальные трансформаторы
[115:11] => четыре карты объектов в разных
[115:13] => уровни объединяются с помощью пространственного
[115:16] => трансформаторы
[115:17] => каждая функция сначала проходит через
[115:20] => специальный трансформатор, а затем эти
[115:23] => различные функции объединены
[115:25] => затем эта комбинация подается через
[115:27] => пропустить соединение
[115:29] => и это делается аналогично для каждого
[115:31] => уровень архитектуры
[115:33] => хорошо, значит, это все для
[115:35] => техническое обсуждение блока xst теперь давайте
[115:38] => давайте кратко взглянем на
[115:40] => реализация и результаты, которые мы
[115:42] => получите от обучения эту сеть
[115:44] => хорошо, итак, ссылка на это
[115:46] => блокнот для реализации будет
[115:47] => указано в поле с описанием ниже
[115:50] => в первом разделе мы реализовали
[115:52] => различные служебные функции, такие как
[115:55] => загрузить изображение
[115:56] => и одно горячее преобразование входных данных
[115:58] => изображение в простых терминах, что один горячий
[116:02] => средства кодирования
[116:03] => учитывая семантически сегментированный ввод, который
[116:06] => имеет различные различные цвета
[116:08] => мы преобразуем это изображение в rgb
[116:11] => в 3d-матрицу, содержащую разреженный
[116:15] => представление различных классов
[116:18] => это представление полезно для
[116:21] => модель машинного обучения для изучения и
[116:23] => понимать данные
[116:25] => в следующем разделе у нас есть
[116:27] => различные параметры конфигурации один
[116:29] => следует отметить, что существуют определенные
[116:32] => изменения, которые были применены к этим
[116:34] => параметры для того, чтобы подчиняться
[116:37] => ограничения, которые мы предоставляем на
[116:39] => kaggle форма изображения была уменьшена
[116:42] => для того, чтобы получить более быструю кривую обучения
[116:45] => размер партии также был увеличен
[116:47] => для того, чтобы получить те же результаты
[116:50] => кроме того, алгоритм обучен только для
[116:52] => всего 40 эпох, тогда как у нас было бы
[116:55] => требуется для обучения 400 эпох
[116:58] => в этом следующем разделе у нас есть
[117:00] => различные функции загрузки данных, которые
[117:02] => загрузите данные для нашего машинного обучения
[117:04] => модель
[117:05] => в этом следующем разделе мы определяем
[117:07] => другая сетевая архитектура
[117:09] => сначала мы определяем пространственный трансформатор
[117:11] => далее мы внедряем блок вместе с
[117:14] => пространственное расширение трансформатора
[117:17] => и, наконец, мы обучаем сеть
[117:19] => теперь давайте взглянем на финал
[117:21] => прогнозы результатов
[117:22] => как и раньше, у нас есть изображения с
[117:24] => четыре камеры на самоуправляемом автомобиле
[117:27] => спереди сзади слева и справа
[117:30] => это следующее изображение является прогнозом вывода
[117:33] => сгенерированный нашей моделью
[117:35] => и следующее изображение — это основная истина
[117:36] => изображение с высоты птичьего полета
[117:39] => как мы видим, модель научилась
[117:41] => в какой-то степени представлять с высоты птичьего полета
[117:43] => просмотр изображения
[117:47] => однако есть некоторый небольшой шум, который
[117:49] => присутствует в выводе
[117:51] => давайте взглянем на другие изображения, как
[117:53] => хорошо
[118:23] => в целом мы можем сказать, что модель научилась
[118:26] => изображение с высоты птичьего полета
[118:27] => изображение, но это потребует дополнительной подготовки
[118:30] => для достижения более высоких результатов
[118:33] => хорошо, значит, это все, что нам нужно было
[118:35] => обсудите для этого блока технику xst
[118:39] => поздравляем с окончанием курса
[118:42] => мы вместе сделали семь разных проектов
[118:44] => и должен узнать больше о
[118:46] => различные концепции, применяемые к восприятию
[118:48] => в самоуправляемых автомобилях
[118:50] => мы выполнили три проекта, связанных с 2d и
[118:53] => затем сделал 4 проекта, которые были связаны с
[118:56] => 3d
[118:57] => для того, чтобы продолжить этот курс, я
[118:59] => рекомендую вам перейти к другим
[119:02] => наборы данных, отличные от обсуждаемых
[119:05] => в этом курсе
[119:06] => читайте и внедряйте новые исследовательские работы
[119:08] => связано с восприятием для самостоятельного вождения
[119:10] => автомобили или вы можете перейти к и узнать больше
[119:13] => о различных модулях для
[119:15] => самоуправляемый автомобиль, такой как локализация или
[119:17] => планирование движения с точки зрения компьютера
[119:20] => видение беспокоит, вы также можете попробовать
[119:22] => различные другие проекты, такие как сходство
[119:25] => обучающие подписи к изображениям и генеративные
[119:28] => моделирование — это все, что нам нужно было
[119:30] => обсудите этот курс, и я бы увидел
[119:32] => вы в другом видео или другом курсе
[119:35] => до тех пор, пока