По гауссу что это

В процессе исправления ошибок гауссиану клонируют (если она мелкая) или разбивают на две (если гауссиана слишком большая).

Выбор между клонированием или разбитием на две точки. Новые гауссианы появляются как в местах, где других мало (under-reconstruction), так и в пространстве, которое покрывает одна крупная гауссиана (over-reconstruction)

Если в альфа-канале получилось слишком низкое значение, то гауссиану удаляют.

Суммарно итераций этого процесса нужны тысячи. В исследовании сравниваются изображения как на 7 тысяч (≈6 минут обучения), так и 30 тысяч итераций (30–50 минут). После 30 тысяч итераций сцена представляется в виде 200–500 тыс. гауссиан.

Хотя по сравнению с другими подходами места нужно меньше, объёмы данных на всех стадиях значительны. Во время тренировки память загружалась до 20 ГиБ на неоптимизированной модели. (У A6000 48 ГиБ памяти.) Для рендеринга желательно умещать всю сцену на сотни мегабайт в память видеоускорителя плюс иметь дополнительно 30–500 МиБ на растеризатор.

Технически код реализован на Python на фреймворке PyTorch. Код проектов выложен в репозитории github.com/graphdeco-inria/gaussian-splatting. Интерактивный просмотр сцен реализован на тулките SIBR.

Кроме кода и научного доклада в высоком качестве (111 МиБ) и низком (25 МиБ) исследователи выложили 650 МиБ сцен и 7 ГиБ примеров сгенерированных картинок.

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

Эталонная фотография реального объекта

В этом архиве на 7 ГиБ лежат также примеры тех же сцен, но сгенерированных другими методами.

Сравнение девяти сцен из научной статьи. Слева направо: оригинальные фотографии, гауссов сплэтинг, mip-NeRF 360, Instant NGP, Plenoxels. Цветом и стрелочками выделены неочевидные различия

Достичь уровня Instant NGP (DOI: 10.1145/3528223.3530127) и Plenoxels (DOI: 10.1109/CVPR52688.2022.00542) гауссов сплэтинг может всего за 5—10 минут обучения, то есть за небольшое число итераций — 7 тысяч. Оба метода при этом выдают в секунду число кадров меньше 10, в то время как у Gaussian splatting это значение выше сотни.

Слева направо: сравнение индекса структурного сходства (SSIM, structure similarity) и пикового отношения сигнала к шуму (peak signal-to-noise ratio, PSNR) для различных алгоритмов. График авторов гауссова сплэтинга, поэтому под «ours» понимается он

Доведение интераций обучения до 30 тысяч позволяет выйти на уровень лучших существующих на данный момент продуктов, того, что на сленге называется SOTA, state of the art. И здесь гауссов сплэтинг работает на уровне или даже превосходит текущего «короля» — mip-NeRF 360 (DOI: 10.1109/CVPR52688.2022.00539).

Пример того же грузовика, но в исполнении mip-NeRF 360

Стоит учитывать, что для mip-NeRF 360 пришлось развернуть отдельный кластер на 4 ускорителя Nvidia A100 для обучения. Процесс обучения занял полсуток (или 48 часов, если бы ускоритель был один). Ни о какой работе в реальном времени речи не идёт — для генерации одной картинки Mip-NeRF360 требуется несколько секунд.

Слева направо: частота кадров и время тренировки для различных алгоритмов. График авторов гауссова сплэтинга, поэтому под «ours» понимается он

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

Дальнейшее развитие

Гауссов сплэтинг несовместим с существующими пайплайнами рендеринга и требует большого объёма видеопамяти и места для хранения сцены. Даже если эти проблемы решатся, внезапного перехода видеоигр на гауссов сплэтинг ожидать не сто́ит.

У супостата в шутере должен быть хитбокс, у боевой арены — границы для обработки столкновений, а ещё нужны погода, освещение и интерактивность окружения. Гауссов сплэтинг в его изначальном виде даёт лишь статичную сценку, которую даже на 3D-принтере не распечатать — только нарисовать на мониторе.

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

На видео дорисованы трёхмерные траектории случайно выбранных 3 % гауссиан за 15 кадров (полсекунды). Dynamic 3D Gaussians: Tracking by Persistent Dynamic View Synthesis

С этим столкнулся, например, автор работы Dynamic 3D Gaussians: Tracking by Persistent Dynamic View Synthesis (arXiv:2308.09713). В период после публикации научной статьи, но до релиза кода пустой репозиторий github.com/JonathonLuiten/Dynamic3DGaussians набрал 450 звёзд и много просьб открыть исходники.

