{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Name: **Your name here** \n", "UID: **Your student ID num here**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Homework 2: More Linear Algebra " ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# Setup the environment - do not modify this cell, but run it before anything else\n", "import numpy as np\n", "from scipy.signal import convolve2d\n", "from scipy.linalg import hilbert\n", "from numpy.random import randn, normal\n", "from numpy.linalg import norm, inv\n", "from numpy.fft import fft2, ifft2\n", "import urllib\n", "import matplotlib.pyplot as plt\n", "np.random.seed(0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Problem 1 - condition number\n", "Run the following code. " ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Recovery error (clean) = 1.63e-06\n", "measurement error = 1.79e-07\n", "Recovery error (noisy) = 178.930\n" ] } ], "source": [ "# Do not modify this block!\n", "# Create a linear system Ax=b\n", "n=8\n", "A = hilbert(n) # construct an n by n matrix\n", "x = randn(n,1) # construct n by 1 signal \n", "b = A@x # Note that '@' is matrix multiplication in python, while '*' denotes entry-wise multiplication\n", "\n", "# Solve the system to recover x\n", "x_recovered = inv(A)@b \n", "print('Recovery error (clean) = %0.3g'%norm(x_recovered-x))\n", "\n", "# Add some noise\n", "b_noise = b+randn(n,1)*0.0000001\n", "print('measurement error = %0.3g'%norm(b_noise-b))\n", "\n", "# Solve the noisy system\n", "x_noise = inv(A)@b_noise\n", "print('Recovery error (noisy) = %0.3f'%norm(x_noise-x))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Why did this happen? Write a few sentence.\n", "*Put your work here*\n", "\n", "The condition number of $A$ is very large. When you invert $A$, you noise blows up by a factor of $\\kappa,$ resulting in a solution that is noise dominated." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In general, suppose that I want to solve $Ax=b$ to find $x$, but I have noisy measurements $\\hat b.$ To do this, I compute $\\hat x = A^{-1} \\hat b.$ \n", "**Prove the following**\n", "$$\\frac{\\|x-\\hat x\\|}{\\|x\\|} \\le \\kappa \\frac{\\|b-\\hat b\\|}{\\|b\\|},$$\n", "where $\\kappa$ is the condition number of $A.$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Proof\n", " $$\\|\\hat x-x \\| = \\|A^{-1}\\hat b -A^{-1}b\\| \\le \\|A^{-1}\\| \\|\\hat b -b\\|.$$\n", " Also, \n", " $$\\|A\\| \\|x\\| \\ge \\|b\\|.$$\n", " Dividing the top inequality by the bottom yields\n", " $$\\frac{\\|\\hat x-x \\|}{\\|A\\| \\|x\\|} \\le \\frac{\\|A^{-1}\\| \\|\\hat b -b\\|}{\\|b\\|},$$\n", " which re-arranges to the desired result." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Problem 2 - Adjoints\n", "Suppose you have two functions, A an At that each implement linear operators. Write a *randomized* method for checking whether At is the adjoint of A. Your test should directly verify the definition of the adjoint\n", " $$\\langle A(x), y \\rangle = \\langle x, At(y)\\rangle$$\n", "where $\\langle \\cdot,\\cdot \\rangle$ denotes the Hermitian inner product. When $x$ and $h$ happen to be column vectors, this condition becomes\n", " $$A(x)^H y = x^H At(y)$$\n", " where $x^H$ is the Hermitian transpose of $x.$\n", " The arguments of the checker method are the functions A and At, and a tuple containing the dimensions of the argument to A. The method returns True if the methods are adjoints of one another, and False otherwise.\n", " \n", " Your method must work for inputs $x$ of any dimension and shape.\n", " Note: If you choose to use the numpy transpose operator in your solution, remember that this built in operator is not the Hermitian transpose - It's just a regular transpose without taking the conjugate." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def check_adjoint(A,At,dims):\n", " # start with this line - create a random input for A()\n", " x = normal(size=dims)+1j*normal(size=dims)\n", " Ax = A(x)\n", " y = normal(size=Ax.shape)+1j*normal(size=Ax.shape)\n", " Aty = At(y)\n", " # compute the Hermitian inner products\n", " inner1 = np.sum(np.conj(Ax)*y)\n", " inner2 = np.sum(np.conj(x)*Aty)\n", " # report error\n", " rel_error = np.abs(inner1-inner2)/np.maximum(np.abs(inner1),np.abs(inner2))\n", " if rel_error < 1e-10:\n", " print('Adjoint Test Passed, rel_diff = %s'%rel_error)\n", " return True\n", " else:\n", " print('Adjoint Test Failed, rel_diff = %s'%rel_error)\n", " return False" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "After filling in the body of your method, run this unit test to make sure it's ok." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Adjoint Test Failed, rel_diff = 0.99995\n", "Adjoint Test Passed, rel_diff = 3.0552317883369726e-16\n", "Adjoint Test Passed, rel_diff = 5.925851089833151e-16\n", "Tests PASSED! You're on your way to understanding linear operators!\n" ] } ], "source": [ "# Adjoint unit test - DO NOT MODIFY THIS BLOCK\n", "# This method will throw a nasty exception if your code doesn't perform as expected\n", "\n", "# Test #1: This test should fail because the standard DFT is not self adjoint\n", "A = lambda x: fft2(x)\n", "At = lambda x: ifft2(x)\n", "result = check_adjoint(A,At,(100,200))\n", "assert (not result), \"Adjoint test should have failed, but succeeded! Double check your solution!\" # Throw an exception if the result is unexpected\n", "\n", "# Test #2: This test should pass though, because F^H = conj(F). \n", "A = lambda x: fft2(x)\n", "At = lambda x: np.conj(fft2(np.conj(x)))\n", "result = check_adjoint(A,At,(100,200))\n", "assert result, \"Adjoint test should have succeeded, but failed! Double check your solution!\" # Throw an exception if the result is unexpected\n", "\n", "# Test #3: Make sure your method works with linear operators that output a different size than their inputs\n", "M = randn(10,5)\n", "A = lambda x: M@x\n", "At = lambda x: M.T@x\n", "result = check_adjoint(A,At,(5,8))\n", "assert result, \"Adjoint test should have succeeded, but failed! Double check your solution!\" # Throw an exception if the result is unexpected\n", "\n", "\n", "print(\"Tests PASSED! You're on your way to understanding linear operators!\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Problem 3 - Convolutions\n", "When computing total variation, you need to produce the image gradient, which containts the horizontal and vertical differences between adjacent pixels in a 2d array.\n", "Choose the kernels below so that the methods gradh and gradv produce differences (discrete gradients) in the horizontal and vertical directions. Remember that convolve2d assumes the middle element of the kernel (array index 1 for a kernel of length 3) is the center of the kernel. This differs from standard convolutions, in which array index 0 is the center of the kernel.\n", "\n", "Output i,j of the horizontal gradients should contain x[i,j+1]-x[i,j], while the veritical graident should contain x[i+1,j]-x[i,j]." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# Put your kernels here! \n", "kernel_h = [[1,-1,0]] \n", "kernel_v = [[1],[-1],[0]]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "** Now, run the cell below. It will create the gradient operators using your kernels, and unit test them. Do NOT modify any of the code in the cell below.**" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "TESTS PASSED! YOU ROCK!\n" ] } ], "source": [ "# Do not modify ANYTHING in this cell. \n", "def gradh(x):\n", " \"\"\"Discrete gradient/difference in horizontal direction\"\"\"\n", " return convolve2d(x,kernel_h, mode='same', boundary='wrap')\n", "def gradv(x):\n", " \"\"\"Discrete gradient/difference in vertical direction\"\"\"\n", " return convolve2d(x,kernel_v, mode='same', boundary='wrap')\n", "def grad2d(x):\n", " \"\"\"The full gradient operator: compute both x and y differences and return them all. The x and y \n", " differences are stacked so that rval[0] is a 2D array of x differences, and rval[1] is the y differences.\"\"\"\n", " return np.stack([gradh(x),gradv(x)])\n", "\n", "# Perform unit tests - this will throw exceptions if your method is screwed up!\n", "x = randn(10,20)\n", "ghx = gradh(x)\n", "assert ghx[0,0] == x[0,1] - x[0,0], 'Failed test 1'\n", "assert ghx[0,-1] == x[0,0] - x[0,-1], 'Failed test 2'\n", "assert ghx[1,1] == x[1,2] - x[1,1], 'Failed test 3'\n", "gvx = gradv(x)\n", "assert gvx[0,0] == x[1,0] - x[0,0], 'Failed test 4'\n", "assert gvx[-1,0] == x[0,0] - x[-1,0], 'Failed test 5'\n", "assert gvx[1,1] == x[2,1] - x[1,1], 'Failed test 6'\n", "print('TESTS PASSED! YOU ROCK!')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Now, implement the adjoint/transpose of these operators!** No looping allowed! Your implementation of gradht and gradvt must call convolve2d exactly once. Ideally, you'll only write 1 line of code per line." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# Your work here: fill in the implementations of these functions\n", "def gradht(x):\n", " \"\"\"Adjoint of gradh\"\"\"\n", " kernel_ht = [[0,-1,1]] \n", " return convolve2d(x,kernel_ht, mode='same', boundary='wrap')\n", "def gradvt(x):\n", " \"\"\"Adjoint of gradv\"\"\"\n", " kernel_vt = [[0],[-1],[1]]\n", " return convolve2d(x,kernel_vt, mode='same', boundary='wrap')\n", "def divergence2d(x):\n", " \"The methods is the adjoint of grad2d.\"\n", " return gradht(x[0])+gradvt(x[1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**After writing the adjoint routines, run the unit test below!**" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Adjoint Test Passed, rel_diff = 2.542717181643103e-16\n", "Adjoint Test Passed, rel_diff = 1.0633148430239133e-16\n", "Adjoint Test Passed, rel_diff = 1.0355040823076723e-16\n", "Unit tests PASSED! You're getting really good at this!\n" ] } ], "source": [ "is_pass = check_adjoint(gradh, gradht,(10,20))\n", "assert is_pass, 'Your gradht method is not the adjoint of gradh.'\n", "\n", "is_pass = check_adjoint(gradv, gradvt,(10,20))\n", "assert is_pass, 'Your gradvt method is not the adjoint of gravh.'\n", "\n", "is_pass = check_adjoint(grad2d, divergence2d,(10,20))\n", "assert is_pass, 'Your divergence2d method is not the adjoint of grad2d.'\n", "\n", "print(\"Unit tests PASSED! You're getting really good at this!\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Problem 4 - FFT \n", "Now, re-implement these methods using the FFT!\n", "Your code must call np.fft.fft2() and np.fft.ifft2(x), and you cannot call convolve2d. No loops allowed! Remember, when you convolve things using the FFT, you're relying on the convolution theorem. This theorem assumes the center of the kernel is at index 0. Also, we're using the 2D DFT here rather than the 1D DFT from your last homework. All the basic ideas still apply. " ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def gradh_fft(x):\n", " \"\"\"Discrete gradient/difference in horizontal direction\"\"\"\n", " fft_kernel_h = np.zeros(x.shape) \n", " fft_kernel_h[0,0] = -1\n", " fft_kernel_h[0,-1] = 1\n", " Fx = fft2(x)\n", " Fk = fft2(fft_kernel_h)\n", " return ifft2(Fx*Fk)\n", "def gradv_fft(x):\n", " \"\"\"Discrete gradient/difference in vertical direction\"\"\"\n", " fft_kernel_v = np.zeros(x.shape) \n", " fft_kernel_v[0,0] = -1\n", " fft_kernel_v[-1,0] = 1\n", " Fx = fft2(x)\n", " Fk = fft2(fft_kernel_v)\n", " return ifft2(Fx*Fk)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Now, run the unit tests below!**" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Horizontal error = 8.61433786536898e-14\n", "Vertical error = 8.54345073528387e-14\n", "Tests PASSED! Wow - you're a linear algebra GENIUS!\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "