From 4321ef5cb4080a0f573cad9af86250c615dcebac Mon Sep 17 00:00:00 2001 From: Francis Date: Fri, 22 Apr 2022 13:54:21 -0400 Subject: [PATCH] add tutorial thanks to weave --- examples/intro_joli.jl | 184 +++++++++++++++ tutorials/intro_joli.ipynb | 446 +++++++++++++++++++++++++++++++++++++ 2 files changed, 630 insertions(+) create mode 100644 examples/intro_joli.jl create mode 100644 tutorials/intro_joli.ipynb diff --git a/examples/intro_joli.jl b/examples/intro_joli.jl new file mode 100644 index 0000000..8f59197 --- /dev/null +++ b/examples/intro_joli.jl @@ -0,0 +1,184 @@ +#' +#' # Introduction to JOLI +#' +#' [JOLI.jl](https://github.com/slimgroup/JOLI.jl) is a Julia framework for constructing matrix-free linear operators with explicit domain/range type control and applying them in basic algebraic matrix-vector operations. This notebook mainly covers 3 things: +#' +#' 1. How to build a linear operator in JOLI, and verify its correctness. +#' 2. How to solve a linear inverse problem $Ax=b$ where $A$ is a linear operator defined by JOLI. +#' 3. How JOLI interacts with machine learning toolbox [Flux.jl](https://github.com/FluxML/Flux.jl) and optimization toolbox [Optim.jl](https://github.com/JuliaNLSolvers/Optim.jl) via [ChainRules.jl](https://github.com/JuliaDiff/ChainRules.jl). +#' #' +#' ## Build a linear operator +#' #' +#' We start by loading a few packages. +#' +#+ + +using LinearAlgebra, FFTW, JOLI, JOLI4Flux, PyPlot, Random, IterativeSolvers, GenSPGL, Test; +using JOLI4Flux, Optim, Zygote, ChainRulesCore, Flux; +Random.seed!(4321); + +#' +#' The JOLI toolbox gives a way to represent matrices implicitly. Instead of storing all entries in a matrix, JOLI only needs to store the forward and adjoint actions of this matrix on a vector, and the metadata (domain/range types etc). This is quite important when working with large-scale linear systems, where the linear operator can only be stored in a matrix-free way to fit into memory. +#' #' +#' For example, we can construct a convolution operator given its kernel $w$ via JOLI toolbox. We first set up the convolution kernel as below +#' +#+ + +t = 0:.001:2'; # time interval +N = length(t); # length +w = (1 .-2*1e3*(t .-.2).^2).*exp.(-1e3*(t .-.2).^2); # convolution kernel +figure();plot(t, w);title("convolution kernel w");xlabel("time [s]"); + +#' +#' We know that convolution can be computed easily thanks to Fourier transform---i.e., +#' +#' $$\mathcal{F}(w\ast x) = \mathcal{F}(w)\cdot \mathcal{F}(x),$$ +#' +#' where $\mathcal{F}$ denotes the Fourier transform, $\ast$ denotes convolution, and $\cdot$ denotes element-wise multiplication. Therefore, we can use the pre-defined linear operators in JOLI (`joDFT` for Fourier transform and `joDiag` for diagonal matrix) to construct the convolution operator `A` as +#' +#+ + +F = joDFT(N; DDT=Float64, RDT=ComplexF64); +W = joDiag(fft(w); DDT=ComplexF64, RDT=ComplexF64); +A = F' * W * F; + +#' +#' In general, JOLI provides a variety of linear operators that are frequently used in the scientific computing community, such as restriction operators, compressive sensing matrices, Fourier/wavelet transforms etc to name only a few. If you want to use common linear operators, we suggest you first check the [JOLI reference guide](https://slimgroup.github.io/JOLI.jl/) to find pre-existing ones. In case you want to define something exotic enough that doesn’t exist yet in the JOLI package, you can still construct your own JOLI operator by providing the forward and adjoint actions of the operator. The code block below is a dummy example to demonstrate how to build a linear operator of dense matrix (although there is already `joMatrix` to do this): +#' +#+ + +M = randn(N, N) +M1 = joLinearFunctionFwd(N, N, # input and output size + x -> M * x, # forward evaluation + x -> transpose(M) * x, # transpose evaluation + x -> adjoint(M) * x, # adjoint evaluation + x -> conj(M) * x, # conjugate evaluation + Float64, Float64; name="DIYOp"); # domain and range types, operator name + +#' +#' We can access the types of domain/range and size of `M1` via native julia functions +#' +#+ + +println("size(M1) is ", size(M1)) +println("domain type is ", deltype(M1)) +println("range type is ", reltype(M1)) + +#' +#' After we define the linear operator `M1`, we should verify its correctness by linearity test and adjoint test +#' +#+ + +a1 = randn(Float64, N); +a2 = randn(Float64, N); +@test isapprox(M1 * a1 + M1 * a2, M1 * (a1 + a2)); # linearity test +@test isapprox(dot(a1, M1 * a2), dot(M1' * a1, a2)); # adjoint(dot) test + +#' +#' JOLI also provides these testing functions so that it generates the testing vectors and runs the test for you +#' +#+ + +@test islinear(M1)[1]; +@test isadjoint(M1)[1]; + +#' +#' In case you've built your own JOLI operator and you find this operator is generally applicable to a broader community, we highly encourage you to open a pull request to add your DIY operator in JOLI. +#' #' +#' ## Solve $Ax=b$ with the built linear operator +#' #' +#' Now we have successfully defined a convolution operator `A` with JOLI toolbox. We can then solve a linear inverse problem +#' +#' $$Ax=b$$ +#' +#' using iterative solvers. In this tutorial, we set up a ground truth `x` as a sparse vector, and use 2 iterative methods to solve for `x`---[LSQR](https://iterativesolvers.julialinearalgebra.org/stable/linear_systems/lsqr/) and [spgl1](https://friedlander.io/spgl1/). Notice that these iterative methods only require the forward and adjoint evaluations of `A`, which are both provided by our JOLI operator. Thanks to the power of abstraction in Julia, we do not need to overload these iterative algorithms. These julia native algorithms work out of the box. +#' +#+ + +# set up the ground truth x +k = 20; +x = zeros(N); +x[rand(1:N, k)] = randn(k); +figure();plot(t, x);title("ground truth x");xlabel("time [s]"); + +#' +#' We then generate a noisy measurement `b` via perturbing the forward evaluation by a noise term `e`. +#' +#+ + +e = 1e-3 * randn(N); # noise +b = A * x + e; # noisy measurement + +#' +#' Then we can first solve for `x` using LSQR in IterativeSolvers.jl package +#' +#+ + +x1 = lsqr(A, b; maxiter=500); +figure();plot(t, x1);title("solution from LSQR");xlabel("time [s]"); + +#' +#' We can see the recovery is somehow noisy because the convolution operator has a null space and LSQR searches for a minimal 2-norm solution. Since the ground truth signal is sparse, we can use spgl1 algorithm to solve for `x`, which pursues a sparse solution. +#' +#+ + +x2, _, _, _ = spgl1(A, b, options = spgOptions(iterations=500, verbosity=0)); +figure();plot(t, x2);title("solution from spgl1");xlabel("time [s]"); + +#' +#' We can see that spgl1 produces a sparse solution as expected. Notice again that we did not provide a matrix to these algorithms, but a linear operator equipped with forward and adjoint evaluations. `lsqr` and `spgl1` algorithms work right away without any modification. +#' #' +#' ## Automatic differentiation (AD) through the linear operator +#' #' +#' Furthermore, we have the package [JOLI4Flux](https://github.com/slimgroup/JOLI4Flux.jl) that "teaches" Julia how to differentiate through the linear operator---i.e., "teaches" Julia to apply the adjoint of the linear operator during back-propagation. Taking advantage of this AD capability, we can solve the inverse problem $Ax=b$ via different regularization techniques and different objective functions. Since the gradient is provided by AD, we can use any kind of gradient-based optimization algorithm to acquire the solution. In the following example, we adopt a least-squares objective with an $\ell_1$ penalty as +#' +#' $$\min_{x}\frac{1}{2} \|Ax-b\|_2^2 + \lambda \|x\|_1$$ +#' +#' and we use L-BFGS algorithm from [Optim.jl](https://github.com/JuliaNLSolvers/Optim.jl) package to iteratively invert the linear system. +#' +#+ + +λ = 1; # weight on l1 regularization +loss(x) = .5 * norm(A * x - b)^2 + λ * norm(x,1); # objective function +δloss!(g, x) = begin g.=gradient(loss, x)[1]; return loss(x) end; # in-place gradient function +summary = optimize(loss, δloss!, zeros(N), LBFGS(), Optim.Options(iterations=500)); +figure();plot(t, summary.minimizer);title("L-BFGS w/ 1-norm penalty");xlabel("time [s]"); + +#' +#' Linear operators in JOLI also talk to deep neural networks in Flux very effectively with the help of JOLI4Flux. We can also reparameterize the input `x` by a network `f` with a fixed input `z` and solve for the network parameters instead---i.e., +#' +#' $$\min_{\theta}\|Af_{\theta}(z)-b\|_2^2.$$ +#' +#' This is so-called deep prior approach discussed in [Ulyanov, Dmitry, Andrea Vedaldi, and Victor Lempitsky. "Deep image prior." Proceedings of the IEEE conference on computer vision and pattern recognition. 2018](https://arxiv.org/abs/1711.10925). It has also been adopted into scientific computing and computational geoscience community, where `A` is PDE-based linear operator, such as in [Siahkoohi, Ali, Gabrio Rizzuti, and Felix J. Herrmann. "Deep Bayesian inference for seismic imaging with tasks." arXiv preprint arXiv:2110.04825 (2021)](https://arxiv.org/abs/2110.04825). +#' +#' In this tutorial, we adopt a dense layer as a very simple deep prior network for demonstrative purpose only. In practice, the deep prior approach might need careful choices on the network structure and regularization parameters. Thanks to the abstraction, we can still write very clean code to interact with Flux and work with optimizers in Flux, such as ADAM. +#' +#+ + +f = Dense(2*N, N); # a very simple network +z = randn(2*N); # fixed input +Flux.trainmode!(f, true); +θ = Flux.params(f); # network parameters + +# Optimizer +opt = ADAM(1f-4) +for j=1:500 + grads = gradient(θ) do + return .5 * norm(A * f(z) - b)^2 + norm(f(z), 1) + norm(θ)^2; + end + + # Update params + for p in θ + Flux.Optimise.update!(opt, p, grads[p]) + end +end + + +#+ + +Flux.testmode!(f, true); +figure();plot(t, f(z));title("deep prior solution");xlabel("time [s]"); + +#' +#' Thanks to the abstraction power of Julia, multiphysics data-driven framework can be written in a quite clean way in Julia, and can be inverted thanks to the AD capability. More information is available at [Louboutin, Mathias, et al. "Accelerating innovation with software abstractions for scalable computational geophysics." arXiv preprint arXiv:2203.15038 (2022)](https://arxiv.org/pdf/2203.15038.pdf). +#' \ No newline at end of file diff --git a/tutorials/intro_joli.ipynb b/tutorials/intro_joli.ipynb new file mode 100644 index 0000000..5a3c5b8 --- /dev/null +++ b/tutorials/intro_joli.ipynb @@ -0,0 +1,446 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Introduction to JOLI\n", + "\n", + "[JOLI.jl](https://github.com/slimgroup/JOLI.jl) is a Julia framework for constructing matrix-free linear operators with explicit domain/range type control and applying them in basic algebraic matrix-vector operations. This notebook mainly covers 3 things:\n", + "\n", + "1. How to build a linear operator in JOLI, and verify its correctness.\n", + "2. How to solve a linear inverse problem $Ax=b$ where $A$ is a linear operator defined by JOLI.\n", + "3. How JOLI interacts with machine learning toolbox [Flux.jl](https://github.com/FluxML/Flux.jl) and optimization toolbox [Optim.jl](https://github.com/JuliaNLSolvers/Optim.jl) via [ChainRules.jl](https://github.com/JuliaDiff/ChainRules.jl)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Build a linear operator" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by loading a few packages." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "using LinearAlgebra, FFTW, JOLI, JOLI4Flux, PyPlot, Random, IterativeSolvers, GenSPGL, Test;\n", + "using JOLI4Flux, Optim, Zygote, ChainRulesCore, Flux;\n", + "Random.seed!(4321);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The JOLI toolbox gives a way to represent matrices implicitly. Instead of storing all entries in a matrix, JOLI only needs to store the forward and adjoint actions of this matrix on a vector, and the metadata (domain/range types etc). This is quite important when working with large-scale linear systems, where the linear operator can only be stored in a matrix-free way to fit into memory." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For example, we can construct a convolution operator given its kernel $w$ via JOLI toolbox. We first set up the convolution kernel as below" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAHHCAYAAAB3K7g2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAA9hAAAPYQGoP6dpAABMJklEQVR4nO3de3hU1b3/8c9kkkwSQhIoIQGMBLTcFRBKRKXiIRLQg+JRREVBDqLlkFqltpWfrUg9ivagoi1KtQK2RwXvtoJRROIVRbmcihe8gVAwAUSSkEAuM+v3RzI7M2QymUAGZm/fr+fJI9mz98za2Wg+rvVda7mMMUYAAAA2EXe8GwAAANAahBcAAGArhBcAAGArhBcAAGArhBcAAGArhBcAAGArhBcAAGArhBcAAGArhBcAAGArhBcALbr66quVm5vb5u/rcrl02223tfn7tuTqq69WamrqMf/ctjBy5EiNHDnyeDcDOK4ILwCiauXKlccloABwrvjj3QAAzrZy5UotXLgwZIA5ePCg4uP5zxCA1qHnBcBxk5SU5MjwcujQIfl8vuPdDMCxCC9AlO3cuVPTpk1T165d5fF41KNHD82YMUM1NTXWOV9//bUmTJigjh07KiUlRaeffrpWrFgR9D7FxcVyuVx66qmndMcdd+iEE05QUlKSRo0apS+//NI6r7CwUKmpqaqqqmrSlssvv1zZ2dnyer3WsQcffFD9+/eXx+NR165dNXPmTO3fvz/sPfnbUlxcHHR827ZtcrlcWrp0qaT62pKFCxdKqq9v8X/5hap52bhxo8aOHau0tDSlpqZq1KhReu+994LOWbp0qVwul9555x3NmjVLmZmZateunS666CLt2bMnbNubs2nTJmVmZmrkyJE6cOCApPpn95//+Z/KysqSx+NR//79tXjx4pA/i2XLlum3v/2tunXrppSUFJWXl1u1NTt37tT48eOVmpqqzMxM3XTTTUHPQJJ8Pp8WLFig/v37KykpSVlZWbruuuv0/ffft/pe/uM//kOnnXZa0LFx48bJ5XLp73//u3Xs/fffl8vl0ssvv9zqzwCOJ+f9Lw8QQ3bt2qVhw4Zp//79uvbaa9WnTx/t3LlTzzzzjKqqqpSYmKjS0lKdccYZqqqq0vXXX68f/ehHeuyxx3TBBRfomWee0UUXXRT0nnfddZfi4uJ00003qaysTH/4wx80adIkvf/++5KkiRMnauHChVqxYoUmTJhgXVdVVaV//OMfuvrqq+V2uyVJt912m+bOnav8/HzNmDFDW7Zs0UMPPaQPPvhA77zzjhISEo7q/q+77jrt2rVLq1at0t/+9rcWz//44481YsQIpaWl6de//rUSEhL05z//WSNHjtQbb7yhvLy8oPN//vOfq0OHDpozZ462bdumBQsWqLCwUMuXL29VOz/44AMVFBRo6NChevHFF5WcnKzS0lKdfvrpcrlcKiwsVGZmpl5++WVNmzZN5eXluuGGG4Le4/bbb1diYqJuuukmVVdXKzExUZLk9XpVUFCgvLw8zZ8/X6+99pruuecenXTSSZoxY0bQz2rp0qWaOnWqrr/+em3dulV/+tOftHHjxlY/ixEjRujFF19UeXm50tLSZIzRO++8o7i4OL311lu64IILJElvvfWW4uLidOaZZ7bq5wUcdwZA1EyePNnExcWZDz74oMlrPp/PGGPMDTfcYCSZt956y3qtoqLC9OjRw+Tm5hqv12uMMWbNmjVGkunbt6+prq62zr3//vuNJPPRRx9Z79utWzdz8cUXB33eU089ZSSZN9980xhjzO7du01iYqIZPXq09RnGGPOnP/3JSDKLFy+2jk2ZMsV0797d+t7fljVr1gR9xtatW40ks2TJEuvYzJkzTXP/qZFk5syZY30/fvx4k5iYaL766ivr2K5du0z79u3NT3/6U+vYkiVLjCSTn59v/RyNMebGG280brfb7N+/P+TnBd5Pu3btjDHGvP322yYtLc2cf/755tChQ9Y506ZNM126dDF79+4Nuvayyy4z6enppqqqKuhn0bNnT+tY4OdIMr///e+Djg8ePNgMGTLE+v6tt94ykszjjz8edF5RUVGT42effbY5++yzw97fBx98YCSZlStXGmOM+ec//2kkmQkTJpi8vDzrvAsuuMAMHjw47HsBsYhhIyBKfD6fXnjhBY0bN05Dhw5t8rp/+GTlypUaNmyYzjrrLOu11NRUXXvttdq2bZs++eSToOumTp1q/V+9VP9/2VL90JP/fSdMmKCVK1dawx+StHz5cnXr1s36nNdee001NTW64YYbFBfX+J+C6dOnKy0trcmwVbR5vV69+uqrGj9+vHr27Gkd79Kli6644gq9/fbbKi8vD7rm2muvDRqGGjFihLxer7755puIPnPNmjUqKCjQqFGj9Nxzz8nj8UiSjDF69tlnNW7cOBljtHfvXuuroKBAZWVl2rBhQ9B7TZkyRcnJySE/52c/+1nQ9yNGjLCelyQ9/fTTSk9P17nnnhv0WUOGDFFqaqrWrFkT0f34DR48WKmpqXrzzTcl1fewnHDCCZo8ebI2bNigqqoqGWP09ttvW39/ADshvABRsmfPHpWXl2vAgAFhz/vmm2/Uu3fvJsf79u1rvR7oxBNPDPq+Q4cOkhRUGzFx4kQdPHjQqm84cOCAVq5cqQkTJli/7P3ve/hnJyYmqmfPnhEHgLayZ88eVVVVNfuz8Pl82rFjR9DxSH4WzTl06JDOP/98DR48WE899VRQINyzZ4/279+vhx9+WJmZmUFfU6dOlSTt3r076P169OgR8nOSkpKUmZnZpJ2Bbfziiy9UVlamzp07N/m8AwcONPmslrjdbg0fPlxvvfWWpPrwMmLECJ111lnyer1677339Mknn2jfvn2EF9gSNS+AzfjrVQ5njLH+fPrppys3N1dPPfWUrrjiCv3jH//QwYMHNXHixDZpQ2BvR6DDi1CjLZKfRXM8Ho/OO+88vfjiiyoqKtK///u/W6/5ZwpdeeWVmjJlSsjrTz311KDvm+t1aa6NgXw+nzp37qzHH3885OuHh59InHXWWbrjjjt06NAhvfXWW7rllluUkZGhAQMG6K233lJWVpYkEV5gS4QXIEoyMzOVlpamzZs3hz2ve/fu2rJlS5Pjn332mfX6kbj00kt1//33q7y8XMuXL1dubq5OP/30oM+VpC1btgQN09TU1Gjr1q3Kz89v9r39PRyHz0oK1VvTXNA5XGZmplJSUpr9WcTFxSknJyei94qEy+XS448/rgsvvFATJkzQyy+/bK1cm5mZqfbt28vr9Yb9ObSVk046Sa+99prOPPPMZkNQa40YMUI1NTV68skntXPnTiuk/PSnP7XCS69evawQA9gJw0ZAlMTFxWn8+PH6xz/+oQ8//LDJ6/7egfPOO0/r1q3T2rVrrdcqKyv18MMPKzc3V/369Tuiz584caKqq6v12GOPqaioSJdeemnQ6/n5+UpMTNQDDzwQ1FPx6KOPqqysTOeff36z7929e3e53W6rpsLvwQcfbHJuu3btJDUNOodzu90aPXq0XnzxRW3bts06XlpaqieeeEJnnXWW0tLSwr5HayUmJuq5557TT37yE40bN07r1q2z2nLxxRfr2WefDRk+j3Q6dnMuvfRSeb1e3X777U1eq6ura/FnF0peXp4SEhJ09913q2PHjurfv7+k+lDz3nvv6Y033qDXBbZFzwsQRXfeeadeffVVnX322br22mvVt29fffvtt3r66af19ttvKyMjQzfffLOefPJJjR07Vtdff706duyoxx57TFu3btWzzz4bVEzbGqeddppOPvlk3XLLLaqurm4yZJSZmanZs2dr7ty5GjNmjC644AJt2bJFDz74oH7yk5/oyiuvbPa909PTNWHCBP3xj3+Uy+XSSSedpJdeeilkbcaQIUMkSddff70KCgrkdrt12WWXhXzf//7v/9aqVat01lln6b/+678UHx+vP//5z6qurtYf/vCHI/o5tCQ5OVkvvfSS/u3f/k1jx47VG2+8oQEDBuiuu+7SmjVrlJeXp+nTp6tfv37at2+fNmzYoNdee0379u1rszacffbZuu666zRv3jxt2rRJo0ePVkJCgr744gs9/fTTuv/++3XJJZe06j1TUlI0ZMgQvffee9YaL1J9z0tlZaUqKysJL7Cv4zjTCfhB+Oabb8zkyZNNZmam8Xg8pmfPnmbmzJlB052/+uorc8kll5iMjAyTlJRkhg0bZl566aWg9/FPyX366aeDjoeanux3yy23GEnm5JNPbrZ9f/rTn0yfPn1MQkKCycrKMjNmzDDff/990DmHT5U2xpg9e/aYiy++2KSkpJgOHTqY6667zmzevLlJW+rq6szPf/5zk5mZaVwuV9C0aR02VdoYYzZs2GAKCgpMamqqSUlJMeecc4559913g87xT5U+fAp6c1O4Dxc4Vdpv7969pl+/fiY7O9t88cUXxhhjSktLzcyZM01OTo5JSEgw2dnZZtSoUebhhx9u8pmHP5fmPscYY+bMmRNy+vjDDz9shgwZYpKTk0379u3NKaecYn7961+bXbt2WedEMlXa71e/+pWRZO6+++6g4yeffLKRFDQlHbATlzERVLYBAADECGpeAACArRBeAACArRBeAACArRBeAACArRBeAACArRBeAACArThukTqfz6ddu3apffv2ES9LDgAAji9jjCoqKtS1a9cWF+d0XHjZtWtXm+5/AgAAjp0dO3bohBNOCHuO48JL+/btJdXffFvvgwIAAKKjvLxcOTk51u/xcBwXXvxDRWlpaYQXAABsJpKSDwp2AQCArRBeAACArRBeAACArRBeAACArRBeAACArRBeAACArRBeAACArRBeAACArRBeAACArRBeAACArUQ1vLz55psaN26cunbtKpfLpRdeeKHFa4qLi3XaaafJ4/Ho5JNP1tKlS6PZRAAAYDNRDS+VlZUaOHCgFi5cGNH5W7du1fnnn69zzjlHmzZt0g033KBrrrlGr7zySjSbCQAAbCSqGzOOHTtWY8eOjfj8RYsWqUePHrrnnnskSX379tXbb7+t++67TwUFBdFqpqPVen2Kc7nkjmt5oysAAOwgpmpe1q5dq/z8/KBjBQUFWrt2bbPXVFdXq7y8POgL9fZUVGv4vNX6z6UfHO+mAADQZmIqvJSUlCgrKyvoWFZWlsrLy3Xw4MGQ18ybN0/p6enWV05OzrFoqi0UfVyivQdq9Mbne1Rafuh4NwcAgDYRU+HlSMyePVtlZWXW144dO453k2LG95U11p//9X3VcWwJAABtJ6o1L62VnZ2t0tLSoGOlpaVKS0tTcnJyyGs8Ho88Hs+xaJ7t7AsILyVl1cexJQAAtJ2Y6nkZPny4Vq9eHXRs1apVGj58+HFqkb19FxBeyg/VHseWAADQdqIaXg4cOKBNmzZp06ZNkuqnQm/atEnbt2+XVD/kM3nyZOv8n/3sZ/r666/161//Wp999pkefPBBPfXUU7rxxhuj2UzH2lfZ2Nty4FDdcWwJAABtJ6rh5cMPP9TgwYM1ePBgSdKsWbM0ePBg3XrrrZKkb7/91goyktSjRw+tWLFCq1at0sCBA3XPPffoL3/5C9Okj9B3Bxp7XiqqCS8AAGeIas3LyJEjZYxp9vVQq+eOHDlSGzdujGKrfjgqAnpb6HkBADhFTNW8oG1V1QSEl2pqXgAAzkB4cbCDtV7rzwcYNgIAOAThxaF8PqNDtT7r+wqGjQAADkF4cajAXheJ8AIAcA7Ci0MdHl4OHfY9AAB2RXhxqIM1hBcAgDMRXhyqac+Lr5kzAQCwF8KLQ1Ud1vNSXUfPCwDAGQgvDuUfNvLE1z9iel4AAE5BeHGog7X1s4s6pCRKkg7VecOudgwAgF0QXhzK39OSnpwgSTJGqvUSXgAA9kd4caiauvrwkpbcuH3VIepeAAAOQHhxqBpvfXhJ9cTL5ao/xnRpAIATEF4cyt/zkhgfZxXtVlO0CwBwAMKLQzWGF7eSEtySmC4NAHAGwotD+YeNEt1xTJcGADgK4cWhGnteXPS8AAAchfDiUFZ4oecFAOAwhBeHsoaN4uOU2BBear2EFwCA/RFeHCpwtlGC2x9eWKQOAGB/hBeHqraGjdwB4YWeFwCA/RFeHCqw5yWR8AIAcBDCi0PVegOHjeqX2PUHGgAA7Izw4lChal5q6HkBADgA4cWhGhepcynBP9uInhcAgAMQXhwqdM0Ls40AAPZHeHGomqDZRg01LwwbAQAcgPDiUNUsUgcAcCjCi0OFXqSO8AIAsD/Ci0PVNGzCmOim5gUA4CyEF4eq8YaYKs1sIwCAAxBeHKq2rr6XJdHNsBEAwFkILw4V1PMSXz/biPACAHACwotDsc4LAMCpCC8OxfYAAACninp4WbhwoXJzc5WUlKS8vDytW7cu7PkLFixQ7969lZycrJycHN144406dOhQtJvpKMYYK6gkuF0U7AIAHCWq4WX58uWaNWuW5syZow0bNmjgwIEqKCjQ7t27Q57/xBNP6Oabb9acOXP06aef6tFHH9Xy5cv1//7f/4tmMx3HFzA6lBDXuKs0NS8AACeIani59957NX36dE2dOlX9+vXTokWLlJKSosWLF4c8/91339WZZ56pK664Qrm5uRo9erQuv/zyFntrECwwpLjdLlbYBQA4StTCS01NjdavX6/8/PzGD4uLU35+vtauXRvymjPOOEPr16+3wsrXX3+tlStX6rzzzmv2c6qrq1VeXh709UPnDeh6iY9rHDbyT58GAMDO4qP1xnv37pXX61VWVlbQ8aysLH322Wchr7niiiu0d+9enXXWWTLGqK6uTj/72c/CDhvNmzdPc+fObdO2211dUHhpnG1EwS4AwAliarZRcXGx7rzzTj344IPasGGDnnvuOa1YsUK33357s9fMnj1bZWVl1teOHTuOYYtjU11ASImPcymBYSMAgINEreelU6dOcrvdKi0tDTpeWlqq7OzskNf87ne/01VXXaVrrrlGknTKKaeosrJS1157rW655RbFxTXNWh6PRx6Pp+1vwMb8w0ZxLikuzkXBLgDAUaLW85KYmKghQ4Zo9erV1jGfz6fVq1dr+PDhIa+pqqpqElDcbrek+um/iIx/2Ci+4WfJInUAACeJWs+LJM2aNUtTpkzR0KFDNWzYMC1YsECVlZWaOnWqJGny5Mnq1q2b5s2bJ0kaN26c7r33Xg0ePFh5eXn68ssv9bvf/U7jxo2zQgxaVtcQUtxx9T0urPMCAHCSqIaXiRMnas+ePbr11ltVUlKiQYMGqaioyCri3b59e1BPy29/+1u5XC799re/1c6dO5WZmalx48bpjjvuiGYzHafOVx9S4t3B4YVhIwCAE7iMw8ZjysvLlZ6errKyMqWlpR3v5hwXX5RW6Nz73lSHlARtvHW0vtxdofx731RGSoI23Tr6eDcPAIAmWvP7O6ZmG6Ft1FrDRvWP11/7UkfNCwDAAQgvDuSfbeSfZeSvffEPJwEAYGeEFweqbQgphxfs0vMCAHACwosDea2p0vXhxV+4W+czTDkHANge4cWB/D0s8W5/zYvLei1w3yMAAOyI8OJA1lRpq+clLuA1wgsAwN4ILw7kDyj+mpfAnhfWegEA2B3hxYG8DBsBAByM8OJAhw8buYN6XggvAAB7I7w4UN1hs41cLpf1Z3peAAB2R3hxIGuqtLuxx8X/Z2peAAB2R3hxoMO3B5CkBP8WAfS8AABsjvDiQN6GmpeEgFoXt9sV9BoAAHZFeHGgw6dKS42bM1KwCwCwO8KLAzWusNsYXvybNLK/EQDA7ggvDtQ426jx8bKzNADAKQgvDuQ9bJ0XKWBnaQp2AQA2R3hxoMbZRgEFu3FMlQYAOAPhxYEa13lpfLwsUgcAcArCiwMdvsKuFDBsRMEuAMDmCC8OVNcwNMSwEQDAiQgvDuQfGkoIMVWaYSMAgN0RXhwo1PYA1iJ1hBcAgM0RXhzI2h4gxMaMdQwbAQBsjvDiQKG3B3AFvQYAgF0RXhzI2h4gMLww2wgA4BCEFweqC7POC9sDAADsjvDiQKG2B6DnBQDgFIQXB6oNW/NCzwsAwN4ILw7k9YYbNqLnBQBgb4QXBwq1PQDDRgAApyC8OJB/aCjksBHrvAAAbI7w4kChtgewFqlj2AgAYHOEFweqC7E9gLWrNOEFAGBzhBcHqgsxVZpdpQEATkF4caBQBbsJcewqDQBwhqiHl4ULFyo3N1dJSUnKy8vTunXrwp6/f/9+zZw5U126dJHH41GvXr20cuXKaDfTUbzWCruBPS8Nu0oz2wgAYHPx0Xzz5cuXa9asWVq0aJHy8vK0YMECFRQUaMuWLercuXOT82tqanTuueeqc+fOeuaZZ9StWzd98803ysjIiGYzHafW2tsoYJ0XdpUGADhEVMPLvffeq+nTp2vq1KmSpEWLFmnFihVavHixbr755ibnL168WPv27dO7776rhIQESVJubm40m+hIobYH8M88YtgIAGB3URs2qqmp0fr165Wfn9/4YXFxys/P19q1a0Ne8/e//13Dhw/XzJkzlZWVpQEDBujOO++U1+tt9nOqq6tVXl4e9PVDVxdiewBr2IjwAgCwuaiFl71798rr9SorKyvoeFZWlkpKSkJe8/XXX+uZZ56R1+vVypUr9bvf/U733HOP/vu//7vZz5k3b57S09Otr5ycnDa9DzuqC7E9QALDRgAAh4ip2UY+n0+dO3fWww8/rCFDhmjixIm65ZZbtGjRomavmT17tsrKyqyvHTt2HMMWxyZvqO0B4ljnBQDgDFGreenUqZPcbrdKS0uDjpeWlio7OzvkNV26dFFCQoLcbrd1rG/fviopKVFNTY0SExObXOPxeOTxeNq28TbnX8uF7QEAAE4UtZ6XxMREDRkyRKtXr7aO+Xw+rV69WsOHDw95zZlnnqkvv/xSPl/jL9jPP/9cXbp0CRlcEFrj9gAhZhvR8wIAsLmoDhvNmjVLjzzyiB577DF9+umnmjFjhiorK63ZR5MnT9bs2bOt82fMmKF9+/bpF7/4hT7//HOtWLFCd955p2bOnBnNZjpOqIJddpUGADhFVKdKT5w4UXv27NGtt96qkpISDRo0SEVFRVYR7/bt2xUXsBZJTk6OXnnlFd1444069dRT1a1bN/3iF7/Qb37zm2g203H8Q0PxoYaNfAwbAQDsLarhRZIKCwtVWFgY8rXi4uImx4YPH6733nsvyq1ytroQK+zGW3sb0fMCALC3mJpthLbRONuoac0Li9QBAOyO8OIwxpjQNS/W3kYMGwEA7I3w4jCBPSsJgcNGzDYCADgE4cVhAsNJqJ4Xho0AAHZHeHGYuqCel8bH62a2EQDAIQgvDuP1hu55sXaVZrYRAMDmCC8OE9izEh+0qzQ1LwAAZyC8OEzgTCOXi40ZAQDOQ3hxmFDTpKWA2UZMlQYA2BzhxWH8NS3xh4eXOBapAwA4A+HFYWp9Tfc1khp7YmoJLwAAmyO8OIy1NYA7+NH6p03T8wIAsDvCi8P4l/8/vObFHTBsZAwBBgBgX4QXh/H3rCQ0U/MiMeMIAGBvhBeHsWYbuUP3vEgMHQEA7I3w4jB11myj0DUvEj0vAAB7I7w4TF0Ls40ktggAANgb4cVhvM0tUhfwfS2bMwIAbIzw4jD+YaOEw6ZKu1yuoBlHAADYFeHFYZrbHiDwGDUvAAA7I7w4jLeZmpfAY+xvBACwM8KLw9T6Zxu5w4QXel4AADZGeHEYa3uAuKaPNp4tAgAADkB4cZhIal5qGTYCANgY4cVh/PUsCSGGjRKYbQQAcADCi8OE7XlxU/MCALA/wovDhK15iaPmBQBgf4QXh/HXs4SabUTNCwDACQgvDtPc9gBS41Rpel4AAHZGeHGYOmvYKER4oeYFAOAAhBeHqbMWqWv6aN0NNS917CoNALAxwovDhNseoHGqNDUvAAD7Irw4TC0bMwIAHI7w4jD+YtyEEMNGVs0Lw0YAABsjvDiMP5iEnm3UUPNCzwsAwMaOSXhZuHChcnNzlZSUpLy8PK1bty6i65YtWyaXy6Xx48dHt4EOUtdQz5IQdqo0NS8AAPuKenhZvny5Zs2apTlz5mjDhg0aOHCgCgoKtHv37rDXbdu2TTfddJNGjBgR7SY6SuP2AKFmG1HzAgCwv6iHl3vvvVfTp0/X1KlT1a9fPy1atEgpKSlavHhxs9d4vV5NmjRJc+fOVc+ePaPdREfxWlOlQ8w2cjNVGgBgf1ENLzU1NVq/fr3y8/MbPzAuTvn5+Vq7dm2z1/3+979X586dNW3atBY/o7q6WuXl5UFfP2S1YaZK0/MCAHCCqIaXvXv3yuv1KisrK+h4VlaWSkpKQl7z9ttv69FHH9UjjzwS0WfMmzdP6enp1ldOTs5Rt9vOItsegJoXAIB9xdRso4qKCl111VV65JFH1KlTp4iumT17tsrKyqyvHTt2RLmVsS3c9gCNGzPS8wIAsK/4aL55p06d5Ha7VVpaGnS8tLRU2dnZTc7/6quvtG3bNo0bN8465vMPg8THa8uWLTrppJOCrvF4PPJ4PFFovT3VWbtKh1rnpf4YGzMCAOwsqj0viYmJGjJkiFavXm0d8/l8Wr16tYYPH97k/D59+uijjz7Spk2brK8LLrhA55xzjjZt2vSDHxKKhDfcxozUvAAAHCCqPS+SNGvWLE2ZMkVDhw7VsGHDtGDBAlVWVmrq1KmSpMmTJ6tbt26aN2+ekpKSNGDAgKDrMzIyJKnJcYRWF8n2AF5qXgAA9hX18DJx4kTt2bNHt956q0pKSjRo0CAVFRVZRbzbt29XXIg1SXBk/NOgQ20PkOD2F+zS8wIAsK+ohxdJKiwsVGFhYcjXiouLw167dOnStm+Qg/lX2A3d88L2AAAA+6PLw2EiqXmh5wUAYGeEF4eptVbYbX5X6VpqXgAANkZ4cRh6XgAATkd4cRhrkboQextR8wIAcALCi8P4p0GH2x6AqdIAADsjvDhM47BR8zUv9LwAAOyM8OIw1q7SIYaNqHkBADgB4cVhvN5wGzPWP242ZgQA2BnhxWHCbQ8Qb62wS80LAMC+CC8O4w8vobYHYGNGAIATEF4cJtxsIzc1LwAAByC8OEy4Rer8vTF11LwAAGyM8OIwtb7mtwdwW8NG1LwAAOyL8OIwbA8AAHA6wouDGGOsYBJ6thFTpQEA9kd4cZDAWUQJoVbYpecFAOAAhBcHCQwl7pAbM1LzAgCwP8KLgwT2vISreWGdFwCAnRFeHCRwt+iQ4YWp0gAAByC8OEhgj0rIgl1qXgAADkB4cZDAadIuV7iaF8ILAMC+CC8OUhtmawBJSnBTsAsAsD/Ci4OEW6BOktwN06e91LwAAGyM8OIgdWG2BpCYbQQAcAbCi4P4ZxE11/MSz7ARAMABCC8O4g8lzdW8ULALAHACwouD+HteEpodNqo/bozkI8AAAGyK8OIgdWE2ZTz8OL0vAAC7Irw4SEuzjRLcgeGFuhcAgD0RXhzEvz1AfIhNGSV6XgAAzkB4cZDGYaPwNS8Sa70AAOyL8OIg/mGjhDA9L/5dA2oZNgIA2BThxUFa2h5AYnNGAID9EV4cpKWCXSlgrReGjQAANkV4cRBre4Bmal4kKaHhNQp2AQB2RXhxEP/05+ZmG0mS2+0fNqLmBQBgT8ckvCxcuFC5ublKSkpSXl6e1q1b1+y5jzzyiEaMGKEOHTqoQ4cOys/PD3s+GvmHgiKpeaHnBQBgV1EPL8uXL9esWbM0Z84cbdiwQQMHDlRBQYF2794d8vzi4mJdfvnlWrNmjdauXaucnByNHj1aO3fujHZTbc8bwbCR/zVqXgAAdhX18HLvvfdq+vTpmjp1qvr166dFixYpJSVFixcvDnn+448/rv/6r//SoEGD1KdPH/3lL3+Rz+fT6tWro91U26ttTcEuPS8AAJuKanipqanR+vXrlZ+f3/iBcXHKz8/X2rVrI3qPqqoq1dbWqmPHjiFfr66uVnl5edDXD5XXP1U6TM1LPDUvAACbi2p42bt3r7xer7KysoKOZ2VlqaSkJKL3+M1vfqOuXbsGBaBA8+bNU3p6uvWVk5Nz1O22K39vSgJTpQEADhbTs43uuusuLVu2TM8//7ySkpJCnjN79myVlZVZXzt27DjGrYwdLW0PIDFVGgBgf/HRfPNOnTrJ7XartLQ06Hhpaamys7PDXjt//nzdddddeu2113Tqqac2e57H45HH42mT9tpdqxapI7wAAGwqqj0viYmJGjJkSFCxrb/4dvjw4c1e94c//EG33367ioqKNHTo0Gg20VH8Q0Hh1nmh5gUAYHdR7XmRpFmzZmnKlCkaOnSohg0bpgULFqiyslJTp06VJE2ePFndunXTvHnzJEl33323br31Vj3xxBPKzc21amNSU1OVmpoa7ebamrVIXQTrvNRS8wIAsKmoh5eJEydqz549uvXWW1VSUqJBgwapqKjIKuLdvn274gJqNB566CHV1NTokksuCXqfOXPm6Lbbbot2c23N2h7A3fI6L2zMCACwq6iHF0kqLCxUYWFhyNeKi4uDvt+2bVv0G+RQdd6We16oeQEA2F1MzzZC6zTONqLmBQDgXIQXB/FGNGxEzQsAwN4ILw7iDyThh42oeQEA2BvhxUH8Q0HsKg0AcDLCi4NY2wNEsM6Lv7gXAAC7Ibw4iH+RunDbA/h7Xhg2AgDYFeHFQSLbHoC9jQAA9kZ4cRBrhd0ww0YJDBsBAGyO8OIgdRHNNqJgFwBgb4QXB2lcpI6aFwCAcxFeHMQb0Wwjal4AAPZGeHGQWm8r1nmh5gUAYFOEFwdpnG3U/GOl5gUAYHeEFwepi2CqtH/YiJoXAIBdEV4cxD9V2h2u5oWNGQEANkd4cRD/VOmECIaN/PsgAQBgN4QXB/FaU6XZmBEA4FyEFwexal4imSrNsBEAwKYILw5ibQ8QQc8LBbsAALsivDhI4/YAkUyVpuYFAGBPhBcHqYug5sW/+i49LwAAuyK8OIg3gpoX/75HTJUGANgV4cVB/NsDUPMCAHAywouDWOu8uMPsKu2m5gUAYG+EFwexZhtFsMIuU6UBAHZFeHGQSAp2/TUvLFIHALArwotDeH1GpiGPhNsegJoXAIDdEV4cwl+sK7W0wq5/Y0ZqXgAA9kR4cYjAYaBwBbtuel4AADZHeHEIb0ABbviNGesfOeEFAGBXhBeHqA2Y+hx2nRc3u0oDAOyN8OIQjfsaueRyRTJVmpoXAIA9EV4cwlpdN0yxrhS4MSM9LwAAeyK8OIS1r1GYadJSYzEvNS8AALsivDhEJKvrSo09L0yVBgDY1TEJLwsXLlRubq6SkpKUl5endevWhT3/6aefVp8+fZSUlKRTTjlFK1euPBbNtLVab2Q9LyxSBwCwu6iHl+XLl2vWrFmaM2eONmzYoIEDB6qgoEC7d+8Oef67776ryy+/XNOmTdPGjRs1fvx4jR8/Xps3b452U23NH0YSWuh5iXezPQAAwN6iHl7uvfdeTZ8+XVOnTlW/fv20aNEipaSkaPHixSHPv//++zVmzBj96le/Ut++fXX77bfrtNNO05/+9KdoN9XW/MNA4dZ4kQJmGxFeAAA2FR/NN6+pqdH69es1e/Zs61hcXJzy8/O1du3akNesXbtWs2bNCjpWUFCgF154IeT51dXVqq6utr4vLy8/+oaHsHH797rtH5/IJcnlklyS4lyuhj/XH2h8zaW4uPp/+mctu1wu6/W4gD9LLiXGu3Rix3YalJOhc/pkyhPvbnX76qyel/B5NHCFXWNM2GnVzdl7oFqvfVKqzbvKVFJWrUO1XtV6farzGYajAOAHYPCJGZozrv9x+/yohpe9e/fK6/UqKysr6HhWVpY+++yzkNeUlJSEPL+kpCTk+fPmzdPcuXPbpsFhlB+q0//t2B/1z+mWkax7Lh2o03v+qFXXWVOlI+x5keoDTEsFvoGMMfrLW1t1z6otOlRLwS8A/FClJScc18+Pang5FmbPnh3UU1NeXq6cnJw2/5z+XdP0l8lDZVT/S7z+n4f9Wabhnw3HA481d1zSwRqvvt57QKs+KdXO/Qc1efE6PTk9T0O6d4y4fdZU6RZ6XgJfr/MZtaaT58Hir/Q/r2yRJPXrkqaze2eqW0ayUj3xine7FB8X1+KwFQDA/jq2Szyunx/V8NKpUye53W6VlpYGHS8tLVV2dnbIa7Kzs1t1vsfjkcfjaZsGh9Ep1aP8flktn3gUZo/tq+uf3KjVn+3WTU//U0U3jIh4CClwhd1wAl9vTd3Lp9+W695Vn0uSbjmvr64Z0eOIhpwAADhaUS3YTUxM1JAhQ7R69WrrmM/n0+rVqzV8+PCQ1wwfPjzofElatWpVs+c7STtPvO67bJAy23u0dW+lXty0K+JrW7vCrhS8mWNLHlj9hbw+o4L+WZr+054EFwDAcRP12UazZs3SI488oscee0yffvqpZsyYocrKSk2dOlWSNHny5KCC3l/84hcqKirSPffco88++0y33XabPvzwQxUWFka7qTEhLSlB15zVQ5L017XbIr7OKtiNcJ2X+msiq1vZXXFIr3xcX3M069zeEbcJAIBoiHp4mThxoubPn69bb71VgwYN0qZNm1RUVGQV5W7fvl3ffvutdf4ZZ5yhJ554Qg8//LAGDhyoZ555Ri+88IIGDBgQ7abGjEuH5sgd59LmneXasa8qomv84aWlmhOXy9Xq/Y1W/vNb+Yw0KCdDvbPbR3QNAADRckwKdgsLC5vtOSkuLm5ybMKECZowYUKUWxW7OrRL1LDcjlr79Xd69ZNSTWvoiQmnLsJhI6k+4Hh9JuLwsmbLHknS+ad0ieh8AACiib2NYtTI3pmSpPe//i6i8/0Fuy2t8yJJCf61XiKoean1+vTBtn2SpDNP7hRRWwAAiCbCS4wamttBkrRh+/cyJoKQ4YtsnRcpYHPGCGpeNu8sU1WNVx1SEtSHISMAQAwgvMSoAd3SleiO094DNfrmu5brXhrXeWk5vPjXeolkNdzNO8sk1de7xLGGCwAgBhBeYpQn3q2+Xep7Oj79tuUtDyLdVbr+nIaC3QiGjT5p+Oz+XdNbPBcAgGOB8BLDfpxVH162lFa0eG5rCnbjA/Y3asknu+rDS98uaS2eCwDAsUB4iWG9G8LL55GElwjXeZEktzuymhefz1jByd8LBADA8UZ4iWG9Ggpkt5RE0vPSsM5LRD0vkdW87K6o1qFan9xxLuV0TGnxfQEAOBYILzGsZ6d2kqQd+w7K10LQ8K+WmxBBUW2kNS/ffFcpqX6n60imYAMAcCzwGymGdUlPUnycSzVen0orDoU91yrYjSBkNK6wG37Y6JuG1X27/4heFwBA7CC8xLB4d5y6ZiRLkra3MF26VQW77si2B/B/5okMGQEAYgjhJcb5g8OO7w+GPc8fRCJZpM6qeWlp2IieFwBADCK8xLicjg09Ly1s0FhnrbDbinVeWup52efveWnX4nsCAHCsEF5iXLeGYaNv97fQ82LtbRT59gAt1bzsavjMEzokt/ieAAAcK4SXGNc5LUmSVFpRHfa81hTsJkSwPUCd16e9B+o/M6uhDQAAxALCS4zzB4fd5eFnG3mPYGPGcFOlv6uskTH15/6oXWKkzQUAIOoILzGuc3uPpPoF48KpbVXBbsvDRqUNYSkz1cOGjACAmEJ4iXH+npd9lTWqqWs+bDROlW7NOi/N97yUlvuHjDwRtxUAgGOB8BLjOqQkWEW4ew403/vir1+JpGA3kpqX3Q2L4nWm3gUAEGMILzHO5XKpc/uGot0wdS/+gl13JBszNvS81IapefH3vPiHrQAAiBWEFxvo3DB0E65o19rbKKKNGevP8YapefF/FjONAACxhvBiA/7eD39vSCjWVOlIFqmLYHsAfy8PPS8AgFhDeLGBzIYA8V0ENS+R7G3kjmB7gO8qayRJnVIJLwCA2EJ4sYGOKfXrrOyrqmn2HGu2USumSteG6XnZ1xBeOqayxgsAILYQXmygQ8Micd9X1jZ7TmtW2PX3zoSrefneH15SCC8AgNhCeLGBjg3hxd8bEopVsNuanpdmho0O1XpVWeOV1BicAACIFYQXG+jQ0Pvxfdhho4Z1XuIj39uo1hu652V/VX0PjzvOpbSk+Fa1FQCAaCO82EAkPS81Xv9U6ZYfaWJ8+PDi/5wOKYlyudgaAAAQWwgvNmDVvFTVyJjQQz213sjXebF6XupCv5e/h6dju4RWtxUAgGgjvNiAv2i21mt0oLou5Dn++pXESHpeWhg2Cux5AQAg1hBebCA50a3kBLek5mcc1dZFPmzk752pbia8NPa8EF4AALGH8GITVt1LM0W7Vs1LJAW7/pqXZnaptnpeCC8AgBhEeLGJDg31J983U7TbmpqXloaNWOMFABDLCC824a8/CTXjyOsz8i+WG1HNizXbKHTB7r6GqdIZKRTsAgBiD+HFJtKS64NE+aGmNS+BPSiR1bzUn1PTTM9L+cH6z0hPJrwAAGIP4cUm/EGi7GDT8FJzpOGlmZoXf0BKI7wAAGJQ1MLLvn37NGnSJKWlpSkjI0PTpk3TgQMHwp7/85//XL1791ZycrJOPPFEXX/99SorK4tWE20lLamh5+Vg06nSgYW3ka3z4t8eIHzPi/8zAQCIJVELL5MmTdLHH3+sVatW6aWXXtKbb76pa6+9ttnzd+3apV27dmn+/PnavHmzli5dqqKiIk2bNi1aTbSVcD0v1qaMca6IVsRtaYXd8kP1ASktma0BAACxJyq/nT799FMVFRXpgw8+0NChQyVJf/zjH3Xeeedp/vz56tq1a5NrBgwYoGeffdb6/qSTTtIdd9yhK6+8UnV1dYqP/2H/IvUHiXA1L5EMGUmBs41CF+zS8wIAiGVR6XlZu3atMjIyrOAiSfn5+YqLi9P7778f8fuUlZUpLS3tBx9cpMBho+ZrXiIZMqo/r/mal+o6r6objlPzAgCIRVFJBSUlJercuXPwB8XHq2PHjiopKYnoPfbu3avbb7897FCTJFVXV6u6utr6vry8vPUNtoHww0b1YSMxggXqpPCzjSoahoxcLqm9h9AIAIg9rep5ufnmm+VyucJ+ffbZZ0fdqPLycp1//vnq16+fbrvttrDnzps3T+np6dZXTk7OUX9+LPL3gvjDRaC6huGfiIeN4psv2PX37KR64hUXx47SAIDY06r/tf7lL3+pq6++Ouw5PXv2VHZ2tnbv3h10vK6uTvv27VN2dnbY6ysqKjRmzBi1b99ezz//vBISwg9dzJ49W7NmzbK+Ly8vd2SASUuqf1ThpkpHXvNSv09SqO0BrGJd6l0AADGqVeElMzNTmZmZLZ43fPhw7d+/X+vXr9eQIUMkSa+//rp8Pp/y8vKava68vFwFBQXyeDz6+9//rqSkpBY/y+PxyOPxRH4TNuUfNjpQXac6r0/xAUGlcVPGCGterJ6XpgW7VrEu9S4AgBgVlYLdvn37asyYMZo+fbrWrVund955R4WFhbrsssusmUY7d+5Unz59tG7dOkn1wWX06NGqrKzUo48+qvLycpWUlKikpERerzcazbSV9gE9IQeqg4eOals5bBRY82JMcICxFqhLot4FABCbovYb6vHHH1dhYaFGjRqluLg4XXzxxXrggQes12tra7VlyxZVVVVJkjZs2GDNRDr55JOD3mvr1q3Kzc2NVlNtITE+TskJbh2s9arsYK0yAjZNPNKC3fprjVUDIzUugkfPCwAgVkUtvHTs2FFPPPFEs6/n5uYG/V//yJEjm/QCIFh6coIO1nqbrLLb+pqXwPDiCwo9jT0vhBcAQGxibyMb8S9Ud3jRbm0r13kJDCuHzzhqrHlh2AgAEJsILzaS3szO0q1dYdcd55J/FvTha73Q8wIAiHWEFxtpbpXd2rr64bbECMOL1Pwqu9S8AABiHeHFRtKaWWXX33sSH+GwkdT8/kbMNgIAxDrCi400t0VAa4eNJCmhmZ2lWecFABDrCC820r6hN+TwLQKsqdKtCC+JzQ0bscIuACDGEV5sxB8oKpoU7LZukTopcJVdZhsBAOyF8GIj/kBRfljPi7/3JCE+8pqXZgt2mW0EAIhxhBcbaW62UXVDAPHEuyN+r1AFu9V1Xh2qrX8val4AALGK8GIjac2s81JdV7/3kyfC7QGkxp6XwGEjfy2NyyW19zBsBACITYQXG2muYPeIel7iGzdn9PP36KR64hUXF/kQFAAAxxLhxUaaHTZqGOrxJLSm56VpwS4zjQAAdkB4sRH/sFFljVd1AaHjaIaNAgt2/aGoPQvUAQBiGOHFRgJDReDQUc1RFew2rXmh5wUAEMsILzaS4I5TSmJ9QAkML401L0fQ8xIw28i/fgxrvAAAYhnhxWb8vS+BM46sYaNW1LxYBbuBw0aH/MNG9LwAAGIX4cVmQhXtHslsI38vjT/4SI29OdS8AABiGeHFZkKt9WLNNmrFsFFSQn3Q8S9KJwVsDUDPCwAghhFebCbNP2x0MLDmpfWzjZIahpgO1dLzAgCwF8KLzYTsefEPGyVEPmzU2PPSGF7KrfBCzwsAIHYRXmymsWD36GYbhQ4vzDYCAMQ+wovNhCzYrW39sJH/3MCalwp6XgAANkB4sZmoDhtZBbv0vAAAYhfhxWb8PS/+XhJjzNENG9UF9rywzgsAIPYRXmzGX4/i7yUJ3BX6aGYb+XxGB6r92wPQ8wIAiF2EF5vx94r4C3ar6wLDSyuGjRrO9dfLVNbUydewU4B/aAoAgFhEeLGZxnVe6nte/AvUuVxSgtsV8fscvkidfxgqwe1qVQ8OAADHGr+lbMbfK+KvTwlcoM7lak14aRg2arg+cF+j1rwPAADHGuHFZqyC3eo6+XzmiPY1kprONvL3vFDvAgCIdYQXm/EvUmeMdKCmTgdrWr/GixRYsOsfNmKmEQDAHggvNpOU4FZiQ1ApP1irgw09J+08resxObznxb9XEvsaAQBiHeHFhgLXeqlq6HlJbsUCdVJjeKmu88kYY/W8sKM0ACDWEV5sKHCtl6qGtVlSEo8svEj1AaacHaUBADZBeLGhtIC1Xvw9LymtHTYKqJE5VOsNmm0EAEAsI7zYkLW/0cFaVTXUrKS0ctgo3h2n+Lj6KdEHa73UvAAAbIPwYkP+gFFx6MiHjQKvqaz2an9VjSSpY7vENmolAADREbXwsm/fPk2aNElpaWnKyMjQtGnTdODAgYiuNcZo7NixcrlceuGFF6LVRNsKPWzU+vDiHyI6UF2n7xvCS0YKw0YAgNgWtfAyadIkffzxx1q1apVeeuklvfnmm7r22msjunbBggWs8hpGYMGuf6p0SmLrh3tSG+pkKqvrtL+qvualQwo9LwCA2BaVAodPP/1URUVF+uCDDzR06FBJ0h//+Eedd955mj9/vrp27drstZs2bdI999yjDz/8UF26dIlG82yvseelVgnu+vx5JMNG7Rp6ayoONfa8EF4AALEuKj0va9euVUZGhhVcJCk/P19xcXF6//33m72uqqpKV1xxhRYuXKjs7OyIPqu6ulrl5eVBX07XuL9RwLDREYSX1KBho/qeF4aNAACxLirhpaSkRJ07dw46Fh8fr44dO6qkpKTZ62688UadccYZuvDCCyP+rHnz5ik9Pd36ysnJOeJ224V//6Gyg7Uqa9hdOj259aEjtaHnZU9FtWoa9kjqQMEuACDGtSq83HzzzXK5XGG/PvvssyNqyN///ne9/vrrWrBgQauumz17tsrKyqyvHTt2HNHn24l/RtB3B2qOMrzUh6B/fV8lSUpwu9TuCHpwAAA4llpV8/LLX/5SV199ddhzevbsqezsbO3evTvoeF1dnfbt29fscNDrr7+ur776ShkZGUHHL774Yo0YMULFxcUhr/N4PPJ4PJHegiN0bp8kSdpzoFpeYyQ1DiW1Rqqn/pod3x+UJGWkJFIoDQCIea0KL5mZmcrMzGzxvOHDh2v//v1av369hgwZIqk+nPh8PuXl5YW85uabb9Y111wTdOyUU07Rfffdp3HjxrWmmY6X2b4+rO2rrJFpCC9H0vPiXy9m295KSVJHinUBADYQldlGffv21ZgxYzR9+nQtWrRItbW1Kiws1GWXXWbNNNq5c6dGjRqlv/71rxo2bJiys7ND9sqceOKJ6tGjRzSaaVsZyQmKj3OpzmesQtsj2VCxU2p9WNm+r37YqHPaD6sHCwBgT1Fb5+Xxxx9Xnz59NGrUKJ133nk666yz9PDDD1uv19bWasuWLaqqqopWExwrLs6lTqnBQSP9CGYJ/eiw98hKSzqqdgEAcCxEbSObjh076oknnmj29dzcXGvIozktvf5D1jnNo5LyQ5LqC21Tj2CRuh8dNrMoi54XAIANsLeRTWUG9Jp0SU9WXFzrC20P73nJpucFAGADhBebyumYYv25W0byEb2Hv/A31HsCABCrCC821Se7vfXnbh2OLLykJycE7SLdt0vaUbcLAIBoI7zYVL+ujUGjd1b7MGeG17NTO+vPndtT8wIAiH2EF5s6pVu6/v3ULhp8YoYuHnLCEb/Prwp6q/uPUnTHRQNYoA4AYAsu47ApPeXl5UpPT1dZWZnS0hgGAQDADlrz+5ueFwAAYCuEFwAAYCuEFwAAYCuEFwAAYCuEFwAAYCuEFwAAYCuEFwAAYCuEFwAAYCuEFwAAYCuEFwAAYCuEFwAAYCuEFwAAYCuEFwAAYCuEFwAAYCvxx7sBbc0YI6l+a20AAGAP/t/b/t/j4TguvFRUVEiScnJyjnNLAABAa1VUVCg9PT3sOS4TScSxEZ/Pp127dql9+/ZyuVxt+t7l5eXKycnRjh07lJaW1qbvHQu4P/tz+j06/f4k598j92d/0bpHY4wqKirUtWtXxcWFr2pxXM9LXFycTjjhhKh+RlpammP/UkrcnxM4/R6dfn+S8++R+7O/aNxjSz0ufhTsAgAAWyG8AAAAWyG8tILH49GcOXPk8XiOd1OigvuzP6ffo9PvT3L+PXJ/9hcL9+i4gl0AAOBs9LwAAABbIbwAAABbIbwAAABbIbwAAABb+UGHl4ULFyo3N1dJSUnKy8vTunXrwp7/9NNPq0+fPkpKStIpp5yilStXBr1ujNGtt96qLl26KDk5Wfn5+friiy+ieQstas09PvLIIxoxYoQ6dOigDh06KD8/v8n5V199tVwuV9DXmDFjon0bzWrN/S1durRJ25OSkoLOibVn2Jr7GzlyZJP7c7lcOv/8861zYun5vfnmmxo3bpy6du0ql8ulF154ocVriouLddppp8nj8ejkk0/W0qVLm5zT2n+vo6m19/jcc8/p3HPPVWZmptLS0jR8+HC98sorQefcdtttTZ5hnz59ongXzWvt/RUXF4f8O1pSUhJ0np2fYah/x1wul/r372+dEyvPcN68efrJT36i9u3bq3Pnzho/fry2bNnS4nWx8LvwBxteli9frlmzZmnOnDnasGGDBg4cqIKCAu3evTvk+e+++64uv/xyTZs2TRs3btT48eM1fvx4bd682TrnD3/4gx544AEtWrRI77//vtq1a6eCggIdOnToWN1WkNbeY3FxsS6//HKtWbNGa9euVU5OjkaPHq2dO3cGnTdmzBh9++231teTTz55LG6nidben1S/ImRg27/55pug12PpGbb2/p577rmge9u8ebPcbrcmTJgQdF6sPL/KykoNHDhQCxcujOj8rVu36vzzz9c555yjTZs26YYbbtA111wT9Mv9SP5ORFNr7/HNN9/Uueeeq5UrV2r9+vU655xzNG7cOG3cuDHovP79+wc9w7fffjsazW9Ra+/Pb8uWLUHt79y5s/Wa3Z/h/fffH3RvO3bsUMeOHZv8exgLz/CNN97QzJkz9d5772nVqlWqra3V6NGjVVlZ2ew1MfO70PxADRs2zMycOdP63uv1mq5du5p58+aFPP/SSy81559/ftCxvLw8c9111xljjPH5fCY7O9v8z//8j/X6/v37jcfjMU8++WQU7qBlrb3Hw9XV1Zn27dubxx57zDo2ZcoUc+GFF7Z1U49Ia+9vyZIlJj09vdn3i7VneLTP77777jPt27c3Bw4csI7F0vMLJMk8//zzYc/59a9/bfr37x90bOLEiaagoMD6/mh/ZtEUyT2G0q9fPzN37lzr+zlz5piBAwe2XcPaSCT3t2bNGiPJfP/9982e47Rn+PzzzxuXy2W2bdtmHYvVZ7h7924jybzxxhvNnhMrvwt/kD0vNTU1Wr9+vfLz861jcXFxys/P19q1a0Nes3bt2qDzJamgoMA6f+vWrSopKQk6Jz09XXl5ec2+ZzQdyT0erqqqSrW1terYsWPQ8eLiYnXu3Fm9e/fWjBkz9N1337Vp2yNxpPd34MABde/eXTk5Obrwwgv18ccfW6/F0jNsi+f36KOP6rLLLlO7du2CjsfC8zsSLf072BY/s1jj8/lUUVHR5N/BL774Ql27dlXPnj01adIkbd++/Ti18MgMGjRIXbp00bnnnqt33nnHOu7EZ/joo48qPz9f3bt3Dzoei8+wrKxMkpr8fQsUK78Lf5DhZe/evfJ6vcrKygo6npWV1WTs1a+kpCTs+f5/tuY9o+lI7vFwv/nNb9S1a9egv4RjxozRX//6V61evVp333233njjDY0dO1Zer7dN29+SI7m/3r17a/HixXrxxRf1v//7v/L5fDrjjDP0r3/9S1JsPcOjfX7r1q3T5s2bdc011wQdj5XndySa+3ewvLxcBw8ebJO/87Fm/vz5OnDggC699FLrWF5enpYuXaqioiI99NBD2rp1q0aMGKGKiorj2NLIdOnSRYsWLdKzzz6rZ599Vjk5ORo5cqQ2bNggqW3+uxVLdu3apZdffrnJv4ex+Ax9Pp9uuOEGnXnmmRowYECz58XK70LH7SqNtnHXXXdp2bJlKi4uDipqveyyy6w/n3LKKTr11FN10kknqbi4WKNGjToeTY3Y8OHDNXz4cOv7M844Q3379tWf//xn3X777cexZW3v0Ucf1SmnnKJhw4YFHbfz8/uheeKJJzR37ly9+OKLQTUhY8eOtf586qmnKi8vT927d9dTTz2ladOmHY+mRqx3797q3bu39f0ZZ5yhr776Svfdd5/+9re/HceWRcdjjz2mjIwMjR8/Puh4LD7DmTNnavPmzcetfqq1fpA9L506dZLb7VZpaWnQ8dLSUmVnZ4e8Jjs7O+z5/n+25j2j6Uju0W/+/Pm666679Oqrr+rUU08Ne27Pnj3VqVMnffnll0fd5tY4mvvzS0hI0ODBg622x9IzPJr7q6ys1LJlyyL6j+Dxen5Horl/B9PS0pScnNwmfydixbJly3TNNdfoqaeeatJFf7iMjAz16tXLFs8wlGHDhlltd9IzNMZo8eLFuuqqq5SYmBj23OP9DAsLC/XSSy9pzZo1OuGEE8KeGyu/C3+Q4SUxMVFDhgzR6tWrrWM+n0+rV68O+j/zQMOHDw86X5JWrVplnd+jRw9lZ2cHnVNeXq7333+/2feMpiO5R6m+Svz2229XUVGRhg4d2uLn/Otf/9J3332nLl26tEm7I3Wk9xfI6/Xqo48+stoeS8/waO7v6aefVnV1ta688soWP+d4Pb8j0dK/g23xdyIWPPnkk5o6daqefPLJoGnuzTlw4IC++uorWzzDUDZt2mS13SnPUKqfyfPll19G9D8Rx+sZGmNUWFio559/Xq+//rp69OjR4jUx87uwzUp/bWbZsmXG4/GYpUuXmk8++cRce+21JiMjw5SUlBhjjLnqqqvMzTffbJ3/zjvvmPj4eDN//nzz6aefmjlz5piEhATz0UcfWefcddddJiMjw7z44ovmn//8p7nwwgtNjx49zMGDB4/5/RnT+nu86667TGJionnmmWfMt99+a31VVFQYY4ypqKgwN910k1m7dq3ZunWree2118xpp51mfvzjH5tDhw7F/P3NnTvXvPLKK+arr74y69evN5dddplJSkoyH3/8sXVOLD3D1t6f31lnnWUmTpzY5HisPb+KigqzceNGs3HjRiPJ3HvvvWbjxo3mm2++McYYc/PNN5urrrrKOv/rr782KSkp5le/+pX59NNPzcKFC43b7TZFRUXWOS39zI611t7j448/buLj483ChQuD/h3cv3+/dc4vf/lLU1xcbLZu3Wreeecdk5+fbzp16mR2794d8/d33333mRdeeMF88cUX5qOPPjK/+MUvTFxcnHnttdesc+z+DP2uvPJKk5eXF/I9Y+UZzpgxw6Snp5vi4uKgv29VVVXWObH6u/AHG16MMeaPf/yjOfHEE01iYqIZNmyYee+996zXzj77bDNlypSg85966inTq1cvk5iYaPr3729WrFgR9LrP5zO/+93vTFZWlvF4PGbUqFFmy5Ytx+JWmtWae+zevbuR1ORrzpw5xhhjqqqqzOjRo01mZqZJSEgw3bt3N9OnTz9u/1ExpnX3d8MNN1jnZmVlmfPOO89s2LAh6P1i7Rm29u/oZ599ZiSZV199tcl7xdrz80+bPfzLf09TpkwxZ599dpNrBg0aZBITE03Pnj3NkiVLmrxvuJ/Zsdbaezz77LPDnm9M/fTwLl26mMTERNOtWzczceJE8+WXXx7bG2vQ2vu7++67zUknnWSSkpJMx44dzciRI83rr7/e5H3t/AyNqZ8anJycbB5++OGQ7xkrzzDUfUkK+vcqVn8XuhpuAAAAwBZ+kDUvAADAvggvAADAVggvAADAVggvAADAVggvAADAVggvAADAVggvAADAVggvAKKmuLhYLpdL+/fvP+af7XK55HK5lJGREdH5/ra6XK4mG+kBiC2EFwBtYuTIkbrhhhuCjp1xxhn69ttvlZ6eflzatGTJEn3++ecRnetv66WXXhrlVgE4WoQXAFGTmJio7OxsuVyu4/L5GRkZ6ty5c0Tn+tuanJwc5VYBOFqEFwBH7eqrr9Ybb7yh+++/3xp62bZtW5Nho6VLlyojI0MvvfSSevfurZSUFF1yySWqqqrSY489ptzcXHXo0EHXX3+9vF6v9f7V1dW66aab1K1bN7Vr1055eXkqLi5udTv/7//+T+ecc47at2+vtLQ0DRkyRB9++GEb/RQAHCvxx7sBAOzv/vvv1+eff64BAwbo97//vSQpMzNT27Zta3JuVVWVHnjgAS1btkwVFRX6j//4D1100UXKyMjQypUr9fXXX+viiy/WmWeeqYkTJ0qSCgsL9cknn2jZsmXq2rWrnn/+eY0ZM0YfffSRfvzjH0fczkmTJmnw4MF66KGH5Ha7tWnTJiUkJLTJzwDAsUN4AXDU0tPTlZiYqJSUFGVnZ4c9t7a2Vg899JBOOukkSdIll1yiv/3tbyotLVVqaqr69eunc845R2vWrNHEiRO1fft2LVmyRNu3b1fXrl0lSTfddJOKioq0ZMkS3XnnnRG3c/v27frVr36lPn36SFKrgg+A2EF4AXBMpaSkWMFFkrKyspSbm6vU1NSgY7t375YkffTRR/J6verVq1fQ+1RXV+tHP/pRqz571qxZuuaaa/S3v/1N+fn5mjBhQlBbANgD4QXAMXX4MI3L5Qp5zOfzSZIOHDggt9ut9evXy+12B50XGHgicdttt+mKK67QihUr9PLLL2vOnDlatmyZLrrooiO4EwDHC+EFQJtITEwMKrJtK4MHD5bX69Xu3bs1YsSIo36/Xr16qVevXrrxxht1+eWXa8mSJYQXwGaYbQSgTeTm5ur999/Xtm3btHfvXqvn5Gj16tVLkyZN0uTJk/Xcc89p69atWrdunebNm6cVK1ZE/D4HDx5UYWGhiouL9c033+idd97RBx98oL59+7ZJOwEcO4QXAG3ipptuktvtVr9+/ZSZmant27e32XsvWbJEkydP1i9/+Uv17t1b48eP1wcffKATTzwx4vdwu9367rvvNHnyZPXq1UuXXnqpxo4dq7lz57ZZOwEcGy5jjDnejQCAtuZyufT888+3eqn/q6++Wvv379cLL7wQlXYBOHr0vABwrMsvv1wnnHBCROe+9dZbSk1N1eOPPx7lVgE4WvS8AHCkL7/8UlL9cFGPHj1aPP/gwYPauXOnpPpZTC2tVwPg+CG8AAAAW2HYCAAA2ArhBQAA2ArhBQAA2ArhBQAA2ArhBQAA2ArhBQAA2ArhBQAA2ArhBQAA2ArhBQAA2Mr/B9kGxnt7+dhkAAAAAElFTkSuQmCC", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "t = 0:.001:2'; # time interval\n", + "N = length(t); # length\n", + "w = (1 .-2*1e3*(t .-.2).^2).*exp.(-1e3*(t .-.2).^2); # convolution kernel\n", + "figure();plot(t, w);title(\"convolution kernel w\");xlabel(\"time [s]\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We know that convolution can be computed easily thanks to Fourier transform---i.e.,\n", + "\n", + "$$\\mathcal{F}(w\\ast x) = \\mathcal{F}(w)\\cdot \\mathcal{F}(x),$$\n", + "\n", + "where $\\mathcal{F}$ denotes the Fourier transform, $\\ast$ denotes convolution, and $\\cdot$ denotes element-wise multiplication. Therefore, we can use the pre-defined linear operators in JOLI (`joDFT` for Fourier transform and `joDiag` for diagonal matrix) to construct the convolution operator `A` as" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "F = joDFT(N; DDT=Float64, RDT=ComplexF64);\n", + "W = joDiag(fft(w); DDT=ComplexF64, RDT=ComplexF64);\n", + "A = F' * W * F;" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In general, JOLI provides a variety of linear operators that are frequently used in the scientific computing community, such as restriction operators, compressive sensing matrices, Fourier/wavelet transforms etc to name only a few. If you want to use common linear operators, we suggest you first check the [JOLI reference guide](https://slimgroup.github.io/JOLI.jl/) to find pre-existing ones. In case you want to define something exotic enough that doesn’t exist yet in the JOLI package, you can still construct your own JOLI operator by providing the forward and adjoint actions of the operator. The code block below is a dummy example to demonstrate how to build a linear operator of dense matrix (although there is already `joMatrix` to do this):" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "M = randn(N, N)\n", + "M1 = joLinearFunctionFwd(N, N, # input and output size\n", + " x -> M * x, # forward evaluation\n", + " x -> transpose(M) * x, # transpose evaluation\n", + " x -> adjoint(M) * x, # adjoint evaluation\n", + " x -> conj(M) * x, # conjugate evaluation\n", + " Float64, Float64; name=\"DIYOp\"); # domain and range types, operator name" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can access the types of domain/range and size of `M1` via native julia functions" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "size(M1) is (2001, 2001)\n", + "domain type is Float64\n", + "range type is Float64\n" + ] + } + ], + "source": [ + "println(\"size(M1) is \", size(M1))\n", + "println(\"domain type is \", deltype(M1))\n", + "println(\"range type is \", reltype(M1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After we define the linear operator `M1`, we should verify its correctness by linearity test and adjoint test" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "a1 = randn(Float64, N);\n", + "a2 = randn(Float64, N);\n", + "@test isapprox(M1 * a1 + M1 * a2, M1 * (a1 + a2)); # linearity test\n", + "@test isapprox(dot(a1, M1 * a2), dot(M1' * a1, a2)); # adjoint(dot) test" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "JOLI also provides these testing functions so that it generates the testing vectors and runs the test for you" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "@test islinear(M1)[1];\n", + "@test isadjoint(M1)[1];" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In case you've built your own JOLI operator and you find this operator is generally applicable to a broader community, we highly encourage you to open a pull request to add your DIY operator in JOLI." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solve $Ax=b$ with the built linear operator" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we have successfully defined a convolution operator `A` with JOLI toolbox. We can then solve a linear inverse problem\n", + "\n", + "$$Ax=b$$\n", + "\n", + "using iterative solvers. In this tutorial, we set up a ground truth `x` as a sparse vector, and use 2 iterative methods to solve for `x`---[LSQR](https://iterativesolvers.julialinearalgebra.org/stable/linear_systems/lsqr/) and [spgl1](https://friedlander.io/spgl1/). Notice that these iterative methods only require the forward and adjoint evaluations of `A`, which are both provided by our JOLI operator. Thanks to the power of abstraction in Julia, we do not need to overload these iterative algorithms. These julia native algorithms work out of the box." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# set up the ground truth x\n", + "k = 20;\n", + "x = zeros(N);\n", + "x[rand(1:N, k)] = randn(k);\n", + "figure();plot(t, x);title(\"ground truth x\");xlabel(\"time [s]\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We then generate a noisy measurement `b` via perturbing the forward evaluation by a noise term `e`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "e = 1e-3 * randn(N); # noise\n", + "b = A * x + e; # noisy measurement" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we can first solve for `x` using LSQR in IterativeSolvers.jl package" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x1 = lsqr(A, b; maxiter=500);\n", + "figure();plot(t, x1);title(\"solution from LSQR\");xlabel(\"time [s]\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see the recovery is somehow noisy because the convolution operator has a null space and LSQR searches for a minimal 2-norm solution. Since the ground truth signal is sparse, we can use spgl1 algorithm to solve for `x`, which pursues a sparse solution." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING: options.stepMin is below the precision of the data type. Setting to 10*eps(DT)\n" + ] + } + ], + "source": [ + "x2, _, _, _ = spgl1(A, b, options = spgOptions(iterations=500, verbosity=0));\n", + "figure();plot(t, x2);title(\"solution from spgl1\");xlabel(\"time [s]\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that spgl1 produces a sparse solution as expected. Notice again that we did not provide a matrix to these algorithms, but a linear operator equipped with forward and adjoint evaluations. `lsqr` and `spgl1` algorithms work right away without any modification." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Automatic differentiation (AD) through the linear operator" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Furthermore, we have the package [JOLI4Flux](https://github.com/slimgroup/JOLI4Flux.jl) that \"teaches\" Julia how to differentiate through the linear operator---i.e., \"teaches\" Julia to apply the adjoint of the linear operator during back-propagation. Taking advantage of this AD capability, we can solve the inverse problem $Ax=b$ via different regularization techniques and different objective functions. Since the gradient is provided by AD, we can use any kind of gradient-based optimization algorithm to acquire the solution. In the following example, we adopt a least-squares objective with an $\\ell_1$ penalty as\n", + "\n", + "$$\\min_{x}\\frac{1}{2} \\|Ax-b\\|_2^2 + \\lambda \\|x\\|_1$$\n", + "\n", + "and we use L-BFGS algorithm from [Optim.jl](https://github.com/JuliaNLSolvers/Optim.jl) package to iteratively invert the linear system." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "λ = 1; # weight on l1 regularization\n", + "loss(x) = .5 * norm(A * x - b)^2 + λ * norm(x,1); # objective function\n", + "δloss!(g, x) = begin g.=gradient(loss, x)[1]; return loss(x) end; # in-place gradient function\n", + "summary = optimize(loss, δloss!, zeros(N), LBFGS(), Optim.Options(iterations=500));\n", + "figure();plot(t, summary.minimizer);title(\"L-BFGS w/ 1-norm penalty\");xlabel(\"time [s]\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Linear operators in JOLI also talk to deep neural networks in Flux very effectively with the help of JOLI4Flux. We can also reparameterize the input `x` by a network `f` with a fixed input `z` and solve for the network parameters instead---i.e.,\n", + "\n", + "$$\\min_{\\theta}\\|Af_{\\theta}(z)-b\\|_2^2.$$\n", + "\n", + "This is so-called deep prior approach discussed in [Ulyanov, Dmitry, Andrea Vedaldi, and Victor Lempitsky. \"Deep image prior.\" Proceedings of the IEEE conference on computer vision and pattern recognition. 2018](https://arxiv.org/abs/1711.10925). It has also been adopted into scientific computing and computational geoscience community, where `A` is PDE-based linear operator, such as in [Siahkoohi, Ali, Gabrio Rizzuti, and Felix J. Herrmann. \"Deep Bayesian inference for seismic imaging with tasks.\" arXiv preprint arXiv:2110.04825 (2021)](https://arxiv.org/abs/2110.04825).\n", + "\n", + "In this tutorial, we adopt a dense layer as a very simple deep prior network for demonstrative purpose only. In practice, the deep prior approach might need careful choices on the network structure and regularization parameters. Thanks to the abstraction, we can still write very clean code to interact with Flux and work with optimizers in Flux, such as ADAM." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "f = Dense(2*N, N); # a very simple network\n", + "z = randn(2*N); # fixed input\n", + "Flux.trainmode!(f, true);\n", + "θ = Flux.params(f); # network parameters\n", + "\n", + "# Optimizer\n", + "opt = ADAM(1f-4)\n", + "for j=1:500\n", + " grads = gradient(θ) do\n", + " return .5 * norm(A * f(z) - b)^2 + norm(f(z), 1) + norm(θ)^2;\n", + " end\n", + "\n", + " # Update params\n", + " for p in θ\n", + " Flux.Optimise.update!(opt, p, grads[p])\n", + " end\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Figure(PyObject
)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Flux.testmode!(f, true);\n", + "figure();plot(t, f(z));title(\"deep prior solution\");xlabel(\"time [s]\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Thanks to the abstraction power of Julia, multiphysics data-driven framework can be written in a quite clean way in Julia, and can be inverted thanks to the AD capability. More information is available at [Louboutin, Mathias, et al. \"Accelerating innovation with software abstractions for scalable computational geophysics.\" arXiv preprint arXiv:2203.15038 (2022)](https://arxiv.org/pdf/2203.15038.pdf)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.7.1", + "language": "julia", + "name": "julia-1.7" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.7.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}