Сравнение эталона движения (красная линия) и предсказанного (синяя). Ошибка составляет в среднем 1,5 см. Dynamic 3D Gaussians: Tracking by Persistent Dynamic View Synthesis

Это ожидаемо. Как следует из названия [«динамические трёхмерные гауссианы: отслеживание методом устойчивого динамического синтеза»], в гауссов сплэтинг добавили запись движения. Регистрируются все шесть степеней свободы каждого элемента сцены.

В качестве входных данных взят датасет Panoptic, известный по научной статье Panoptic Studio: A Massively Multiview System for Social Interaction Capture (DOI: 10.1109/TPAMI.2017.2782743). Эта работа 2017 года касается захвата движений людей в социальных взаимодействиях. Из всего обширного датасета выбрали несколько зрелищных активностей: люди играют с мячом, замахиваются битой и участвуют в контактных видах спорта.

Данные с 31 камер разбили на две части: видео с 27 камер взяли для обучения, 4 — для тестирования. 150 кадров при частоте 30 кадров в секунду с каждой камеры в разрешении HD отмасштабировали до 640×360, попутно устранив искажения линз.

Нескольких участников (некоторые повторяются) вставили в сцену Garden, которая впервые появляется в виде датасета в работе mip-NeRF 360. Dynamic 3D Gaussians: Tracking by Persistent Dynamic View Synthesis

Авторы позволили гауссианам двигаться при условии, что они сохраняют изначальный цвет, размер и прозрачность. В этой работе используется новая реализация гауссова сплэтинга с оптимизациями для CUDA. В результате обучение для каждой из 150 временных точек (то есть по кадру с каждой с 27 камер) занимает всего 2 часа на одной RTX 3090, а частота кадров рендера огромна — 850 в секунду.

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

Если отредактировать любое из изображений в простом графическом редакторе (Photoshop или Paint), эти изменения гауссины могут распространить на всю длинную сцену.

Вообще, над представлением видео в точках-гауссианах работают сразу несколько команд по всему миру. Например, в Китае в Хуачжунском университете науки и технологии над этим трудятся исследователи Huawei. Результаты они показали в 4D Gaussian Splatting for Real-Time Dynamic Scene Rendering (arXiv:2310.08528).

Эта работа отличается неплохим качеством видео и упором на чуть ли не бюджетные видеокарты. Заявлено, что на RTX 3080 достигается частота 50 кадров в секунду, RTX 3090 — 70 при разрешении 800×800.

Для работы использовались как датасеты с одной камерой, так с двумя (Nerfies) и 15—20 (DyNeRF). Брались в том числе синтетические данные (датасет из DNeRF).

Чтобы достичь правильные позиции и деформации формы, гауссианы здесь предлагается соединять в воксели с помощью метода HexPlane (arXiv:2301.09632). Гауссианы собираются в группы, для последних проводится анализ: как они во времени меняют позицию, поворот и размер.

Общая схема пайплайна модели. 4D Gaussian Splatting for Real-Time Dynamic Scene Rendering

Уже две работы представили системы для генерации контента с помощью гауссова сплэтинга. DreamGaussian: Generative Gaussian Splatting for Efficient 3D Content Creation (arXiv:2309.16653) и Gsgen: Text-to-3D using Gaussian Splatting — это методы автоматического создания 3D-ассетов по текстовым описаниям.

Подобные системы пытаются исправить недостатки существующих систем генерации 3D-моделей с помощью гауссова сплэтинга. К примеру, с его помощью DreamGaussian генерирует модель, извлекает полигональную сетку и корректирует текстуру.

Генерация направления «текст в изображение в 3D-модель». DreamGaussian

Не сто́ит думать, что гауссов сплэтинг — это что-то далёкое, ресурсоёмкое и требующее глубоких технических знаний. В сети появляются простые гайды, которые разжёвывают всё по шагам. Но вообще-то для знакомства с техникой необязательно даже что-то качать: гауссов сплэтинг работает прямо в браузере.

Так, ресурс Polycam предлагает создать сцену в браузере — нужно всего лишь выгрузить на сайт от 20 до 200 изображений в формате JPEG или PNG. Желательно следовать практикам съёмки для фотограмметрии: снимать со всех возможных углов, но так, чтобы два снимка перекрывали друг друга хотя бы на 50 %, не стесняться подходить поближе и снимать крупный план.

На странице poly.cam/gaussian-splatting уже собраны десятки сцен от пользователей. Чаще всего загружают разнообразные интересные объекты: живописные виды, дорогие автомобили и женщин в нижнем белье. Просмотр работает прямо в браузере. Также примеры работы гауссова сплэтинга в браузере выложили на gsplat.net.

