За пределами CycleGAN: мультимодальный, контрастный и семантический синтез изображений

Заметка о StarGAN закончилась одним генератором, который даёт много стилей во многих доменах: StarGAN v2 сохраняет цикл обратно ко входу и берёт целевой облик из выученного пространства стилей. От CycleGAN ведут и другие пути. MUNIT (Huang et al., 2018) разделяет изображение на код содержания (content code), общий для двух доменов, и код стиля (style code), свой для каждого из них, и переводит, подменяя стиль. CUT (Park et al., 2020) совсем отказывается от цикла и второго генератора и с помощью контрастной функции потерь (contrastive loss) привязывает каждый фрагмент выхода к тому фрагменту входа, из которого он получился. pix2pixHD и SPADE (Wang et al., 2018a; Park et al., 2019) начинают не с фотографии, а с маски сегментации, и SPADE добивается того, чтобы маска доходила до каждого слоя. Наконец, сверхразрешение (super-resolution) с помощью GAN (Ledig et al., 2017; Wang et al., 2018b) — задача с парами, в которой проблема попиксельной функции потерь видна лучше всего: изображение, минимизирующее квадратичную ошибку, — это размытое среднее всех правдоподобных ответов.

Обозначения. Как и в заметке о CycleGAN, $x$ — входное изображение, $G$ — генератор, $D$ — дискриминатор, $\|a - b\|_1$ — сумма модулей разностей (реализации её усредняют). Для MUNIT домены — $X_1$ и $X_2$ с изображениями $x_1, x_2$; у каждого домена $i$ есть энкодер содержания (content encoder) $E^c_i$, энкодер стиля (style encoder) $E^s_i$ и декодер $G_i$; $c$ — код содержания, $s$ — код стиля с априорным распределением $q(s) = \mathcal N(0, I)$. Для CUT $\hat y = G(x)$ — выход, а $G_{\mathrm{enc}}$ — первая половина генератора. Для семантического синтеза $m$ — маска сегментации, которая сопоставляет каждому пикселю метку класса. Для сверхразрешения $x^{\mathrm{LR}}$ — вход низкого разрешения, $x^{\mathrm{HR}}$ — настоящее изображение высокого разрешения, $\varphi$ — карта признаков предобученной сети VGG.

MUNIT: одно пространство содержания, по пространству стилей на домен#

Два автоэнкодера с общим кодом содержания#

MUNIT предполагает, что изображение порождается двумя кодами: кодом содержания $c$, общим для обоих доменов, и кодом стиля $s_i$, своим для домена $i$ (Huang et al., 2018, раздел 3.1). Содержание — это «лежащая в основе пространственная структура», а стиль — «отрисовка этой структуры»: поза и расположение кошки, с одной стороны, и её шерсть и окрас — с другой. Пара соответствующих изображений имела бы вид $x_1 = G^*_1(c, s_1)$ и $x_2 = G^*_2(c, s_2)$ с одним и тем же $c$. Поскольку $s_2$ случаен, у одного $x_1$ целое распределение переводов, а не один перевод.

У каждого домена есть автоэнкодер, код которого разделён на две части, $(c_i, s_i) = (E^c_i(x_i), E^s_i(x_i))$. Перевод меняет декодеры местами (раздел 3.2):

$$x_{1 \to 2} = G_2\big(E^c_1(x_1),\, s_2\big), \qquad s_2 \sim \mathcal N(0, I).$$

Новый $s_2$ даёт новый выход. Если же взять $s_2 = E^s_2(x_2)$ с настоящего изображения целевого домена, получится перевод по образцу (example-guided translation), в котором выход копирует стиль образца (раздел 5.5).

У двух кодов разная форма, и именно форма во многом их и разделяет (Huang et al., 2018, приложение B.2):

• Содержание — карта признаков. Энкодер содержания дважды понижает разрешение и добавляет четыре остаточных блока, так что изображение $256 \times 256$ превращается в тензор $64 \times 64 \times 256$. Во всех его слоях используется нормализация по экземпляру (instance normalization), которая убирает поканальные среднее и разброс каждой карты признаков — статистики, несущие значительную часть стиля изображения.
• Стиль — вектор из 8 чисел. Энкодер стиля заканчивается глобальным усредняющим пулингом (global average pooling) и линейным слоем, поэтому не сохраняет пространственного расположения, и не использует нормализацию по экземпляру, которая убрала бы ровно то, что он должен сохранить.
• Декодер встраивает стиль через AdaIN: MLP превращает $s$ в масштаб и сдвиг каждого слоя AdaIN в четырёх остаточных блоках, а два блока повышения разрешения выдают изображение.

Функции потерь в пространстве изображений и в латентном пространстве#

MUNIT обучает энкодеры и декодеры быть обратными друг к другу в обоих направлениях (Huang et al., 2018, формулы 1–5):

$$\begin{aligned} \mathcal L^{x_1}_{\mathrm{recon}} &= \mathbb E_{x_1}\, \big\|G_1\big(E^c_1(x_1), E^s_1(x_1)\big) - x_1\big\|_1, \\ \mathcal L^{c_1}_{\mathrm{recon}} &= \mathbb E_{c_1, s_2}\, \big\|E^c_2\big(G_2(c_1, s_2)\big) - c_1\big\|_1, \\ \mathcal L^{s_2}_{\mathrm{recon}} &= \mathbb E_{c_1, s_2}\, \big\|E^s_2\big(G_2(c_1, s_2)\big) - s_2\big\|_1, \end{aligned}$$

где $c_1 = E^c_1(x_1)$ для настоящего $x_1$ и $s_2 \sim \mathcal N(0, I)$. К ним добавляются те же три слагаемых с переставленными доменами и состязательная функция потерь $\mathcal L^{x_2}_{\mathrm{GAN}}$, в которой $D_2$ отличает настоящие изображения $X_2$ от переводов $G_2(c_1, s_2)$. Полная целевая функция:

$$\begin{aligned} \min_{E_1, E_2, G_1, G_2}\; \max_{D_1, D_2}\;\; & \mathcal L^{x_1}_{\mathrm{GAN}} + \mathcal L^{x_2}_{\mathrm{GAN}} + \lambda_x \big(\mathcal L^{x_1}_{\mathrm{recon}} + \mathcal L^{x_2}_{\mathrm{recon}}\big) \\ & + \lambda_c \big(\mathcal L^{c_1}_{\mathrm{recon}} + \mathcal L^{c_2}_{\mathrm{recon}}\big) + \lambda_s \big(\mathcal L^{s_1}_{\mathrm{recon}} + \mathcal L^{s_2}_{\mathrm{recon}}\big), \end{aligned}$$

с $\lambda_x = 10$ и $\lambda_c = \lambda_s = 1$ (приложение B.1). У каждого слагаемого своя задача:

• Реконструкция изображения делает каждую пару $(E_i, G_i)$ автоэнкодером своего домена. Она использует изображения только одного домена, поэтому пары ей не нужны.
• Реконструкция содержания требует, чтобы перевод сохранял содержание: энкодер содержания целевого домена должен прочитать $c_1$ обратно по $x_{1 \to 2}$. Именно это привязывает выход к входу.
• Реконструкция стиля требует, чтобы перевод использовал стиль: $s_2$ должен читаться по выходу. Без неё декодер мог бы игнорировать $s_2$, а шум, который подают генератору, обычно игнорируется (раздел 1).
• Состязательная функция потерь делает переводы похожими на настоящие изображения целевого домена. MUNIT использует вариант наименьших квадратов и три дискриминатора на разных масштабах изображения — те же, что у pix2pixHD ниже (раздел 5.1).

В оптимуме распределение закодированных стилей совпадает с гауссовским априорным, а распределения содержания двух доменов совпадают друг с другом (предложение 2): пространство содержания становится инвариантным к домену без функции потерь, которая требовала бы этого явно. Для наборов данных высокого разрешения ($512 \times 512$ и выше) MUNIT добавляет доменно-инвариантную перцептивную функцию потерь (domain-invariant perceptual loss) — расстояние между признаками VGG входа и его перевода, взятыми после нормализации признаков по экземпляру. Эта нормализация убирает специфичные для домена статистики признаков, так что вход может служить эталоном (раздел 5.1, приложение C).

Почему у MUNIT нет цикловой функции потерь#

Цикловая функция потерь вынуждает перевод быть детерминированным (Huang et al., 2018, предложение 5). Пусть перевод случаен в обоих направлениях и цикл выполняется точно: любой выход $x_1$, переведённый обратно, возвращает $x_1$, а любой выход $x_2$, переведённый обратно, возвращает $x_2$. Предположим также, что переводы из $X_1$ попадают в $X_2$ и наоборот (совпадающие маргинальные распределения, matched marginals). Пусть $a \neq b$ — два возможных перевода одного входа $x^*_1$. Обратный перевод $a$ даёт $x^*_1$ по прямому циклу. Повторный прямой перевод $x^*_1$ должен наверняка вернуть $a$ по обратному циклу из $a$. Но $x^*_1$ может дать и $b$. Значит, $a = b$: у перевода единственный выход. Это формальная версия ограничения, описанного в конце заметки о CycleGAN.

MUNIT сохраняет более слабый цикл, который переносит стиль с собой (предложение 4). Переведём $x_1$ со случайным $s_2$, а затем обратно со стилем оригинала, $E^s_1(x_1)$: получится $x_1$. Этот цикл, дополненный стилем (style-augmented cycle), выполняется в оптимуме трёх функций потерь реконструкции, а для некоторых наборов данных можно добавить его явный вариант (формула 6). Цикл StarGAN v2, который возвращается с собственным стилем входа $E_y(x)$, — та же идея.

Результаты и абляционное исследование#

На задаче границы → обувь разнообразие — это среднее расстояние LPIPS между парами выходов для одного и того же входа (100 входов, по 19 пар на каждый), а качество — доля оценщиков, которые предпочли выход метода выходу MUNIT (Huang et al., 2018, таблица 1):

Метод	Качество	Разнообразие
CycleGAN	36.0%	0.010
MUNIT без $\mathcal L^{x}_{\mathrm{recon}}$	6.0%	0.213
MUNIT без $\mathcal L^{c}_{\mathrm{recon}}$	20.7%	0.172
MUNIT без $\mathcal L^{s}_{\mathrm{recon}}$	28.6%	0.070
MUNIT	50.0%	0.109
BicycleGAN, обученный на парах	56.7%	0.104
настоящая обувь	–	0.293

CycleGAN с дропаутом (dropout) на этапе тестирования почти не меняет свои выходы. Без реконструкции стиля многие выходы почти одинаковы — это частичный коллапс. Две самые разнообразные строки — худшие: без реконструкции изображения выходы разнообразнее всего, а предпочитают их лишь в 6.0% сравнений, потому что артефакты делают выходы непохожими друг на друга, а метрика разнообразия их учитывает. Полная модель близка к BicycleGAN, которому нужны парные данные и который предпочитают MUNIT в 56.7% сравнений.

MUNIT и StarGAN v2#

StarGAN v2 (Choi et al., 2020) появился двумя годами позже и сравнивает себя с MUNIT по протоколу, описанному в разделе «Как измеряют модели перевода». У двух моделей общий механизм стиля, а различаются они тем, что строят вокруг него:

	MUNIT	StarGAN v2
Доменов на модель	два, по автоэнкодеру на каждый	много, один генератор
Содержание	явный код $64 \times 64 \times 256$, восстанавливаемый $\mathcal L^{c}_{\mathrm{recon}}$	отдельного кода нет: $G$ кодирует $x$ внутри себя
Стиль	8 чисел, взятых прямо из $\mathcal N(0, I)$	64 числа из отображающей сети $F_y(z)$ — выученного преобразования гауссовского распределения, своего для каждого домена
Встраивание стиля	AdaIN, параметры из MLP	AdaIN, аффинное отображение в каждом слое
Привязка к входу	реконструкция содержания; реконструкция изображения внутри домена	цикл с собственным стилем входа
Разнообразие	только реконструкция стиля	реконструкция стиля и слагаемое разнообразия
Дискриминаторы	по одному на домен, три масштаба, наименьшие квадраты	по голове на домен, ненасыщающаяся функция потерь с R1

Сравнение в заметке о StarGAN показывает, что дают дополнения StarGAN v2: конфигурация D абляционного исследования — шум на входе генератора и реконструкция латентного кода — уже даёт разнообразные выходы, а отображающая сеть и слагаемое разнообразия снижают FID ещё больше.

CUT: контрастная функция потерь вместо цикла#

Зачем отказываться от цикла?#

Цикловая функция потерь предполагает, что два домена находятся во взаимно однозначном соответствии, а многие пары доменов ему не подчиняются: фотография содержит больше информации, чем её карта меток, а лошадь может стать многими зебрами (Park et al., 2020, раздел 2). Кроме того, цикл стоит второго генератора и второго дискриминатора, которые служат лишь для проверки первого. CUT оставляет один генератор, $\hat y = G(x)$, и один дискриминатор и заменяет цикл другим способом выразить зависимость выхода от входа: фрагмент выхода должен указывать, из какого фрагмента входа он получился. Лоб зебры должен прослеживаться до лба лошади, а не до её ног или травы.

На языке теории информации цель — сделать большой взаимную информацию (mutual information) между соответствующими фрагментами входа и выхода. Поскольку $I(X; \hat Y) = H(X) - H(X \mid \hat Y)$, а $H(X)$ не зависит от $G$, это то же самое, что сделать вход легко восстановимым по выходу. Авторы CUT, ссылаясь на более ранние работы, отмечают, что цикловая функция потерь ограничивает условную энтропию $H(X \mid \hat Y)$ сверху, так что CycleGAN преследует ту же цель через вторую сеть (раздел 3). CUT преследует её напрямую, с помощью контрастной оценки.

InfoNCE: выбрать позитивный пример среди негативных#

InfoNCE (van den Oord, Li and Vinyals, 2018, раздел 2.3) превращает вопрос «связан ли $v^+$ с $v$?» в классификацию. Запрос (query) $v$, его позитивный пример (positive) $v^+$ и $N$ негативных примеров (negatives) $v^-_1, \dots, v^-_N$ отображаются в единичные векторы в $\mathbb R^K$, и softmax по их скалярным произведениям должен выбрать позитивный пример (Park et al., 2020, формула 2):

$$\ell(v, v^+, v^-) = -\log \frac{\exp(v \cdot v^+ / \tau)}{\exp(v \cdot v^+ / \tau) + \sum_{n=1}^{N} \exp(v \cdot v^-_n / \tau)},$$

— это кросс-энтропия для классификации с $(N + 1)$ вариантами и температурой $\tau = 0.07$. Нормировка на единичную сферу не даёт эмбеддингу схлопнуться в точку или неограниченно расти. Эта функция потерь — многоклассовый родственник шумоконтрастного оценивания (noise-contrastive estimation, NCE): NCE обучает логистическую регрессию отличать данные от шума, InfoNCE — softmax выбирать единственного настоящего партнёра среди $N + 1$ кандидатов. В обоих случаях в оптимуме оценка (score) равна логарифму отношения плотностей; для InfoNCE $\exp(\text{score}) \propto p(v^+ \mid v)/p(v^+)$ (van den Oord et al., раздел 2.3). Та же функция потерь, в которой негативными примерами служат другие отрывки батча, обучает поисковые энкодеры семантического поиска.

