[Из песочницы] Еще один алгоритм для восстановления смазанных изображений


Доброго времени суток. Уже столько сказано о методах деконволюции изображений, кажется добавить больше нечего. Однако всегда найдется алгоритм лучше и новее предыдущих. Не так давно был описан итерационный алгоритм, имеющий линейную скорость сходимости при малых затратах памяти, стабильный и хорошо распараллеливаемый. А через некоторое время он был улучшен еще и до квадратичной сходимости. Встречайте: (Fast) Iterative Shrinkage-Thresholding Algorithm.

2d03245ebf0b473f9602953084bbade7.bmp

Постановка задачи


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

$$display$$\mathbf{y}=\mathbf{Ax}+ \mathbf{n}$$display$$

Матрица $inline$\mathbf{A}$inline$ является матрицей свертки, и с физической точки зрения показывает взаимосвязь между точками исходных и испорченных данных. В случае с изображениями, эту матрицу можно получить преобразовав ядро свертки. Вектора $inline$\mathbf{x}$inline$ и $inline$\mathbf{y}$inline$ являются исходным и поврежденным изображением в векторизованной форме. Иначе говоря, все столбцы пикселей в изображении конкатенируются одно за другим.

Первая проблема такой постановки задачи: количество выделяемой памяти. Если изображение имеет размеры 640×480, то задача хранит два вектора изображений размерами 307200×1 и матрицу размером 307200×307200 элементов. Матрица свертки разрежена, однако ее размеры даже в разреженной форме будут большими, и займут много памяти. Произведение с матрицей свертки можно заменить на двумерную свертку с ядром, что не требует хранения большой матрицы в памяти, этим мы решим проблему с хранением матрицы $inline$\mathbf{A}$inline$.
Для поиска изображения, максимально близкого к исходному, запишем оптимизируемую функцию в классическом виде второй нормы невязки между поврежденным и искомым изображениями.

$$display$$min_{\hat{\mathbf{x}}} \mid\mid \mathbf{y-A\hat{x}} \mid\mid_2$$display$$

Отличие от классических методов


Такая постановка задачи является одной из самых популярных, однако мы ее дополним для улучшения производительности. Использованный подход называется «Majorization-maximization», и заключается он в подмене исходной задачи на другую, очень похожую. Новая задача обладает двумя свойствами:
  1. Задача значительно проще
  2. Во всех точках кроме текущей имеет невязку большую, чем исходная задача

Данное действие происходит на каждой итерации алгоритма. Звучит достаточно сложно, гораздо сложнее, чем это выглядит на самом деле. Итоговая функция минимизации для итерации $inline$k$inline$ записана следующим образом:

$$display$$\mathbf{J_k (x)}= \mid\mid \mathbf{y-A\hat{x}} \mid\mid_2 + (\mathbf{\hat{x}-\hat{x_k}})^T (\alpha\mathbf{I}- \mathbf{A^TA}) (\mathbf{\hat{x}-\hat{x_k}})$$display$$

Матрица правого слагаемого положительно определена. Это достигается тем, что $inline$\alpha>maxeig (\mathbf{A^TA})$inline$. Функция минимизации состоит из суммы двух величин, каждая из которых неотрицательна. При этом, в точке $inline$\mathbf{\hat{x}=\hat{x}_k}$inline$ второе слагаемое равно нулю, благодаря чему выполняется второе условие из списка.

Поиск решения


Поиск решения начнем классическим методом: раскроем скобки, выпишем градиент и приравниванием его к нулю. Важно заметить, это градиент на $inline$k$inline$-той итерации. Внимание много математики!

$$display$$\mathbf{J_k (\hat{x})}=(\mathbf{y-A\hat{x}})^T (\mathbf{y-A\hat{x}})+ (\mathbf{\hat{x}-\hat{x}_k})^T \cdot (\alpha\mathbf{I}- \mathbf{A^TA})\cdot (\mathbf{\hat{x}-\hat{x}_k})$$display$$