Для гауссова сплэтинга усиленно пишется софт. Просмотрщики реализованы на WebGPU, WebGL, в том числе с хорошими оптимизациями, плагины для импорта — для Blender и Unity. Для Unreal плагин тоже есть, но сто́ит он $99,99.

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

Фрагменты видеоролика 3D Gaussian Splatting from Hollywood Films! с видами отеля «Оверлук» и Хогвартса, сгенерированными гауссовым сплэтингом

Наконец, кто-то просто экспериментирует с гауссовым сплэтингом. Микроблогер @ajayns_ выложил анимацию под названием Gaussian unsplatting. В ней точки падают в порядке дальности от камеры, и сцена разваливается на части.

В другом варианте Burning Gaussian splatting сцена с помощью шейдеров рождается из пламени, а затем сгорает обратно.

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

• Gaussian splatting
• 3D Gaussian splatting
• гауссов сплэтинг
• NeRF
• обработка графики
• обработка изображений
• 3D-графика
• Общество Макса Планка
• Университет Лазурного берега
• INRIA
• SIGGRAPH
• научные работы
• CUDA
• рендеринг
• видеоускорители
• обучение
• машинное обучение
• стохастический градиентный спуск
• генеративные модели

• Работа с 3D-графикой
• Обработка изображений
• Математика
• Компьютерная анимация
• CGI (графика)

Быстрое размытие по Гауссу

Фильтр размытия по гауссу (широко известный “gaussian blur” в фотошопе) достаточно часто применяется сам по себе или как часть других алгоритмов обработки изображений. Далее будет описан метод, позволяющий получать размытие со скоростью, не зависящей от радиуса размытия, используя фильтры с бесконечной импульсной характеристикой.

Описание метода есть на английском. Но на русском информации нет. Кроме того, мною были внесены некоторые изменения.

Итак, пусть исходное изображение будет задано яркостью x(m,n). Гаусово размытие с радиусом r считается по формуле

Пределы суммирования по u и v можно выбирать как плюс минус несколько сигм, т.е. радиусов r, что даёт сложность алгоритма порядка O(r 2 ) операций на пиксель. Для больших r и многомегапиксельных изображений не слишком здорово, правда?

Первое ускорение даёт свойство сепарабельности гауссова размытия. То есть, можно провести фильтрацию по оси x для каждой строки, полученное изображение отфильтровать по y по каждому столбцу и получить тот же результат со сложностью O(r) операций на пиксель. Уже лучше. Это свойство мы тоже будем использовать, поэтому дальше все рассуждения будут для одномерного случая, где нужно получить y(n) имея x(n).

В этом нам помогут фильтры с бесконечной импульсной характеристикой. Идея фильтра такова: значения y(n) рекуррентно рассчитываются по формуле:

Где a_k и b_i – некоторые предрасчитанные коэффициенты, а y(n) и x(n) при n

Часть формулы, зависящая от b_i сводится к простой свёртке с конечным ядром. Поскольку мы хотим, чтобы фильтр считал побыстрее, то наш фильтр будем искать для случая P=0, то есть рассматривая один единственный коэффициент b₀.

На всякий случай, напомню, что любой линейный фильтр (а БИХ фильтр также является линейным) полностью характеризуется своим откликом на дельта функцию, равную 1 в точке 0, и 0 во всех остальных точках. Часть, зависящая от коэффициентов a при отклике на такую функцию либо разойдётся и уйдёт в бесконечность (этого хотелось бы избежать), либо даст нам красивый убывающий хвост. Например, вот такой:

Похоже на гаусс? Ну да, что-то уже есть, но как-то оно кособоко выглядит. Поэтому идея алгоритма будет такой: мы отфильтруем в одну сторону (циклом от 0 до n_max), а потом результат в обратную (от n_max до 0), с теми же коэффициентами. Математически должна получиться строго симметричная кривая (поэтому не важно, фильтровать сначала туда потом обратно, или наоборот). Несколько забегая вперёд, вот что получится если профильтровать это ещё в обратном порядке:

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

Итак, осталось рассчитать коэффициенты фильтра a. Далее все формулы пойдут для случая Q=3.

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

Или для нашего случая Q=3, P=1:

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

в нашем случае 1/Z₀, 1/Z₁, 1/Z₂. Заметим, что полюса однозначно определяют коэффициенты a_k нашего фильтра (все БИХ фильтры, обычно, ищутся именно через полюса, а не напрямую). Кстати, получить коэффициенты по полюсам проще, чем наоборот (для этого нужно перемножить полиномы, а наоборот – решить степенное уравнение).