Минимизация $\ell$ максимизирует нижнюю оценку взаимной информации, $I \ge \log(N + 1) - \mathbb E\,\ell$, которая становится точнее с ростом $N$ (van den Oord et al., раздел 2.3, где общее число сэмплов равно $N + 1$). Значение функции потерь $\log(N + 1)$ означает, что позитивный пример найти не легче, чем случайного кандидата.

Разобранный пример (игрушечные числа). Косинус запроса с позитивным примером равен $0.5$, а с тремя негативными — $0.45$, $0.2$ и $-0.1$. При $\tau = 1$ softmax даёт позитивному примеру вероятность всего $0.309$, функция потерь равна $1.176$, что близко к уровню случайного угадывания $\log 4 = 1.386$. При $\tau = 0.07$ логиты делятся на $0.07$, разрыв $0.05$ между позитивным примером и ближайшим негативным превращается в $0.71$, и позитивный пример получает $0.665$, а функция потерь равна $0.408$. Малая температура делает функцию потерь чувствительной к малым различиям сходства, и в градиенте доминирует самый трудный негативный пример — тот, что больше всех похож на запрос.

PatchNCE: соответствующие фрагменты, негативные примеры из того же изображения#

CUT применяет InfoNCE к фрагментам нескольких масштабов (Park et al., 2020, раздел 3). Энкодерная половина генератора, $G_{\mathrm{enc}}$, и так вычисляет стопку карт признаков, и каждая позиция карты признаков слоя $l$ описывает фрагмент входа; более глубокие слои описывают более крупные фрагменты. CUT берёт $L = 5$ слоёв — от RGB-пикселей через две свёртки понижения разрешения до первого и пятого остаточного блока, так что фрагменты варьируются от отдельных пикселей до областей шириной около сотни пикселей (приложение C.1). Небольшой двухслойный MLP $H_l$ с 256 нейронами, свой для каждого слоя, отображает каждый вектор признаков в единичный вектор, как в SimCLR.

Один и тот же энкодер встраивает вход и выход: $z_l = H_l(G^l_{\mathrm{enc}}(x))$ и $\hat z_l = H_l(G^l_{\mathrm{enc}}(\hat y))$. В 256 случайных позициях $s$ каждого слоя признак выхода $\hat z^s_l$ служит запросом, признак входа в той же позиции $z^s_l$ — позитивным примером, а признаки входа в остальных 255 позициях $z^{S \setminus s}_l$ — негативными (формула 3):

$$\mathcal L_{\mathrm{PatchNCE}}(G, H, X) = \mathbb E_{x}\, \sum_{l=1}^{L}\, \sum_{s=1}^{S_l}\, \ell\big(\hat z^s_l,\; z^s_l,\; z^{S \setminus s}_l\big).$$

Негативные примеры берутся из того же входного изображения. Нога зебры на выходе должна быть ближе к ноге лошади в той же позиции, чем к спине лошади, небу или траве той же фотографии. Авторы пробовали и негативные примеры из других изображений, хранимые в большом банке памяти (memory bank) в стиле MoCo, и нашли их хуже — как отдельно, так и в дополнение к внутренним (раздел 4.2). Их объяснение: с внутренними негативными примерами энкодеру не нужно моделировать различия между изображениями, не относящиеся к переводу, например между белыми и гнедыми лошадьми. Использование только последнего слоя энкодера тоже не сработало. В отличие от обучения представлений, где фиксированное изображение встраивается в один вектор, синтезу нужен плотный сигнал на каждом масштабе.

Что мешает генератору схитрить? Если бы выход не сохранял никакого следа входа, $\hat z^s_l$ был бы так же близок к негативному примеру, как к позитивному, и функция потерь держалась бы около $\log 256 = 5.545$ на запрос. Функция потерь мала, только если каждый фрагмент выхода узнаваемо является преобразованным фрагментом входа. Энкодер сам учится тому, что значит «соответствующий» при переходе между доменами: он должен сопоставлять формы и части и игнорировать текстуры — именно то, что меняет перевод. Фиксированное расстояние, например $L_1$ или функция потерь VGG между $x$ и $\hat y$, штрафовало бы сами полосы.

Целевая функция и FastCUT#

Генератор и MLP минимизируют (Park et al., 2020, формула 5)

$$\mathcal L_{\mathrm{GAN}}(G, D, X, Y) + \lambda_X\, \mathcal L_{\mathrm{PatchNCE}}(G, H, X) + \lambda_Y\, \mathcal L_{\mathrm{PatchNCE}}(G, H, Y),$$

а дискриминатор ведёт состязательную игру. Последнее слагаемое пропускает через $G$ настоящие изображения $y$ целевого домена и требует, чтобы $G(y)$ пофрагментно соответствовало $y$: это выученная контрастная версия функции потерь тождественного отображения из CycleGAN. Названы две настройки:

• CUT: $\lambda_X = \lambda_Y = 1$, обучение в течение 400 эпох.
• FastCUT: $\lambda_X = 10$, $\lambda_Y = 0$, обучение в течение 200 эпох, с аугментацией на эквивариантность к отражению (flip-equivariance augmentation): вход отражается по горизонтали, а признаки выхода перед вычислением функции потерь отражаются обратно.

Всё остальное — как в CycleGAN: генератор ResNet с девятью остаточными блоками, дискриминатор PatchGAN, функция потерь GAN наименьших квадратов и размер батча 1 (приложение C.1). Тождественное слагаемое в основном стабилизирует обучение. Без него перевод лошадь → зебра достиг лучшего FID, но обучение на Cityscapes могло схлопнуться (раздел 4.2, рисунок 6).

Результаты в сравнении с CycleGAN#

В сравнении с CycleGAN, MUNIT и односторонними базовыми моделями при разрешении $256 \times 256$ (Park et al., 2020, таблица 1):

Метод	FID лошадь → зебра	FID кошка → собака	FID Cityscapes	mAP Cityscapes	с/итер.	Память, ГБ
CycleGAN	77.2	85.9	76.3	20.4	0.40	4.81
MUNIT	133.8	104.4	91.4	16.9	0.39	3.84
CUT	45.5	76.2	56.4	24.7	0.24	3.33
FastCUT	73.4	94.0	68.8	19.1	0.15	2.25

mAP на Cityscapes измеряется сетью сегментации, запущенной на фотографиях, сгенерированных по картам меток, поэтому он проверяет, что выход сохраняет расположение объектов входа. CUT тратит на итерацию на 40% меньше времени, чем CycleGAN, и требует на 31% меньше памяти, FastCUT — на 63% меньше времени и на 53% меньше памяти. CycleGAN, как и FastCUT, обучается 200 эпох, а CUT — 400, так что полное обучение CUT не короче, чем у CycleGAN. Без цикла CUT может и сильнее менять изображение: в задаче лошадь → зебра зебры занимают 36.8% пикселей целевых обучающих фотографий, а лошади — 17.9% пикселей исходных. CUT увеличивает животных до 30.8% пикселей, CycleGAN оставляет их на уровне 19.1%, а FastCUT с его большим контрастным весом остаётся близко к CycleGAN, на 25.9% (приложение C.4). Такое сближение с целевыми статистиками помогает в задаче кошка → собака, где нужны изменения формы, и вредит, когда модель рисует полосы на фоне.