$$display$$\mathbf{J_k (\hat{x})}=\mathbf{y^Ty}+\mathbf{\hat{x}^TA^TA\hat{x}} -2\mathbf{y^TA\hat{x}} -\\-\mathbf{\hat{x}^T (\alpha\mathbf{I}- \mathbf{A^TA})\hat{x}}+\mathbf{\hat{x}_k^T (\alpha\mathbf{I}- \mathbf{A^TA})\hat{x}_k} -2\mathbf{\hat{x}_k^T (\alpha\mathbf{I}- \mathbf{A^TA})\hat{x}} $$display$$

$$display$$\frac{\mathbf{J_k (\hat{x})}}{\delta\mathbf{\hat{x}}}=\mathbf{A^TA\hat{x}} -2\mathbf{A^Ty}+\mathbf{2\alpha\mathbf{I}\hat{x}- \mathbf{A^TA}\hat{x}}-2\mathbf{(\alpha\mathbf{I}- \mathbf{A^TA})\hat{x}_k} $$display$$

В итоге производная будет иметь следующий вид:

$$display$$\delta J_k (x)=2\mathbf{A^Ty}-2(\alpha\mathbf{I-A^TA})\mathbf{\hat{x}_k}+2\alpha\mathbf{\hat{x}}$$display$$

Следующий классический шаг в данной ситуации — приравнять градиент к нулю, и выразить из полученного выражения искомый вектор $inline$\mathbf{\hat{x}}$inline$. Записанный $inline$\mathbf{\hat{x}}$inline$ определим как $inline$\mathbf{\hat{x}_{n+1}}$inline$ или как решение на следующей итерации.

$$display$$\delta J_k (x)=2\mathbf{A^Ty}-2(\alpha\mathbf{I-A^TA})\mathbf{\hat{x}_k}+2\alpha\mathbf{\hat{x}}=0$$display$$


$$display$$\mathbf{A^Ty}+\alpha\mathbf{I}\mathbf{\hat{x}_k}-\mathbf{A^TA}\mathbf{\hat{x}_k}=\alpha\mathbf{\hat{x}}$$display$$


$$display$$\mathbf{\hat{x}_{k+1}}= \mathbf{\hat{x}_k}+\frac{1}{\alpha} \cdot\mathbf{A^T (y-A\hat{x_k})}$$display$$

Выписанное в результате выражение называется «Landweber iteration». Это основная формула между итерациями. Используя его, можно гарантировать уменьшение невязки от итерации к итерации с линейной скоростью.

Базовый алгоритм содержит дополнительный шаг, называемый «soft-threshold», и предполагающий разреженность решения. Данный шаг приравнивает нулю все значения искомого вектора по модулю меньшие, чем установленное значение. Это уменьшает влияние шума на результат восстановления.

Как это выглядит
faf79440a2d14c43b6961c42aa14075d.bmp

Как видно из решения, у нас есть два параметра, которые мы регулируем на свой вкус. $inline$\lambda$inline$ отвечает за точность приближения, ограничивая сходимость порогом. $inline$\alpha$inline$ отвечает за стабильность работы и скорость сходимости алгоритма.

$$display$$\mathbf{\hat{x}_{k+1}}=soft (\mathbf{\hat{x}_k}+\frac{1}{\alpha} \cdot\mathbf{A^T (y-A\hat{x_k})},\lambda/\alpha)$$display$$

Модификация алгоритма


В дальнейшем алгоритм был усовершенствован дополнительным слагаемым, схожим по идее с методом сопряженных градиентов. Добавляя на каждом шаге разницу между результатом двух предыдущих итераций, мы увеличиваем сходимость алгоритма до квадратичной. Итоговая процедура работы алгоритма выглядит следующим образом:
  1. Задать параметры $inline$\lambda, \alpha $inline$
  2. Задать $inline$t_1=1, t_0=1,\mathbf{y_{temp}=\hat{x}_0=A^Ty}$inline$
  3. Произвести итерацию базового алгоритма $inline$\mathbf{\hat{x}_{k+1}}= soft (\mathbf{y_{temp}}+\frac{1}{\alpha} \cdot\mathbf{A^T (y-Ay_{temp})},\lambda/\alpha)$inline$
  4. Обновить временные переменные
    $inline$t_0=t_1; t_1=0.5+\sqrt{0.25+t_1^2}$inline$
  5. Добавить сопряженную компоненту к переменной $inline$\mathbf{y_{temp}=\hat{x}_k}+\frac{t_0–1}{t_1}\cdot (\mathbf{\hat{x}_k-\hat{x}_{k-1}})$inline$