Самый главный теоретический постулат, который нам пригодиться: если комплексные полюса лежат внутри единичного круга, т.е. по модулю меньше единицы, (или, что тоже самое, обратные значения Z₀, Z₁, Z₂ лежат вне единичного круга), то фильтр будет устойчивым, то результат не убежит в бесконечность.

Отметим также, что назвав произвольные комплексно сопряженные Z₀, Z₁ и вещественное Z₂ (опять же, все по модулю больше единицы) мы можем построить по ним фильтр. В произведении всё превратится в строго вещественные коэффициенты a.

Коэффициент b₀ работает как “коэффициент громкости” фильтра.

Итак, задача свелась к определению трёх коэффициентов Z₀, Z₁, Z₂. Поскольку, повторюсь, два из них комплексно сопряженные, а третий вещественные, то нужно найти вещественную и мнимую часть от первого, и вещественную от третьего. То есть, три вещественных числа: real(Z₀), im(Z₀), Z₂

Эти три числа должны выражаться через нужный нам радиус фильтра. Отметим, что в реальности имеет смысл считать для r больше либо равного двум, при меньших значениях быстрее профильтровать умножением.

Дальше я пошёл немного другим путём, чем в работе «Recursive Gaussian Derivative Filters». Там они распространяли случай с r=2 на все другие, а я определил лучшие коэффициенты для всех радиусов от 2 до 2048, с экспоненциальным шагом. Я написал оптимизационный алгоритм, который ищет наиболее близкую кривую по методу минимизации модуля максимальной разницы. Дополнительным условием было сохранение фильтром полной энергии, т.е. чтобы функция x(n)=const переходила саму в себя, что даёт условие

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

Желающие могут посмотреть результаты на google spreadsheet.

Видно, что для случая r=2 результаты отличаются от данных в работе. Почему так, я сказать не могу, при этом по моим расчетам мои коэффициенты дают меньшую, процентов на 40, погрешность.

Дальше я воспользовался не буквой а духом статьи, и стал искать данные как

real(Z₀) = cos(W(r)/r)*e A(r)/r
im(Z₀) = sin(W(r)/r)*e A(r)/r
Z₂ = e B(r)/r

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

(k₃ r 3 + k₂ r 2 + k₁ r + k₀)/r 3

и подобрал коэффициенты самым простым образом — просто использовав Wolfram Mathematica. Кстати, если внимательно изучать графики данных из таблиц, видно что функция имеет несколько пилообразную структуру. Поэтому при аппроксимации мы немного потеряем в точности, но по факту совсем чуть чуть — значения из таблицы дадут ошибку на 10 процентов меньшую, чем полученные полиномами.

Ну вот. Для тех, кто уже запутался что и от чего нужно считать, приведу финальный код функции на С для расчёта коэффициентов:

int gaussCoef(double sigma, double a[3], double *b0) < double sigma_inv_4; sigma_inv_4 = sigma*sigma; sigma_inv_4 = 1.0/(sigma_inv_4*sigma_inv_4); double coef_A = sigma_inv_4*(sigma*(sigma*(sigma*1.1442707+0.0130625)-0.7500910)+0.2546730); double coef_W = sigma_inv_4*(sigma*(sigma*(sigma*1.3642870+0.0088755)-0.3255340)+0.3016210); double coef_B = sigma_inv_4*(sigma*(sigma*(sigma*1.2397166-0.0001644)-0.6363580)-0.0536068); double z0_abs = exp(coef_A); double z0_real = z0_abs*cos(coef_W); double z0_im = z0_abs*sin(coef_W); double z2 = exp(coef_B); double z0_abs_2 = z0_abs*z0_abs; a[2] = 1.0/(z2*z0_abs_2); a[0] = (z0_abs_2+2*z0_real*z2)*a[2]; a[1] = -(2*z0_real+z2)*a[2]; *b0 = 1.0 - a[0] - a[1] - a[2]; return 0; >;

Всё! Теперь, нужно написать сам код. Расчёт, конечно, нужно производить во float, но современные компьютеры считают на числа с плавающей запятой (особенно с sse) довольно быстро. Программисты из Интел, кстати, озаботились оптимизацией Gauss-IIR фильтров под векторные инструкции процессора уже написали целую статью. Правда, там считают немножко другим методом, но основные способы оптимизации описаны хорошо.

В конце можно дать пример того, что получилось:

Картинка практически не отличается от «честной». Впрочем, если открыть её в фотошопе и поизучать внимательно, разницу найти можно.

_{P.S. Это правда мой первый пост на Хабре, я мог что-то пропустить. Если будут вопросы, я отвечу в комментариях.}