Поскольку негативные примеры берутся из одного изображения, CUT можно обучить даже на одном изображении на домен, например на картине Моне и одной фотографии, используя случайные вырезки $128 \times 128$ (раздел 4.3).

Семантический синтез изображений по карте меток#

Семантический синтез изображений (semantic image synthesis) превращает маску сегментации $m$ — метку класса для каждого пикселя (небо, дорога, машина, дерево) — в фотографию. Обучающие данные — пары из фотографии и её маски, как у pix2pix, так что это задача обучения с учителем. Нового здесь две вещи. Маски уличных сцен имеют размер $2048 \times 1024$, намного больше, чем $256 \times 256$ у pix2pix, а маска состоит в основном из больших однородных областей, которые, как мы увидим, стираются слоями нормализации стандартного генератора.

pix2pixHD: многомасштабные дискриминаторы и сопоставление признаков#

pix2pixHD (Wang et al., 2018a, раздел 3.2) масштабирует pix2pix тремя способами:

• Генератор «от грубого к точному» (coarse-to-fine). Глобальный генератор $G_1$ — остаточная сеть в духе генератора CycleGAN с четырьмя шагами понижения разрешения и девятью остаточными блоками — работает при разрешении $1024 \times 512$. Локальный улучшитель (local enhancer) $G_2$ работает при $2048 \times 1024$ и перед своими остаточными блоками прибавляет к своей карте признаков последнюю карту признаков $G_1$. Сначала обучается $G_1$, затем $G_2$, затем оба вместе.
• Многомасштабные дискриминаторы (multi-scale discriminators). Чтобы судить изображение $2048 \times 1024$, дискриминатору нужно большое рецептивное поле: более глубокая сеть или более крупные ядра, что дорого и склонно к переобучению. pix2pixHD использует три дискриминатора $D_1, D_2, D_3$ с одинаковой архитектурой (PatchGAN $70 \times 70$) на изображении, уменьшенном в 1, 2 и 4 раза. То же окно $70 \times 70$ покрывает в четыре раза более широкую область самого грубого изображения, поэтому $D_3$ судит о глобальной структуре, а $D_1$ — о мелких деталях, и генератор играет против всех трёх: $\min_G \max_{D_1, D_2, D_3} \sum_{k} \mathcal L_{\mathrm{GAN}}(G, D_k)$. Без них авторы наблюдали в изображениях повторяющиеся узоры.
• Функция потерь сопоставления признаков (feature-matching loss). Генератор должен также совпадать с настоящей фотографией по внутренним признакам дискриминаторов (формула 4):

$$\mathcal L_{\mathrm{FM}}(G, D_k) = \mathbb E_{(m, x)} \sum_{i=1}^{T} \frac{1}{N_i}\, \big\|D^{(i)}_k(m, x) - D^{(i)}_k\big(m, G(m)\big)\big\|_1 ,$$

где $D^{(i)}_k$ — выход слоя $i$ дискриминатора $k$, содержащий $N_i$ элементов, а дискриминатор получает маску, конкатенированную с изображением. Полная целевая функция — $\min_G \big(\max_{D_1, D_2, D_3} \sum_k \mathcal L_{\mathrm{GAN}}(G, D_k) + \lambda \sum_k \mathcal L_{\mathrm{FM}}(G, D_k)\big)$ с $\lambda = 10$ и функциями потерь GAN наименьших квадратов; дискриминаторы лишь извлекают признаки для $\mathcal L_{\mathrm{FM}}$ и не максимизируют её (раздел 3.2; вес — в разделе 4). Эта функция потерь — перцептивная функция потерь (perceptual loss), признаки которой выучены дискриминаторами на этих же данных, на нескольких глубинах и трёх масштабах. Ей нужны пары: она сравнивает синтезированное изображение с фотографией, которой соответствует маска. Перцептивная функция потерь VGG с тем же весом необязательна и немного помогает.

На Cityscapes сеть сегментации восстанавливает входную маску по фотографиям pix2pixHD с попиксельной долей правильных ответов (pixel accuracy) 83.78% и средним IoU (mean IoU) 0.6389 против 78.34% и 0.3948 у pix2pix и 84.29% и 0.6857 на настоящих фотографиях (таблица 1). В исследовании авторов с участием людей добавление функции потерь сопоставления признаков к функции потерь GAN дало большее улучшение, а функция потерь VGG — меньшее, и 69.2% оценщиков предпочли результаты с многомасштабными дискриминаторами результатам с одним дискриминатором (раздел 4).

Как нормализация смывает карту меток#

pix2pixHD подаёт маску, закодированную one-hot по классам, на первый слой генератора, а генератор после каждой свёртки применяет нормализацию по экземпляру. Нормализация вычитает среднее каждого канала по позициям и делит на его разброс. Маска кусочно-постоянна, поэтому после одной свёртки большая часть её информации заключена именно в этих статистиках (Park et al., 2019, раздел 3).

Однородная маска стирается. Пусть у всех пикселей одна и та же метка. Вдали от границ свёртка постоянного входа постоянна: канал $c$ содержит одно значение $a_c$ во всех позициях, а при дополнении отражением — и на границах. Нормализация по экземпляру делит на $\sqrt{\sigma^2 + \varepsilon}$ с малым $\varepsilon > 0$, здесь $\sigma = 0$, и превращает канал в $(a_c - a_c)/\sqrt{0 + \varepsilon} = 0$, какой бы ни была метка. Маска «вся трава» и маска «всё небо» дают одинаковые активации, и генератор не может узнать, что рисовать (рисунок 3 статьи показывает два одинаковых выхода pix2pixHD). Это тот же эффект, из-за которого генератор StarGAN дополняет нулями.

Разобранный пример (игрушечные числа). Маска — небо на доле $p$ пикселей и трава на остальных. После свёртки $1 \times 1$ канал содержит $a_{\mathrm{sky}}$ на небе и $a_{\mathrm{grass}}$ на траве. Его среднее равно $p\,a_{\mathrm{sky}} + (1 - p)\,a_{\mathrm{grass}}$, а стандартное отклонение — $\sqrt{p(1 - p)}\,|a_{\mathrm{sky}} - a_{\mathrm{grass}}|$, поэтому нормализация по экземпляру даёт

$$\text{небо: } \pm\sqrt{\tfrac{1 - p}{p}}, \qquad \text{трава: } \mp\sqrt{\tfrac{p}{1 - p}},$$

где верхние знаки соответствуют случаю $a_{\mathrm{sky}} > a_{\mathrm{grass}}$. При $p = \tfrac14$ значения равны $1.732$ и $-0.577$ — одинаково для весов $(2, -1)$, $(0.3, 0.1)$ и $(5, 4)$. Каждый канал сохраняет расположение — где проходит граница и какая область больше — и теряет величину разности. Маска «море и песок» с тем же расположением даёт те же числа в каждом канале, где порядок двух значений тот же. Чем однороднее маска, тем меньше сохраняется, а для одной области не сохраняется ничего.

Конкатенация маски со входом каждого слоя не помогает, поскольку каждая конкатенированная копия снова проходит свёртку и нормализацию. В абляционном исследовании SPADE на COCO-Stuff средний IoU проверки сегментацией равен 31.9 для декодера, у которого маска конкатенируется на каждом слое, и 35.2 для того же декодера со SPADE (таблица 3).

SPADE: попиксельные масштаб и сдвиг по маске#