Теперь о параллельности алгоритма. Цикл для вычисления порога на каждой итерации можно выразить через поэлементные произведения (произведение Адамара) и операции сравнения, которые включены как в OpenCL так и в CUDA, так что их можно легко распараллелить.
Я реализовал алгоритм на Matlab в двух вариантах: для вычисления на CPU и на GPU. В дальнейшем я стал использовать только версию кода для GPU, так как она удобнее. Код представлен ниже.

Код здесь
function [x] = fista_gpu(y,H,Ht,lambda,alpha,Nit)
x=Ht(y);
y_k=x;
t_1=1;
T=lambda/alpha;
for k = 1:Nit
x_old=x;
x=soft_gpu((y_k+(1/alpha)*Ht(y-H(y_k))), T);
t_0=t_1-1;    
t_1=0.5+sqrt(0.25+t_1^2);
y_k=x+(t_0/t_1)*(x-x_old);
end
end
function [y] = soft_gpu(x,T)
eq=ge(abs(x),abs(T));
y=eq.*sign(x).*(abs(x)-abs(T));
end


Давайте спустимся ближе к практике, и протестируем производительность алгоритма в зависимости от размера картинки.
Конфигурация моего ноутбука
Intel core I3–4005U
NVIDIA GeForce 820M

Слева представлен график зависимости работы алгоритма на 100 итераций, в зависимости от количества пикселей для CPU и GPU.
  • Как видно из результатов, алгоритм на GPU практически не зависит от размеров задачи и для действительно больших проблем мы ограничены только памятью GPU. Полсекунды для 2000×2000 (без учета выгрузки из памяти) достойный результат, не находите?
  • Справа представлена зависимость затраченного алгоритмом времени от количества итераций. При увеличении количества итераций, алгоритм на GPU начинает реагировать увеличением времени работы. Вероятнее всего, это связано с моими ошибками написания кода, либо принудительным понижением частоты работы GPU. В большинстве случаев хватает 100 итераций.

4717e1f349e646b28974605ae0761310.bmp

На следующих графиках представлено сравнение базового и улучшенного алгоритма, а так же зависимости сходимости алгоритма от $inline$\alpha$inline$ и $inline$\lambda$inline$ параметров.

  • Как видно из графика слева, улучшенный алгоритм сходится значительно быстрее, чем базовый, и после ста итераций практически не показывает увеличения точности. Базовый алгоритм лишь к пятисотой итерации показывает приемлемый результат.
  • По центральному графику видно, в зависимости от $inline$\lambda $inline$ меняется порог сходимости алгоритма, что ограничивает производительность. Это необходимый компромисс, если сигнал сильно зашумлен.
  • По правому графику видно, что при увеличении $inline$\alpha $inline$ алгоритм сходится гораздо медленнее. Аналогично предыдущему случаю, присутствует компромисс между «качеством» матрицы свертки и скоростью сходимости.

4d8ce01e217a4ba6b3a2e15a3dc1c4b8.bmp

Ну и напоследок пример работы алгоритма на FHD картинке,

Исходная картинка
0397228103764cd39cdf5dab49dd4377.jpg

Испорченная и зашумленная картинка
2b9140cac5c3429aa97e11bb5ae34120.bmp
Восстановленная картинка
eb78bfdae1e441e7a07aad69fa98ab80.bmp

Как видите результат достаточно хороший, особенно если он занимает всего 15 секунд из которых 1.5 это работа алгоритма и 13.5 выгрузка картинки из памяти GPU.
Весь использованный для алгоритма код выложен в GitHub.

Использованная литература


  • I. Selesnick. (2009) About: Sparse signal restoration.
  • A. Beck and M. Teboulle Fast Gradient-Based Algorithms for Constrained Total Variation Image Denoising and Deblurring Problems IEEE TRANSACTIONS ON IMAGE PROCESSING, VOL. 18, NO. 11, NOVEMBER 2009
  • P.L. Combettes and J.-C. Pesquet Proximal Splitting Methods in Signal Processing

Комментарии (0)

© Habrahabr.ru