{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "# Sequential Subspace Optimization Method for Large-Scale Unconstrained Problems\n", "## (ECE 602 Final Project)\n", "\n", "## Table of Contents\n", "* [Introduction](#first-bullet)\n", "* [SESOP (Sequential Subspace Optimization)](#second-bullet)\n", "* [Fast SESOP](#third-bullet)\n", "* [Newton method](#forth-bullet)\n", "* [Modified Newton method](#fifth-bullet)\n", "* [Implementation details](#sixth-bullet)\n", "* [References](#seventh-bullet)\n", "\n", "## Introduction \n", "\n", "Cosider the function $f$ is the objective we want to minimize over all $x$, belonging to $R^n$. When the number of variables is very large, let say $n$ is greater than $10^4$ and more, we need \n", " for a optimization algorithm, for which storage requirement and computational cost per iteration grow not more than linearly in $n$. Conjugate gradient (CG) method is one the first methods which was proposed to tackle computational costs. It is known that CG worst case\n", "convergence rate for quadratic problems. However, CG to nonlinear\n", "functions is not worstcase optimal. In the paper, a method is presented ,which is equivalent to CG in the quadratic case, and often outperforms CG and Trancated Newton (TN) in non-quadratic case, while preserving worst-case optimality.\n", "\n", "This method is used for large scale unconstraint optimization problems, in which at each iteration the minimum of the objective function is searched over a subspace spanned by the current gradient and by directions of few previous steps.\n", "\n", "\n", "## SESOP (Sequential Subspace Optimization) \n", "\n", "In this section we describe the SESOP algorithm, which is a general method for\n", "smooth unconstrained optimization. Generaly, in this algorithms , we minimize the objective function $f$ in a subsapace of $R^n$ at each iteration($k$). This subspace is constructed using the points $x_{k-1}, x_{k-2},...,x_{k-M}$ from previous iterations. Also, the gradient of $f$ (g^k) at point $x_k$ beside two Nemrowski directios are used to biuld the subspace. \n", "\n", "\n", "To construct the subspace, following steps need to be done at each iteration($k$):\n", "\n", "\n", "\n", "\n", "$min\\:\\:f(x) \\:\\:\\: where f\\:\\:is\\:\\:smooth$\n", "\n", "\n", "\n", "$1.\\:\\: g^k = \\nabla f(x^k)$\n", "\n", "\n", "$2.\\:\\: d^{k-1} = x^k - x^{k-1}$\n", "\n", "\n", "\n", "$3.\\:\\: P^k = (g^k|d^{k-1}...d^{k-M})$\n", "\n", "\n", "\n", "$4.\\:\\:\\alpha ^k = argmin\\:\\:f(x^k+P \\alpha)$\n", "\n", "\n", "\n", "$5. \\:\\:x^{k+1}=x^k+P\\alpha ^k$\n", "\n", "\n", "$6. \\:\\: update \\:\\:matrix\\:\\: P\\:\\: with \\:\\:new \\:\\:directios$\n", "\n", "\n", "In step six, optimization is done on the subspace which is spanned by the column of matrix $P^k$. Note that the number of the columns of matrix $P^k$ is $M$ which is much smaller than original space dimenstion, $n$. To do the optimization on this subsapce, we are looking for a $\\alpha$ which minimize $f(x^k+ P\\alpha)$. This optimization can be done using Newton ,Truncated Newton(TN), CG or even exact line search method. Newton method will be explained in the sections below.\n", "\n", "\n", "\n", "## Fast SESOP \n", "\n", "In some applications:\n", "\n", "\\begin{equation}\n", "f(x)=\\Phi (Ax)\n", "\\end{equation}\n", "\n", "where, $\\Phi$ is cheap to compute, but $Ax$ is expensive to compute, but\n", "\n", "\\begin{equation}\n", "f(x^k+P\\alpha)+\\Phi(Ax^k+AP\\alpha), \\:\\:\\: AP = R\n", "\\end{equation}\n", "\n", "Hence, in each iteration we only need to compute $Ax$ once. Furthermore, for each $x^k$, we change only two columns of P. Considering $Ax^{k+1}=Ax+Rx^k$, we do not need to compute $Ax^{k+1}$ for each k, just update it. We can compute it directly in each let say 10 iteration. Therefore, if\n", "\n", "\\begin{equation}\n", "argmin\\:\\:||Ac-y||^2 + \\mu _0 * smooth\\_function(c)\n", "\\end{equation}\n", "\n", "Then,\n", "\\begin{equation}\n", "\\nabla _\\alpha \\Phi(Ax^k+R\\alpha) = R^T\\nabla _u\\Phi(u) \\Longrightarrow Gradient\n", "\\end{equation}\n", "\n", "\\begin{equation}\n", "\\nabla ^2 _{\\alpha \\alpha} \\Phi(Ax^k+R\\alpha) = R^T\\nabla ^2 _{uu}\\Phi(u)R \\Longrightarrow Hessian\n", "\\end{equation}\n", "\n", "\\begin{equation}\n", "x^{k+1}=x^k+\\alpha ^kd^k,\\:\\:f'\\:^k_d(x^k)\\:<0\\:\\:or\\:\\: <\\nabla f(x^k),d^k>\\:\\:<0\n", "\\end{equation}\n", "\n", "\n", "## Newton method \n", "In this method, to find the best direction $d$ in order to optimize function $f$ around point $x^k$, Teilor exanstion is applied.\n", "\n", "\\begin{equation}\n", "f(x_k,d) \\cong f(x_k) + d^Tg(x_k) + \\frac{1}{2}d^TH(x_k)d\n", "\\end{equation}\n", "\n", "Define:\n", "\n", "\\begin{equation}\n", "S(d) = d^Tg(x_k) + \\frac{1}{2}d^TH(x_k)d\n", "\\end{equation}\n", "\n", "Then:\n", "\n", "\\begin{equation}\n", "\\nabla S(d) = 0\n", "\\end{equation}\n", "\n", "So we will have:\n", "\n", "\\begin{equation}\n", "g^k + H^kd = 0\n", "\\end{equation}\n", "\n", "\\begin{equation}\n", "H^kd = -g^k\n", "\\end{equation}\n", "\n", "## Modified Newton method \n", "\n", "In Newton method we have:\n", "\n", "\\begin{equation}\n", "d^k = -H^{k^{-1}}g^k\n", "\\end{equation}\n", "\n", "To find the minumum value of $f$ in direction $d$ and around point $x^k$, line search method can be applied. In 'Line search' method, we would like our direction to be direction of descent:\n", "\n", "\\begin{equation}\n", "\\Longrightarrow f'_{d^k}=\\:\\:<0\\:\\:\\Longrightarrow \\:\\:g^{k^T}H^{k^{-1}}g^k\\:\\:>0\n", "\\end{equation}\n", "\n", "Therefore $H^{k^{-1}}$ or $H^k$ should be positive semidefinite:\n", "\n", "\\begin{equation}\n", "H^k \\succeq 0\n", "\\end{equation}\n", "\n", "But sometimes $H^k \\nsucceq 0$, so we need to modify it in order to have no eigenvalues less than zero. As a result we will have modified Newton method:\n", "\n", "\\begin{equation}\n", "H^k + E = LDL^T \\Longrightarrow Cholesky\\:\\:modified\\:\\:factorization\n", "\\end{equation}\n", "\n", "Regarding Newton direction, we will have:\n", "\n", "\\begin{equation}\n", "LDL^Td^k = -g^k\n", "\\end{equation}\n", "\n", "In modified Newton method, Hession matrix of $f$ at point $x^k$ is modified in way that all eighen values are positive.\n", "\n", "After we find the best direction($d^k$), to minimize $f$ around the point $x^k$ we can do exact line search on direction $d^k$ or can apply Back tracking method.\n", "\n", "Exact Line search\n", "\\begin{equation}\n", "\\Longrightarrow\\alpha ^k = argmin\\:\\:f(x^k,\\alpha d^k)\n", "\\end{equation}\n", "\n", "Back tracking in exact Line search:\n", "\\begin{equation}\n", "\\Phi (\\alpha) = f(x^k+\\alpha d^k) - f(x^k)\n", "\\end{equation}\n", "\n", "\\begin{equation}\n", "\\Phi '(0) = f'_{d^k}(x^k) < 0 \\equiv c\n", "\\end{equation}\n", "\n", "\\begin{equation}\n", "0<\\sigma <1,\\:\\:\\sigma = 10^{-4}:10^{-1} \n", "\\end{equation}\n", "\n", "\\begin{equation}\n", "0<\\beta <1,\\:\\:\\beta = 0.2\n", "\\end{equation}\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "## Implementation details \n", "In this project, we implemented Fast Sesop with modified Newton method usig Back tracking search strategy. We implemented a Basis Pursuit(BP) to check the efficincy of SESOP method.\n", "Basis Pursuit is a way for decomposing a signal into a sparse superposition of\n", "dictionary elements, using $l_1-norm$ penalization. When the signal is sparse enough,\n", "it is equivalent to $l_0$ minimization, where $l_0(\\alpha)$ stands for the number of non-zero\n", "elements in $\\alpha$. BP in highly overcomplete dictionaries leads to large-scale\n", "optimization problems. The noisy signal $y$ is described as:\n", "\n", "\\begin{equation}\n", "y=x+n\n", "\\end{equation}\n", "\n", "where $x$ is the original signal, and $n$ is Gaussian noise with\n", "variance $σ_n^2$\n", ". We assume signal $x$ can be represented as linear combination of some basis(dictionary), $x=Ac$( $c$ is the cofficents and $A$ is the basis matrix).\n", "\n", "The MAP estimation for the coefficients is achieved by maximizing the log-likelihood:\n", "\\begin{equation}\n", "min_c \\:\\:\\: 0.5\\times||Ac-y||_2^2 +\\lambda \\times||c||_1\n", "\\end{equation}\n", "\n", "Now, the aim is to find coefficents $c$ and reconstruct our original signal $x$ from noisy signal $y$.\n", "\n", "\n", "The main parts of code are modified Newton optimization method and SESOP subspace constructing and updating. To use this code for other use( not Basis Pursuit), one needs to implement the cost function which returns the functions derivitev at input poit $x$ and function value at this point.\n", "\n", "## References \n", "\n", "1. Guy Narkiss and Michael Zibulevsky (2005). \"Sequential Subspace Optimization Method for Large-Scale Unconstrained Problems\", Tech. Report CCIT No 559, EE Dept., Technion.\n", "2. Stephen G. Nash, “A Survey of Truncated-Newton Methods”, Journal of Computational and Applied Mathematics, 124 (2000), pp. 45-59.\n", "3. Michael Elad, Boaz Matalon, and Michael Zibulevsky, \"Coordinate and Subspace Optimization Methods for Linear Least Squares with Non-Quadratic Regularization\", Applied and Computational Harmonic Analysis, Vol. 23, pp. 346-367, November 2007.\n", "4. M. ELAD AND M. ZIBULEVSKY, A probabilistic study of the average perfor- mance of the basis pursuit, submitted to IEEE Trans. On Information Theory, (2004)." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "#global constants\n", "global flag_is_New\n", "flag_is_New = True\n", "\n", "Nem = True #two Nemirovski directions\n", "\n", "newton_iters = 7\n", "isHess = True\n", "weights_pen = 0.01\n", "eps_smooth_abs = 0.01\n", "all_r = []\n", "sesop_iters = 200\n", "last_iters = 5\n", "sub_grad_norm = []\n", "glob_grad_norm = []\n", "\n", "#tolerance values\n", "diff_x_thresh = 1.0e-8\n", "func_thresh = 1.0e-16\n", "glob_thresh = 1.0e-8" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def mult_norm(x1, x2):\n", " return np.matmul(x1, x2)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "def mult_adj(x1, x2):\n", " return np.matmul(x1.T, x2).T" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "def l2norm(r, y, Z=0, isNew=True, nouts=1): # same as ls_fgh\n", " if isNew:\n", " l2norm.tmp = r - y\n", " o = 0.5 * np.matmul((l2norm.tmp.flatten()).T, l2norm.tmp.flatten())\n", " l2norm.f_prev = o\n", " else:\n", " o = l2norm.f_prev\n", " \n", " if nouts > 1:\n", " \n", " grad = l2norm.tmp\n", " \n", " if nouts > 2:\n", " grad = l2norm.tmp\n", " Hes = Z\n", " \n", " return o, grad, Hes\n", " \n", " return o, grad\n", "\n", " return o" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def fast_smooth_approx(x, Hes=np.array([]), isNew=True, nouts=1): #same as sum_fast_abs_smooth_new\n", " if isNew:\n", " fast_smooth_approx.out_f = True\n", " fast_smooth_approx.g_f = True\n", " fast_smooth_approx.h_f = True\n", "\n", " m = weights_pen\n", " epsilon = eps_smooth_abs\n", " \n", " if fast_smooth_approx.out_f:\n", " fast_smooth_approx.t = (1.0 / epsilon) * x\n", " fast_smooth_approx.abs_t = np.absolute(fast_smooth_approx.t)\n", " fast_smooth_approx.backup = 1.0 / (fast_smooth_approx.abs_t + 1)\n", " f = epsilon * (fast_smooth_approx.abs_t + fast_smooth_approx.backup - 1)\n", " out = m*(f.sum(axis=0))\n", " fast_smooth_approx.out_prev = out\n", " fast_smooth_approx.out_f = False\n", " else:\n", " out = fast_smooth_approx.out_prev\n", " \n", " if nouts > 1: #Gradient\n", " if fast_smooth_approx.g_f:\n", " fast_smooth_approx.tmp = fast_smooth_approx.backup * fast_smooth_approx.backup\n", " g = m * (fast_smooth_approx.t * (fast_smooth_approx.abs_t + 2) * fast_smooth_approx.tmp)\n", " fast_smooth_approx.g_old = g\n", " fast_smooth_approx.g_f = False\n", " else:\n", " g = fast_smooth_approx.g_old\n", " \n", " if nouts > 2: # Hessian-matrix product\n", " if fast_smooth_approx.h_f:\n", " fast_smooth_approx.to_f = m * (2.0/epsilon) * fast_smooth_approx.tmp * fast_smooth_approx.backup\n", " fast_smooth_approx.h_f = False\n", " \n", " if Hes.size > 0:\n", " HZ = np.expand_dims(fast_smooth_approx.to_f.flatten(), -1) * Hes\n", " else:\n", " HZ = []\n", " \n", " if nouts > 3: #diagonal of Hessian\n", " d_comp = fast_smooth_approx.to_f\n", " \n", " return out, g, HZ, d_comp\n", "\n", " return out, g, HZ\n", " \n", " return out, g\n", "\n", " return out" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "def ux_body(x, Bx, y, R, P, diff_alpha, alpha, a, costf1, costf2):\n", " global flag_is_New\n", " new_aplha = alpha + a * diff_alpha\n", " r = Bx + np.matmul(R, new_aplha)\n", " out = x + np.matmul(P, new_aplha)\n", " \n", " flag_is_New = True\n", " \n", " r_func, g2 = costf1(r, y, isNew = flag_is_New, nouts = 2)\n", " r2_func, g2_func = costf2(out, isNew = flag_is_New, nouts = 2)\n", " \n", " flag_is_New = False\n", "\n", " g_alpha = np.matmul(g2.T, R).T + np.matmul(g2_func.T, P).T\n", "\n", " return r_func + r2_func, g_alpha, new_aplha, r, out\n", "\n", "#Newton iterations\n", "\n", "def newton_body(r, R, P, x, x0, Bx, y, alpha, i, costf1, costf2):\n", " global flag_is_New\n", "\n", " first_func, first_x, new_R_mult = costf1(r, y, R, isNew = flag_is_New, nouts = 3)\n", "\n", " if isHess:\n", " second_func, second_x, new_P_mult = costf2(x, P, isNew = flag_is_New, nouts = 3)\n", " \n", " flag_is_New = False\n", " out = first_func + second_func\n", "\n", " a_g = np.matmul(first_x.T, R).T + np.matmul(second_x.T, P).T # compute a_g= R'*first_x + P'*second_x in efficient way\n", " \n", " if i == 1:\n", " sub_grad_norm.append(np.linalg.norm(a_g, 2))\n", " \n", " n_a = np.matmul(R.T, new_R_mult) + np.matmul(P.T, new_P_mult)\n", " \n", " Lambda, eig_vecs = np.linalg.eig(n_a)\n", "\n", " l = np.abs(Lambda)\n", " l = np.maximum(l, 1e-12 * np.amax(l))\n", " \n", " a_d = np.matmul(-eig_vecs, np.matmul(np.diag(1./l), np.matmul(eig_vecs.T, a_g)))\n", "\n", " f0 = out\n", " step = 1\n", " a_d_abs = np.absolute(np.matmul(a_g.T, a_d))\n", "\n", " #r, x calculations loop\n", " for j in range(0, 100):\n", "\n", " out, a_g, upd_alpha, r, x = ux_body(x0, Bx, y, R, P, a_d, alpha, step, costf1, costf2)\n", " if (out < f0) or ((out < (f0 + 1e-9 * np.maximum(np.abs(f0), 1)) ) and (np.matmul(a_g.T, a_d) <= 0.1 * a_d_abs)):\n", " break\n", " \n", " step = 0.25 * step\n", "\n", " alpha = upd_alpha\n", " all_r.append(step)\n", " sub_grad_norm.append(np.linalg.norm(a_g, 2) + 1e-20)\n", " \n", " return r, x, a_g" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def NewtonOOS(x0,y,Bx,P,R,costf1,costf2):\n", " alpha = np.zeros([P.shape[1], 1])\n", " \n", " x = x0\n", " r = Bx\n", " \n", " for i in range(0, newton_iters):\n", " u_n, x_n, a_g = newton_body(r, R, P, x, x0, Bx, y, alpha, i, costf1, costf2)\n", " \n", " if np.linalg.norm(a_g, 2) < 1e-12:\n", " break\n", "\n", " return u_n, x_n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def sesop(basis, y, coeffs, costf1, costf2, mult1, mult2):\n", " p = 0 #Previous step\n", " x0 = coeffs\n", "\n", " AC = mult1(basis, coeffs)\n", " \n", " n = np.max(coeffs.shape)\n", " m = np.max(AC.shape)\n", " P1 = np.zeros([n, 1])\n", " indP = 0 # Columns of P span the subspace of optimization\n", " R1 = np.zeros([m, 1])\n", " indR = 0 # R=AP\n", "\n", " x = coeffs\n", "\n", " for i in range(0, sesop_iters):\n", " flag_is_New = True\n", " \n", " first_norm_f, first_norm_g = costf1(AC, y, isNew=flag_is_New, nouts=2)\n", " second_norm_f, second_norm_g = costf2(x, isNew=flag_is_New, nouts=2)\n", "\n", " flag_is_New = False\n", "\n", " f = first_norm_f + second_norm_f\n", " first_grad_x = mult2(first_norm_g, basis)\n", "\n", " x_grad = first_grad_x + second_norm_g\n", "\n", " #Check stopping criteria\n", " if i > 0 and (np.linalg.norm(x - x_prev, 2) < diff_x_thresh or np.abs(f - f_old) < func_thresh or np.linalg.norm(x_grad, 2) < glob_thresh):\n", " break\n", "\n", " f_old = f\n", " d_new = -x_grad #New direction: gradient\n", "\n", " if i > 0:\n", " p = (1.0/dx_norm) * dx\n", "\n", " #r = (1.0/dx_norm) * (AC-AC_prev)\n", "\n", " r = mult1(basis, p)\n", "\n", " if last_iters > 0:\n", " indP = indP + 1\n", " if indP > last_iters:\n", " indP = 1\n", "\n", " P1[:, indP-1] = np.squeeze(p)\n", " R1[:, indP-1] = np.squeeze(r)\n", "\n", " d_new_norm = (1.0 / np.linalg.norm(d_new, 2)) * d_new\n", " Ad_new_norm = mult1(basis, d_new_norm)\n", "\n", " i2 = min(i, last_iters + 1) - 1\n", " i2 = i2 + 1\n", "\n", " if i2 == last_iters + 1:\n", " P1[:, i2-1] = np.squeeze(d_new_norm)\n", " R1[:, i2-1] = np.squeeze(Ad_new_norm)\n", " else:\n", " P1_temp = np.zeros([n, i2+1])\n", " P1_temp[:, 0:i2] = P1\n", " P1_temp[:, i2] = np.squeeze(d_new_norm) #Put normalized [preconditioned] gradient at the last free column\n", " P1 = P1_temp\n", "\n", " R1_temp = np.zeros([m, i2+1])\n", " R1_temp[:, 0:i2] = R1\n", " R1_temp[:, i2] = np.squeeze(Ad_new_norm) #Put normalized [preconditioned] gradient at the last free column\n", " R1 = R1_temp\n", "\n", " if Nem:\n", " P2 = np.zeros([n, 2])\n", " R2 = np.zeros([m, 2])\n", "\n", " if i == 0:\n", " NemWeight = 1\n", " d2Nem = -x_grad\n", " else:\n", " NemWeight=0.5 + np.sqrt(0.25 + NemWeight ** 2)\n", " d2Nem = d2Nem - NemWeight * x_grad\n", "\n", " d1Nem = x - x0\n", " Ad1Nem = mult1(basis, d1Nem)\n", "\n", " tmp = 1.0/(np.linalg.norm(d1Nem, 2) + 1e-20)\n", "\n", " P2[:, 0] = np.squeeze(tmp * d1Nem)\n", " R2[:, 0] = np.squeeze(tmp * Ad1Nem)\n", "\n", " Ad2Nem = mult1(basis, d2Nem)\n", " tmp = 1.0/(np.linalg.norm(d2Nem, 2) + 1e-20)\n", "\n", " P2[:, 1] = np.squeeze(tmp * d2Nem)\n", " R2[:, 1] = np.squeeze(tmp * Ad2Nem)\n", "\n", " if i == 0:\n", " P2 = tmp * d2Nem\n", " R2 = tmp * Ad2Nem\n", "\n", " #p=(1/dx_norm)*dx\n", "\n", " x_prev = x\n", " AC_prev = AC\n", "\n", " P = np.concatenate([P1, P2], axis=1)\n", " R = np.concatenate([R1, R2], axis=1)\n", "\n", " AC, x = NewtonOOS(x_prev, y, AC_prev, P, R, costf1, costf2)\n", "\n", " flag_is_New = True\n", "\n", " AC = mult1(basis, x)\n", "\n", " dx = x - x_prev #If TN, (x_prev+d_tn) - current approx. minimizer of quadratic model\n", " dx_norm = np.linalg.norm(dx, 2) + 1e-30\n", "\n", " glob_grad_norm.append(np.linalg.norm(x_grad, 2))\n", " \n", " return x, AC, f" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", "\n", "def plotting(x, y, A, n1, c00):\n", " plt.figure(1)\n", " plt.plot(y[0:50], label='original')\n", " plt.plot(np.matmul(A, x)[0:50]-20, label='reconstructed')\n", " plt.title('Orignal and reconstructed signal')\n", " plt.legend(loc='best')\n", "\n", " plt.figure(2)\n", " plt.plot(np.arange(0, n1), c00[0:n1], label='original')\n", " plt.plot(np.arange(0, n1), x[0:n1]-3, label='reconstructed')\n", " plt.title('Coefficients')\n", " plt.legend(loc='best')\n", "\n", " plt.figure(3)\n", " plt.title('Norm of gradients')\n", " plt.semilogy(glob_grad_norm)\n", "\n", " plt.figure(4)\n", " plt.title('Norm of subspace gradient with Newton iterations')\n", " plt.semilogy(sub_grad_norm)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#main for Basic Pursuit\n", "from scipy.linalg import hadamard\n", "from scipy.sparse import random\n", "import numpy as np\n", "\n", "n = 2 ** 8\n", "n1 = n\n", "sparsity = 0.1\n", "sigma_noise = 0.5\n", "k = 2 * n\n", "\n", "A = np.hstack([hadamard(n), np.eye(n)])\n", "#A = hadamard(n)\n", "\n", "c00 = np.sign(random(k, 1, density = sparsity, data_rvs = np.random.randn).A) # generate original vector of coefficients\n", "x00 = np.matmul(A, c00)\n", "y = x00 + sigma_noise*np.random.randn(n, 1)\n", "c0 = np.random.rand(c00.shape[0], c00.shape[1])\n", "\n", "x, u, _ = sesop(A, y, c0, l2norm, fast_smooth_approx, mult_norm, mult_adj)\n", "plotting(x, y, A, n1, c00)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "#globals for NN\n", "quadrpenpar = 1e-1\n", "nneurons = 10\n", "eps_sigmoid = 0.7\n", "N_of_train_samples = 260" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "def quadr(x, Z=np.array([]), isNew=True, nouts=1):\n", "\n", " m = quadrpenpar\n", " out = 0.5 * m * np.matmul(x.flatten().T, x.flatten())\n", " \n", " if nouts > 1:\n", " grad = m * x\n", "\n", " if nouts > 2:\n", " Hess = m * Z\n", "\n", " if nouts > 3:\n", " diag_elems = m * np.ones( ((x.flatten()).size(), 1) )\n", " \n", " return out, grad, Hess, diag_elems\n", " \n", " return out, grad, Hess\n", " \n", " return out, grad\n", " \n", " return out\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "def sigmoid(t, eps, isNew=True, nouts=1):\n", " if isNew:\n", " sigmoid.f_state = 1\n", " sigmoid.diff_state = 1\n", " sigmoid.f2_state = 1\n", " \n", " p = 1.0 / eps\n", " \n", " if sigmoid.f_state:\n", " sigmoid.pt = p * t\n", " u = np.abs(sigmoid.pt) # sigmoid is a derivative of out = eps.*(u-log(1+u))\n", " sigmoid.normed_u = 1.0 / (1 + u)\n", " out = sigmoid.pt * sigmoid.normed_u\n", "\n", " sigmoid.out_prev = out\n", " sigmoid.f_state = 0\n", " else:\n", " out = sigmoid.out_prev\n", " \n", " if nouts > 1:\n", " if sigmoid.diff_state:\n", " sigmoid.u2 = sigmoid.normed_u * sigmoid.normed_u\n", " diff = p * sigmoid.u2\n", " sigmoid.diff_prev = diff\n", " sigmoid.diff_state = 0\n", " else:\n", " diff = sigmoid.diff_prev\n", " \n", " if nouts > 2:\n", " if sigmoid.f2_state:\n", " diff2 = (-2 * p**2) * np.sign(sigmoid.pt) * sigmoid.u2 * sigmoid.normed_u\n", " sigmoid.diff2_prev = diff2\n", " sigmoid.f2_state = 0\n", " else:\n", " diff2 = sigmoid.diff2_prev\n", " \n", " return out, diff, diff2\n", " \n", " return out, diff\n", " \n", " return out" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "def weight_norm(V, y, Z=0, isNew=True, nouts=1):\n", " M = nneurons\n", " K = N_of_train_samples\n", " \n", " b_index = list(range(M * (K + 1) + 1, M * (K+2) + 1))\n", " v_index = list(range(0, M))\n", "\n", " c_index = M\n", "\n", " v = V[v_index]\n", " c = V[c_index]\n", " u = V[M + 1 : M + 1 + M * K]\n", "\n", " U = np.reshape(u, (M, K), order='F')\n", " b = V[b_index]\n", " \n", " I_1K = np.ones((1, K))\n", " I_K1 = np.ones((K, 1))\n", " \n", " U = U + np.matmul(b, I_1K) # Add bias\n", " \n", " if nouts == 1:\n", " sigm1 = sigmoid(U, eps_sigmoid, isNew, nouts=nouts)\n", " sigm1 = np.real(sigm1)\n", " elif nouts == 2:\n", " sigm1, sigm2 = sigmoid(U, eps_sigmoid, isNew, nouts=nouts)\n", " sigm1 = np.real(sigm1)\n", " sigm2 = np.real(sigm2)\n", " elif nouts == 3:\n", " sigm1, sigm2, sigm3 = sigmoid(U, eps_sigmoid, isNew, nouts=nouts)\n", " sigm1 = np.real(sigm1)\n", " sigm2 = np.real(sigm2)\n", " sigm3 = np.real(sigm3)\n", "\n", " L = np.matmul(v.T, sigm1).T + c - np.expand_dims(y.flatten(), -1)\n", " out = 0.5 * np.matmul(L.flatten().T, L.flatten())\n", " out = np.real(out)\n", " \n", " if nouts > 1:\n", " v_on_L = np.matmul(v, L.T)\n", " U_grad = v_on_L * sigm2\n", " grad_b = np.matmul(U_grad, I_K1)\n", " grad_out = np.vstack((np.matmul(sigm1, L), L.sum(axis = 0), np.expand_dims(U_grad.flatten(), -1), grad_b))\n", " grad_out = np.real(grad_out)\n", " \n", " if nouts > 2:\n", " J = Z.shape[1]\n", " Hess = np.zeros_like(Z)\n", " \n", " for j in range(0, J):\n", " z_v = np.expand_dims(Z[v_index, j], -1)\n", " z_c = np.expand_dims(Z[c_index, j], -1)\n", " z_b = np.expand_dims(Z[b_index, j], -1)\n", "\n", " z_u = Z[M + 1 : M + 1 + M * K, j]\n", " \n", " Z_u = np.reshape(z_u, U.shape, order='F') + z_b * I_1K\n", " Phi1Z_u = sigm2 * Z_u\n", " diff = (np.matmul(z_v.T, sigm1) + I_1K*z_c + np.matmul(v.T, Phi1Z_u)).T\n", " diff = np.real(diff)\n", "\n", " Hess_u = (np.matmul(z_v, L.T) + np.matmul(v, diff.T)) * sigm2 + v_on_L * sigm3 * Z_u\n", "\n", " Hess[0 : M, j] = np.squeeze(np.matmul(Phi1Z_u, L) + np.matmul(sigm1, diff))\n", " Hess[M + 1, j] = np.sum(diff, axis = 0)\n", " Hess[M + 1 : -M, j] = Hess_u.flatten()\n", " Hess[b_index, j] = np.squeeze(np.matmul(Hess_u, I_K1))\n", " Hess = np.real(Hess)\n", " \n", " return out, grad_out, Hess\n", " \n", " return out, grad_out\n", " \n", " return out" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "def layer(x2, x1):\n", " M = nneurons\n", " v = x1[0 : M]\n", " c = x1[M]\n", " w = x1[M + 1 : x1.shape[0]-M]\n", " b = x1[x1.shape[0]-M:]\n", "\n", " N, K = x2.shape # matrix x2: N inputs (including ones) x2 K examples\n", "\n", " W = np.reshape(w, (nneurons, N), order='F')\n", " U = np.matmul(W, x2)\n", " return np.vstack((v, c, np.expand_dims(U.flatten(), -1), b))" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "def layer_transp(vcu, X):\n", " M = nneurons\n", " K = N_of_train_samples\n", " \n", " indv = list(range(0, M))\n", " indc = M\n", " indb = list(range((M * (K + 1) + 1), (M * (K + 2) +1)))\n", "\n", " v = vcu[indv]\n", " c = vcu[indc]\n", " b = vcu[indb]\n", " u = vcu[M + 1 : M + 1 + M * K]\n", " U = np.reshape(u, (M, K), order='F')\n", " \n", " W = np.matmul(U, X.T)\n", " return np.vstack((v, c, np.expand_dims(W.flatten(), -1), b))" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "def NURALNETWORK(x1, X):\n", " N, K = X.shape\n", " M = nneurons\n", "\n", " M = nneurons\n", " v = x1[0 : M]\n", " c = x1[M]\n", " w = x1[M + 1 : x1.shape[0]-M]\n", " b = x1[x1.shape[0]-M:]\n", " \n", " W = np.reshape(w, (M, N), order='F')\n", " \n", " Phi = sigmoid(np.matmul(W, X) + np.matmul(b, np.ones((1,K))), eps_sigmoid)\n", " y = np.matmul(v.T, Phi) + c\n", " return y" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:48: ComplexWarning: Casting complex values to real discards the imaginary part\n", "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:49: ComplexWarning: Casting complex values to real discards the imaginary part\n", "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:63: ComplexWarning: Casting complex values to real discards the imaginary part\n", "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:68: ComplexWarning: Casting complex values to real discards the imaginary part\n", "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:87: ComplexWarning: Casting complex values to real discards the imaginary part\n", "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:88: ComplexWarning: Casting complex values to real discards the imaginary part\n", "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:93: ComplexWarning: Casting complex values to real discards the imaginary part\n", "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:94: ComplexWarning: Casting complex values to real discards the imaginary part\n", "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:64: ComplexWarning: Casting complex values to real discards the imaginary part\n", "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:66: ComplexWarning: Casting complex values to real discards the imaginary part\n", "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:67: ComplexWarning: Casting complex values to real discards the imaginary part\n", "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:58: ComplexWarning: Casting complex values to real discards the imaginary part\n", "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:59: ComplexWarning: Casting complex values to real discards the imaginary part\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "(5.989755357604896+0j)\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "SigT = 300 # Signal length: the same for training and test signal\n", "delta = 20 #Half-interval around the reconstructed sample to be fed into NN;\n", "sigma_noise = 0.2 #Noise std in simulated data\n", "\n", "tt = np.arange(0.02, 1.02, 1.0/SigT).T #Time running from 0 to 1\n", "\n", "S00Train = np.expand_dims(np.cumsum(np.full((SigT, 1), 0.1 * np.random.randn(SigT, 1) )) + 3 * np.sin(20 * tt), -1) # bumps + sinusoid\n", "NoiseTrain = sigma_noise * np.random.randn(SigT, 1)\n", "SnoisyTrain = S00Train + NoiseTrain\n", "\n", "S00Test = np.expand_dims(np.cumsum(np.full((SigT, 1), 0.1 * np.random.randn(SigT, 1) )) + 2 * np.sin(10 * tt), -1)\n", "NoiseTset = sigma_noise * np.random.randn(SigT, 1)\n", "SnoisyTest = S00Test + NoiseTset\n", "\n", "K = SigT - 2 * delta #Number of training examples\n", "L = 2 * delta + 1 #Interval around the reconstructed sample to be feed into NN;\n", "\n", "#Traini dataset\n", "\n", "Xtrain = np.zeros((L, K))\n", "ytrain = np.zeros((1, K))\n", "\n", "k = -1\n", "for t in range(delta, SigT - delta):\n", " k = k + 1\n", " Xtrain[0 : L, k] = np.squeeze(SnoisyTrain[t - delta:t + delta + 1] - SnoisyTrain[t])\n", " ytrain[0, k] = NoiseTrain[t]\n", "\n", "#Test set \n", "\n", "Xtest = np.zeros((L, K))\n", "ytest = np.zeros((1, K))\n", "\n", "k = -1\n", "for t in range(delta, SigT - delta):\n", " k = k + 1\n", " Xtest[0 : L, k] = np.squeeze(SnoisyTest[t - delta:t + delta + 1] - SnoisyTest[t])\n", " ytest[0, k] = SnoisyTest[t]\n", "\n", "M = nneurons\n", "N = Xtrain.shape[0]\n", "\n", "v0 = (1.0/np.sqrt(M))*np.random.randn(M, 1)\n", "c0 = 0\n", "W0 = (1.0/np.sqrt(N))*np.random.randn(M, N)\n", "b0 = 0.1*np.random.randn(M, 1)\n", "vcwb0 = np.vstack((v0, c0, np.expand_dims(W0.flatten(), -1), b0))\n", "vcwb = vcwb0\n", "\n", "Wbc, _, ff = sesop(Xtrain, ytrain, vcwb0, weight_norm, quadr, layer, layer_transp)\n", "Wbc = np.real(Wbc)\n", "print(ff)\n", "\n", "S_train = SnoisyTrain[delta:SigT-delta] - NURALNETWORK(Wbc, Xtrain).T\n", "S_pred_Test = SnoisyTest[delta:SigT-delta] - NURALNETWORK(Wbc, Xtest).T\n", "\n", "plt.figure(1)\n", "plt.plot(S_train, label='train')\n", "plt.plot(S00Train[delta:SigT-delta], label='recon train')\n", "plt.legend()\n", "\n", "plt.figure(2)\n", "plt.plot(S00Test[delta:SigT-delta], label='test')\n", "plt.plot(S_pred_Test, label='pred_nois')\n", "plt.legend()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And also we implemented SESOP for neural network cost function optimization, to clean a signal from noise. The figures above shows the result of this denoising algorithm. The architecture was one hidden layer with 10 neurons in it. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.4" } }, "nbformat": 4, "nbformat_minor": 2 }