SPADE (SPatially-Adaptive DEnormalization, пространственно-адаптивная денормализация; Park et al., 2019, раздел 3) впускает маску после нормализации, где её уже ничто не может убрать. Активации $h$ слоя нормализуются без обучаемых параметров — поканальным средним $\mu_c$ и стандартным отклонением $\sigma_c$ по батчу и всем позициям, как в батч-нормализации, — а затем масштабируются и сдвигаются картами, вычисленными по маске (формула 1):

$$\mathrm{SPADE}(h, m)_{n, c, y, x} = \gamma_{c, y, x}(m)\, \frac{h_{n, c, y, x} - \mu_c}{\sigma_c} + \beta_{c, y, x}(m).$$

В батч-нормализации $\gamma_c$ и $\beta_c$ — по одному обучаемому числу на канал, в AdaIN $\gamma_c(s)$ и $\beta_c(s)$ зависят от вектора стиля, но не от позиции. Масштаб и сдвиг SPADE, в отличие от них, — тензоры с пространственными измерениями: своё значение в каждом пикселе, определяемое метками вокруг него. Их вычисляет небольшая свёрточная сеть: маска, приведённая к разрешению слоя методом ближайшего соседа, проходит через свёртку $3 \times 3$ со 128 каналами и ReLU, а две следующие свёртки $3 \times 3$ выдают $\gamma$ и $\beta$ (приложение A, рисунок 10). Если заменить маску меткой класса и сделать $\gamma, \beta$ постоянными по позициям, получится условная батч-нормализация; если заменить её изображением, сделать их постоянными и взять батч из одного изображения — AdaIN (раздел 3).

Рисунок

SPADE: карта меток задаёт масштаб и сдвиг в каждой точке

1. Изменение размера. Маска уменьшается до разрешения слоя.
2. Карты модуляции. Общая свёртка с ReLU и две выходные свёртки превращают её в $\gamma(x, y)$ и $\beta(x, y)$.
3. Нормализация. Активации каждого канала стандартизуются по статистикам батча.
4. Денормализация. Результат поэлементно умножается на $\gamma$ и сдвигается на $\beta$. На игрушечном рисунке $h = 5$ на небе превращается в $\hat h = (5 - 2.25)/1.392 = 1.98$, а затем в $1.5 \cdot 1.98 + 0.8 = 3.76$; однородная маска теперь дала бы однородные, но зависящие от метки $\gamma$ и $\beta$, а не нули.

Генератор. Поскольку маска входит в каждый слой нормализации, генератору не нужен энкодер для неё. Он начинает с 256-мерного случайного вектора, отображает его в тензор $4 \times 4 \times 1024$ и применяет семь остаточных блоков, в которых каждая нормализация заменена на SPADE, а между блоками стоит повышение разрешения $2\times$ (приложение A, рисунки 11 и 12). Случайный вектор даёт мультимодальный синтез. Если обучать генератор вместе с энкодером изображений, который выдаёт среднее и дисперсию, как в VAE, со слагаемым KL с весом 0.05, вектор переносит стиль эталонной фотографии: одну маску можно отрисовать в стиле любого образца (раздел 4, приложение A).

Обучение. Дискриминатор — многомасштабный PatchGAN из pix2pixHD со спектральной нормализацией во всех слоях, а функция потерь — как у pix2pixHD, включая слагаемые сопоставления признаков и VGG, но состязательное слагаемое наименьших квадратов заменено кусочно-линейной функцией потерь (hinge loss). Спектральная нормализация применяется и к генератору. Шаг обучения равен $10^{-4}$ для генератора и $4 \cdot 10^{-4}$ для дискриминатора, оптимизатор — Adam с $\beta_1 = 0$, $\beta_2 = 0.999$ (раздел 4).

Результаты. На COCO-Stuff (182 класса) средний IoU проверки сегментацией равен 37.4 против 14.6 у pix2pixHD и 23.7 у каскадной сети уточнения (cascaded refinement network, CRN), а FID — 22.6 против 111.5 и 70.4. На ADE20K средний IoU равен 38.5 против 20.3 у pix2pixHD, а FID — 33.9 против 81.8. На Cityscapes разрыв мал: 62.3 против 58.3 (таблица 1). В абляционном исследовании на COCO-Stuff (таблица 3) базовая модель энкодер–декодер pix2pixHD++ поднимается с 32.7 до 34.4, когда её слои нормализации становятся слоями SPADE, а описанный выше генератор SPADE — декодер без энкодера — достигает 35.2. Это тот же генератор, что и в таблице 1, где указано 37.4; в разделе 4 для него приводится 35.2, и статья не объясняет расхождения. Какую нормализацию без параметров оборачивает SPADE, важно меньше: в таблице 4 тот же генератор получает 33.9 с нормализацией по экземпляру и 35.0 с синхронизированной батч-нормализацией, своей настройкой по умолчанию, хотя остальные строки этой таблицы дают для конфигурации по умолчанию 35.2. Важно то, где входит маска.

Сверхразрешение: почему среднее выглядит размытым#

Оптимум MSE — условное среднее#

Сверхразрешение по одному изображению (single-image super-resolution) восстанавливает изображение высокого разрешения по уменьшенному, обычно в $4\times$ по каждой стороне, так что на каждый пиксель входа нужно произвести 16 пикселей. Обучающие пары достаются даром: достаточно уменьшить любую фотографию. Трудность — в функции потерь. Изображение низкого разрешения согласуется со многими изображениями высокого разрешения, которые различаются именно той мелкой текстурой, которую удалило уменьшение.

Выход, минимизирующий ожидаемую квадратичную ошибку для данного входа, — это условное среднее, $\hat y = \mathbb E[x^{\mathrm{HR}} \mid x^{\mathrm{LR}}]$, а его ожидаемая ошибка равна суммарной условной дисперсии, $\operatorname{tr} \operatorname{Cov}(x^{\mathrm{HR}} \mid x^{\mathrm{LR}})$. PSNR (пиковое отношение сигнала к шуму, peak signal-to-noise ratio), стандартная метрика сверхразрешения, равно $10 \log_{10}(\text{peak}^2/\mathrm{MSE})$ — убывающей функции MSE, поэтому оптимальный по PSNR выход — то же среднее. Когда правдоподобные ответы различаются текстурой, их среднее — гладкое изображение, не совпадающее ни с одним из них. Это та же размытость, с которой заметка о CycleGAN столкнулась в pix2pix, и причина, по которой попиксельное расстояние поощряет размытость.

Даже идеальный генератор не может исправить значение метрики. Пусть $x'$ — сэмпл из истинного условного распределения, взятый независимо от настоящего изображения. Обозначив условное среднее через $\mu$, получаем

$$\mathbb E\,\|x^{\mathrm{HR}} - x'\|^2 = \mathbb E\,\|(x^{\mathrm{HR}} - \mu) - (x' - \mu)\|^2 = 2 \operatorname{tr} \operatorname{Cov}(x^{\mathrm{HR}} \mid x^{\mathrm{LR}}),$$

поскольку два отклонения независимы и имеют нулевое среднее, так что перекрёстный член обращается в нуль. У идеального сэмплера MSE ровно вдвое больше, чем у среднего, а PSNR на $10 \log_{10} 2 = 3.01$ дБ меньше — на любом наборе данных. Метод, создающий реалистичную текстуру, обязан терять PSNR.

Рисунок

Почему оптимум MSE размыт, а сэмпл резок

В игрушечном примере усреднение блоков $4 \times 4$ полностью стирает полосатый узор с периодом 4, поэтому четыре сдвига полос дают один и тот же вход. Оптимум MSE — ровный серый цвет с MSE 0.25 (PSNR 6.02 дБ); сэмпл — резкий полосатый узор с ожидаемой MSE 0.50 (PSNR 3.01 дБ). Функция потерь $L_1$ здесь не лучше: в каждом пикселе половина кандидатов равна 0, а половина — 1, поэтому любое значение между 0 и 1 — попиксельная медиана, в том числе ровные 0.5.

SRGAN: функция потерь содержания на признаках VGG и состязательная функция потерь#

SRGAN (Ledig et al., 2017, раздел 2) заменяет квадратичную ошибку перцептивной функцией потерь (perceptual loss) из двух частей:

$$l^{\mathrm{SR}} = l^{\mathrm{SR}}_{\mathrm{VGG}/5.4} + 10^{-3}\, l^{\mathrm{SR}}_{\mathrm{Gen}} .$$

• Функция потерь содержания (content loss) — квадратичное расстояние между признаками VGG19 выхода и настоящего изображения, $l^{\mathrm{SR}}_{\mathrm{VGG}/i.j} = \frac{1}{W_{i,j} H_{i,j}} \sum_{x, y} \big(\varphi_{i,j}(x^{\mathrm{HR}})_{x,y} - \varphi_{i,j}(G(x^{\mathrm{LR}}))_{x,y}\big)^2$, где $\varphi_{i,j}$ — карта признаков после активации $j$-й свёртки перед $i$-м слоем max-pooling (формула 5). Слой $\varphi_{5,4}$ лежит глубоко в сети, где признаки описывают содержание и менее чувствительны к точным значениям пикселей, чем само изображение; этот выбор следует работе Johnson, Alahi and Fei-Fei (2016). Признаки умножаются на $1/12.75$, что умножает функцию потерь примерно на 0.006 и приводит её к масштабу попиксельной MSE (раздел 3.2).
• Состязательная функция потерь — ненасыщающаяся $-\log D(G(x^{\mathrm{LR}}))$, просуммированная по обучающим изображениям (формула 6). Функция потерь содержания держит выход близко к настоящему изображению в пространстве признаков; дискриминатор толкает его к множеству естественных изображений, которому среднее нескольких текстур не принадлежит.

Генератор, SRResNet, состоит из 16 остаточных блоков из двух свёрток $3 \times 3$ с 64 каналами, батч-нормализацией и PReLU и двух субпиксельных свёрток (sub-pixel convolution), каждая из которых удваивает разрешение. Дискриминатор следует рекомендациям DCGAN: восемь свёрток $3 \times 3$ с числом каналов от 64 до 512 и LeakyReLU (наклон 0.2), свёртки с шагом вместо пулинга, два полносвязных слоя и сигмоида. Для обучения используются 350 000 изображений ImageNet с вырезками $96 \times 96$ и батчами по 16. Обучение GAN начинается с генератора, обученного только на MSE, чтобы избежать плохих локальных оптимумов, и длится $10^5$ итераций с шагом обучения $10^{-4}$ и ещё $10^5$ — с $10^{-5}$ (раздел 3.2).

На BSD100 при $4\times$ 26 оценщиков ставили изображениям баллы от 1 (плохо) до 5 (отлично) (таблица 2):

	бикубическая интерполяция	SRResNet (MSE)	SRGAN	оригинал
PSNR, дБ	25.94	27.58	25.16	∞
средний балл (mean opinion score)	1.47	2.29	3.56	4.46

У SRGAN самый низкий PSNR — на 2.42 дБ ниже, чем у SRResNet, и ниже даже, чем у бикубической интерполяции, — и намного лучший средний балл. Потеря относительно SRResNet, 2.42 дБ, близка к $3.01$ дБ, которые рассуждение предсказывает для идеального сэмплера по сравнению с истинным средним. Статья делает вывод, что PSNR и SSIM не измеряют качество так, как его воспринимают люди (раздел 4); позднее LPIPS подогнали к суждениям людей, чтобы закрыть этот пробел.

ESRGAN: RRDB, релятивистский дискриминатор и признаки до активации#

ESRGAN (Wang et al., 2018b, раздел 3) сохраняет устройство SRGAN и улучшает каждую из трёх его частей:

• Генератор: RRDB без батч-нормализации. Батч-нормализация использует статистики батча при обучении и скользящие средние при тестировании; когда они расходятся, она порождала артефакты, чаще в глубоких сетях, обучаемых как GAN. ESRGAN убирает её и заменяет остаточный блок плотным блоком «остаток в остатке» (Residual-in-Residual Dense Block, RRDB): плотные блоки, в которых каждая свёртка получает выходы всех предыдущих, вложены в два уровня остаточных связей. Каждая остаточная ветвь перед сложением умножается на константу $\beta$ между 0 и 1 (масштабирование остатка, residual scaling), а веса инициализируются с меньшей дисперсией; и то и другое стабилизирует очень глубокую сеть. В большой модели 23 RRDB.
• Дискриминатор: релятивистский усреднённый. Дискриминатор SRGAN оценивает вероятность того, что изображение настоящее, $D(x) = \sigma(C(x))$, где $C$ — необработанный выход. Релятивистский усреднённый дискриминатор (relativistic average discriminator) из работы Jolicoeur-Martineau (2018) оценивает вероятность того, что настоящее изображение реалистичнее подделок в среднем:

$$D_{\mathrm{Ra}}(x_r, x_f) = \sigma\big(C(x_r) - \mathbb E_{x_f}[C(x_f)]\big),$$

где среднее берётся по подделкам мини-батча. Функции потерь симметричны (формулы 1–2):

$$\begin{aligned} \mathcal L^{\mathrm{Ra}}_D &= -\mathbb E_{x_r}\big[\log D_{\mathrm{Ra}}(x_r, x_f)\big] - \mathbb E_{x_f}\big[\log\big(1 - D_{\mathrm{Ra}}(x_f, x_r)\big)\big], \\ \mathcal L^{\mathrm{Ra}}_G &= -\mathbb E_{x_r}\big[\log\big(1 - D_{\mathrm{Ra}}(x_r, x_f)\big)\big] - \mathbb E_{x_f}\big[\log D_{\mathrm{Ra}}(x_f, x_r)\big], \end{aligned}$$

где $D_{\mathrm{Ra}}(x_f, x_r)$ сравнивает подделку со средним значением на настоящих изображениях. Теперь функция потерь генератора содержит и настоящие изображения, а её градиент проходит через слагаемое $\mathbb E_{x_f}[C(x_f)]$ внутри $D_{\mathrm{Ra}}(x_r, x_f)$: по мере улучшения подделок настоящие изображения выглядят на их фоне менее настоящими, хотя $C(x_r)$ не изменилось. Авторы связывают с этим более резкие границы и более детальные текстуры.

• Перцептивная функция потерь: признаки до активации. После ReLU глубоко в VGG19 большинство признаков равны нулю: для одного тестового изображения активны лишь 11.17% нейронов в $\varphi_{5,4}$. Функция потерь на таких разреженных признаках даёт слабый сигнал обучения, а кроме того, из-за неё яркость выхода уходила от яркости настоящего изображения. ESRGAN берёт признаки до активации.

Генератор минимизирует $\mathcal L_G = \mathcal L_{\mathrm{percep}} + \lambda\, \mathcal L^{\mathrm{Ra}}_G + \eta\, \mathcal L_1$ с $\lambda = 5 \cdot 10^{-3}$ и $\eta = 10^{-2}$, где $\mathcal L_1$ — попиксельное расстояние до настоящего изображения (формула 3). Обучение начинается с сети, обученной только на $\mathcal L_1$, чтобы дискриминатор с самого начала видел разумные изображения (раздел 4.1). Для обучения используются DIV2K, Flickr2K и набор OutdoorSceneTraining с вырезками $128 \times 128$. Наконец, интерполяция сетей (network interpolation) смешивает веса двух генераторов, $\theta = (1 - \alpha)\,\theta_{\mathrm{PSNR}} + \alpha\,\theta_{\mathrm{GAN}}$, что позволяет во время тестирования непрерывно обменивать PSNR на текстуру без повторного обучения и даёт более чистые результаты, чем смешивание выходных изображений (раздел 3.4). Вариант ESRGAN победил в области 3 конкурса по сверхразрешению PIRM 2018 — в той области, где ограничение на ошибку было самым слабым и всё решал перцептивный индекс.

Что изменилось#

Модели перевода из этой и двух предыдущих заметок различаются в основном тем, что удерживает выход верным входу:

Метод	Вход → выход	Что привязывает выход к входу	Данные	Выходов на вход
pix2pix	изображение → изображение	$L_1$ до настоящей цели; условный $D(x, y)$	парные	один
CycleGAN	изображение → изображение, два домена	цикловая функция потерь через второй генератор	непарные	один
StarGAN	изображение + целевая метка → изображение	цикл с исходной меткой; классификатор доменов	непарные, домены с метками	один на метку
StarGAN v2	изображение + код стиля → изображение	цикл со стилем входа; реконструкция стиля	непарные, один домен на изображение	много
MUNIT	изображение + код стиля → изображение, два домена	реконструкция содержания и стиля; реконструкция изображения внутри домена	непарные	много
CUT	изображение → изображение	PatchNCE между соответствующими фрагментами входа и выхода	непарные	один
pix2pixHD	карта меток → фотография	условный многомасштабный $D$; сопоставление признаков с парной фотографией	парные	один
SPADE	карта меток (+ вектор стиля) → фотография	маска модулирует каждый слой нормализации; функции потерь pix2pixHD	парные	много, с энкодером изображений
SRGAN	изображение низкого разрешения → высокого	расстояние между признаками VGG выхода и настоящего изображения	парные (получены уменьшением)	один

Ограничения#

• MUNIT работает с двумя доменами и глобальным стилем. Одна модель на пару доменов, как у CycleGAN. Стиль — один вектор из 8 чисел на всё изображение, поэтому он не может меняться локально, а что считать содержанием и что стилем, задаёт архитектура (пространственная карта против усреднённого вектора), а не смысл.
• CUT даёт один выход на вход. Его генератор детерминирован. Свобода сближаться с целевыми статистиками может приводить к нежелательным изменениям, например к текстуре зебры на фоне, а непривычная поза может заставить модель покрыть текстурой фон вместо животного (рисунок 3 статьи). Кроме того, среди внутренних негативных примеров есть фрагменты, которые действительно похожи друг на друга, — два фрагмента одного неба, — а функция потерь всё равно их расталкивает.
• Семантическому синтезу нужны маски, выровненные по пикселям. Разметка дорога; для пейзажей Flickr SPADE использовал маски, предсказанные сетью сегментации. Проверка сегментацией измеряет расположение, а не реалистичность, и базовая модель SIMS на Cityscapes достигла лучшего FID, чем SPADE, вставляя настоящие фрагменты, которые не соответствуют маске.
• GAN для сверхразрешения выдумывают детали. Текстура правдоподобна, но не истинна: это неприемлемо там, где детали служат доказательством, как авторы SRGAN отмечают для медицинских изображений и видеонаблюдения. PSNR падает по самой постановке, а средние баллы, перцептивные индексы и выученные расстояния, которые его заменяют, требуют каждый своего протокола.
• Каждое число зависит от способа оценки. FID меняется с числом сэмплов, метрики разнообразия считают артефакты разнообразием (абляционное исследование MUNIT показывает это так же ясно, как результаты StarGAN v2 на AFHQ), а метрики сегментации зависят от сети сегментации.

Итоги#

• MUNIT кодирует изображение в пространственный код содержания, общий для двух доменов, и 8-мерный код стиля, свой для каждого домена. Перевод декодирует содержание со стилем, взятым из $\mathcal N(0, I)$ или с образца и встроенным через AdaIN. Функции потерь: реконструкция изображения, реконструкция содержания и стиля ($\lambda_x = 10$, $\lambda_c = \lambda_s = 1$) и многомасштабный GAN наименьших квадратов.
• Точная цикловая функция потерь при совпадающих маргинальных распределениях вынуждает перевод быть детерминированным; функции потерь реконструкции MUNIT влекут лишь цикл, дополненный стилем, — именно такой цикл использует StarGAN v2.
• CUT односторонний: функция потерь PatchNCE требует, чтобы каждый фрагмент выхода выбрал соответствующий фрагмент входа среди 255 других фрагментов того же входа, на пяти слоях энкодера генератора, с $\tau = 0.07$. InfoNCE — многоклассовый вариант NCE, он даёт нижнюю оценку взаимной информации. CUT превосходит CycleGAN по FID, тратя меньше времени и памяти на итерацию; FastCUT обходится без тождественного слагаемого и требует ещё меньше.
• pix2pixHD достигает $2048 \times 1024$ с помощью генератора «от грубого к точному», трёх дискриминаторов на трёх масштабах и функции потерь сопоставления признаков дискриминатора ($\lambda = 10$).
• Нормализация по экземпляру после свёртки стирает однородную карту меток, а от кусочно-постоянной сохраняет лишь расположение. SPADE нормализует активации без параметров, а затем применяет попиксельные $\gamma(m)$ и $\beta(m)$, вычисленные по маске, так что метки входят после нормализации.
• Оптимальное по MSE сверхразрешение — условное среднее, размытое, когда текстура неопределённа; у идеального сэмплера MSE вдвое больше, а PSNR на 3.01 дБ меньше. SRGAN обучается на функции потерь по признакам VGG плюс состязательной функции потерь с весом $10^{-3}$; ESRGAN добавляет RRDB без батч-нормализации, релятивистский усреднённый дискриминатор и признаки до активации.

Код#

Реализация функций потерь InfoNCE и PatchNCE на NumPy, проверенная на разобранном примере и на случайных признаках:

import numpy as np

def info_nce(q, pos, negs, tau=0.07):
    """One query: unit vectors q, pos [K] and negs [N, K]; returns the loss and p(positive)."""
    logits = np.r_[q @ pos, negs @ q] / tau
    logits -= logits.max()
    p = np.exp(logits) / np.exp(logits).sum()
    return -np.log(p[0]), p[0]

def patch_nce(f_out, f_in, tau=0.07):
    """f_out, f_in: [S, K] unit features at S sampled locations of the output and the input.
    Query s is f_out[s]; its positive is f_in[s]; the other S - 1 input locations are its negatives."""
    logits = f_out @ f_in.T / tau                  # [S, S]; на диагонали стоят позитивные примеры
    logits -= logits.max(axis=1, keepdims=True)
    log_p = logits - np.log(np.exp(logits).sum(axis=1, keepdims=True))
    return -np.mean(np.diag(log_p))

unit = lambda a: a / np.linalg.norm(a, axis=-1, keepdims=True)

# разобранный пример: косинусы 0.5 (позитивный) и 0.45, 0.2, -0.1 (негативные), для наглядности в 2-D
q = np.array([1.0, 0.0])
cosv = lambda c: np.array([c, np.sqrt(1 - c * c)])
pos, negs = cosv(0.5), np.stack([cosv(c) for c in (0.45, 0.2, -0.1)])
for tau in (1.0, 0.07):
    loss, p = info_nce(q, pos, negs, tau)
    print(f"tau={tau}: p(positive)={p:.3f}, loss={loss:.3f}")
# tau=1.0: p(positive)=0.309, loss=1.176
# tau=0.07: p(positive)=0.665, loss=0.408

# 256 позиций с 256-мерными признаками: точная копия, зашумлённая копия, несвязанные признаки
rng = np.random.default_rng(0)
f_in = unit(rng.standard_normal((256, 256)))
for name, f_out in [("copy", f_in),
                    ("noisy copy", unit(f_in + 3.0 * unit(rng.standard_normal((256, 256))))),
                    ("unrelated", unit(rng.standard_normal((256, 256))))]:
    print(f"{name:>10}: PatchNCE = {patch_nce(f_out, f_in):.3f}")
print(f"log 256 = {np.log(256):.3f}")
#       copy: PatchNCE = 0.000
# noisy copy: PatchNCE = 1.725
#  unrelated: PatchNCE = 5.903
# log 256 = 5.545

У зашумлённой копии косинус с позитивным примером около 0.31. Позитивный пример — самый похожий кандидат для 255 из 256 запросов, и всё же softmax даёт ему в среднем вероятность лишь около 0.2, потому что 255 негативных примеров с косинусами около нуля делят между собой остальное: функция потерь продолжает давить, пока зазор не станет большим по сравнению с $\tau$. Несвязанные признаки дают около $\log 256$ или чуть больше: позитивный пример тогда похож на запрос не больше, чем любой негативный, а некоторые негативные случайно оказываются похожее.

Дальше#

Каждую модель из этой заметки оценивали числами: FID — реалистичность, расстояния LPIPS между выходами — разнообразие, метрики сегментации — верность карте меток, средние баллы — качество сверхразрешения. Абляционное исследование MUNIT и PSNR у SRGAN показали, как легко такое число поощряет не то. Следующие заметки объясняют, откуда берутся эти числа и что они упускают, начиная с Inception Score, который оценивает сгенерированные изображения с помощью предобученного классификатора.

Где посмотреть изображения#

Эти модели лучше всего судить по их сэмплам. В каждой строке указано, где их найти; номера рисунков относятся к указанной версии arXiv.

• MUNIT (Huang et al., 2018; arXiv v2): границы → обувь в сравнении с базовыми моделями — на рисунке 4; границы ↔ обувь и сумки — на рисунке 5, животные — на рисунке 6, уличные сцены — на рисунке 7, Йосемити лето ↔ зима — на рисунке 8; перевод по образцу стиля — на рисунке 9; репозиторий с видео результатов.
• CUT (Park et al., 2020; arXiv v3): лошадь → зебра, кошка → собака и Cityscapes в сравнении с базовыми моделями — на рисунке 3, случайно выбранные результаты — на рисунке 10; картина → фотография при обучении на одном изображении — на рисунке 9; страница проекта с видео.
• pix2pixHD (Wang et al., 2018a; arXiv v2): уличные сцены $2048 \times 1024$ по картам меток, с редактированием меток и облика, — на рисунке 1; границы → лица и кошки — на рисунке 2; сравнения на Cityscapes — на рисунках 9 и 10; ADE20K — на рисунке 11; страница проекта с видео и демонстрациями редактирования.
• SPADE (Park et al., 2019; arXiv v2): карта меток в сочетании с изображением стиля — на рисунке 1; COCO-Stuff, ADE20K и Cityscapes в сравнении с базовыми моделями — на рисунках 5 и 6; пейзажи Flickr — на рисунке 7; несколько выходов для одной маски — на рисунке 9; страница проекта.
• SRGAN (Ledig et al., 2017; arXiv v5): бикубическая интерполяция, сеть, обученная на MSE, и SRGAN рядом — на рисунке 2; варианты функции потерь содержания — на рисунке 6; результаты на Set5, Set14 и BSD100 — на рисунках 11–15.
• ESRGAN (Wang et al., 2018b; arXiv v2): SRGAN против ESRGAN — на рисунках 1 и 7; эффект каждого изменения — на рисунке 8; интерполяция сетей — на рисунке 10 (нумерация основного текста; в дополнительных материалах нумерация снова начинается с 1); репозиторий с изображениями результатов.

Литература#

• X. Huang, M.-Y. Liu, S. Belongie, J. Kautz. Multimodal unsupervised image-to-image translation. ECCV, 2018. Номера разделов относятся к arXiv v2: предположение и модель — в разделе 3, функции потерь — в формулах 1–5, предложения 2, 4 и 5 — в разделе 4 и приложении A, архитектура и гиперпараметры — в разделе 5.1 и приложении B, оценка на задаче границы → обувь — в таблице 1.
• T. Park, A. A. Efros, R. Zhang, J.-Y. Zhu. Contrastive learning for unpaired image-to-image translation. ECCV, 2020. Номера разделов относятся к arXiv v3: InfoNCE и PatchNCE — в разделе 3 (формулы 2–5), сравнение — в таблице 1, абляционные исследования — в разделе 4.2, детали обучения и сближение распределений — в приложениях C.1 и C.4.
• A. van den Oord, Y. Li, O. Vinyals. Representation learning with contrastive predictive coding. arXiv:1807.03748, 2018. Раздел 2.3: функция потерь InfoNCE и оценка $I \ge \log N - \mathcal L_N$.
• T.-C. Wang, M.-Y. Liu, J.-Y. Zhu, A. Tao, J. Kautz, B. Catanzaro. High-resolution image synthesis and semantic manipulation with conditional GANs. CVPR, 2018 (цитируется как Wang et al., 2018a). Раздел 3.2: генератор от грубого к точному, многомасштабные дискриминаторы и функция потерь сопоставления признаков (формулы 3–5); результаты — в разделе 4 и таблице 1.
• T. Park, M.-Y. Liu, T.-C. Wang, J.-Y. Zhu. Semantic image synthesis with spatially-adaptive normalization. CVPR, 2019. Раздел 3: SPADE (формула 1) и почему нормализация смывает маску; раздел 4 и таблицы 1, 3 и 4: результаты и абляционные исследования; приложение A: архитектуры и детали обучения.
• C. Ledig, L. Theis, F. Huszár, J. Caballero, A. Cunningham, A. Acosta, A. Aitken, A. Tejani, J. Totz, Z. Wang, W. Shi. Photo-realistic single image super-resolution using a generative adversarial network. CVPR, 2017. Раздел 2: сети и перцептивная функция потерь (формулы 3–6); раздел 3.2: обучение; таблицы 1 и 2: PSNR и средние баллы.
• X. Wang, K. Yu, S. Wu, J. Gu, Y. Liu, C. Dong, C. C. Loy, Y. Qiao, X. Tang. ESRGAN: Enhanced super-resolution generative adversarial networks. ECCV Workshops, 2018 (цитируется как Wang et al., 2018b). Раздел 3: RRDB, релятивистский дискриминатор (формулы 1–2), перцептивная функция потерь и полная функция потерь (формула 3), интерполяция сетей (формула 4); раздел 4.1: обучение.
• A. Jolicoeur-Martineau. The relativistic discriminator: a key element missing from standard GAN. arXiv:1807.00734, 2018.
• J. Johnson, A. Alahi, L. Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. ECCV, 2016.
• Y. Choi, Y. Uh, J. Yoo, J.-W. Ha. StarGAN v2: Diverse image synthesis for multiple domains. CVPR, 2020. Раздел 2: сети и функции потерь, включая цикл со стилем входа.