{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 04 - Full waveform inversion with Dask and Devito pickling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "Here, we revisit [04_dask.ipynb: Full Waveform Inversion with Devito and Dask](https://github.com/devitocodes/devito/blob/main/examples/seismic/tutorials/04_dask.ipynb), but with a twist: we now want to show that it is possible to use pickle to serialize (deserialize) a Devito object structure into (from) a byte stream. This is specially useful in our example as the geometry of all source experiments remains essentially the same; only the source location changes. In other words, we can convert a `solver` object (built on top of generic Devito objects) into a byte stream to store it. Later on, this byte stream can then be retrieved and de-serialized back to an instance of the original `solver` object by the dask workers, and then be populated with the correct geometry for the i-th source location. We can still benefit from the simplicity of the example and create **only one `solver`** object which can be used to both generate the observed data set and to compute the predicted data and gradient in the FWI process. Further examples of pickling can be found [here](https://github.com/devitocodes/devito/blob/main/tests/test_pickle.py). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The tutorial roughly follows the structure of [04_dask.ipynb](https://github.com/devitocodes/devito/blob/main/examples/seismic/tutorials/04_dask.ipynb). Technical details about [Dask](https://dask.pydata.org/en/latest/#dask) and [scipy.optimize.minimize](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html) will therefore treated only superficially."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is different from 04_dask.ipynb\n",
    "\n",
    "* **The big difference between [04_dask.ipynb](https://github.com/devitocodes/devito/blob/main/examples/seismic/tutorials/04_dask.ipynb) and this tutorial is that in the former is created a `solver` object for each source in both forward modeling and FWI gradient kernels. While here only one `solver` object is created and reused along all the optimization process. This is done through pickling and unpickling respectively.**\n",
    "\n",
    "\n",
    "* Another difference between the tutorials is that the in [04_dask.ipynb](https://github.com/devitocodes/devito/blob/main/examples/seismic/tutorials/04_dask.ipynb) is created a list with the observed shots, and then each observed shot record of the list is passed as parameter to a single-shot FWI objective function executed in parallel using the `submit()` method. Here, a single observed shot record along information of its source location is stored in a dictionary, which is saved into a pickle file. Later, dask workers retrieve the corresponding pickled data when computing the gradient for a single shot. The same applies for the `model` object in the optimization process. It is serialized each time the model's velocity is updated. Then, dask workers unpickle data from file back to `model` object.\n",
    "\n",
    "\n",
    "* Moreover, there is a difference in the way that the global functional-gradient is obtained. In [04_dask.ipynb](https://github.com/devitocodes/devito/blob/main/examples/seismic/tutorials/04_dask.ipynb) we had to wait for all computations to finish via `wait(futures)` and then we sum the function values and gradients from all workers. Here, it is defined a type `fg_pair` so that a reduce function `sum` can be used, such function takes all the futures given to it and after they are completed, combine them to get the estimate of the global functional-gradient. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## scipy.optimize.minimize \n",
    "\n",
    "As in [04_dask.ipynb](https://github.com/devitocodes/devito/blob/main/examples/seismic/tutorials/04_dask.ipynb), here we are going to focus on using L-BFGS via [scipy.optimize.minimize(method=’L-BFGS-B’)](https://docs.scipy.org/doc/scipy/reference/optimize.minimize-lbfgsb.html#optimize-minimize-lbfgsb)\n",
    "\n",
    "```python\n",
    "scipy.optimize.minimize(fun, x0, args=(), method='L-BFGS-B', jac=None, bounds=None, tol=None, callback=None, options={'disp': None, 'maxls': 20, 'iprint': -1, 'gtol': 1e-05, 'eps': 1e-08, 'maxiter': 15000, 'ftol': 2.220446049250313e-09, 'maxcor': 10, 'maxfun': 15000})```\n",
    "\n",
    "The argument `fun` is a callable function that returns the misfit between the simulated and the observed data. If `jac` is a Boolean and is `True`, `fun` is assumed to return the gradient along with the objective function - as is our case when applying the adjoint-state method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dask\n",
    "\n",
    "[Dask](https://dask.pydata.org/en/latest/#dask) is task-based parallelization framework for Python. It allows us to distribute our work among a collection of workers controlled by a central scheduler. Dask is [well-documented](https://docs.dask.org/en/latest/), flexible, an currently under active development.\n",
    "\n",
    "In the same way as in [04_dask.ipynb](https://github.com/devitocodes/devito/blob/main/examples/seismic/tutorials/04_dask.ipynb), we are going to use it here to parallelise the computation of the functional and gradient as this is the vast bulk of the computational expense of FWI and it is trivially parallel over data shots."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Forward modeling\n",
    "\n",
    "We define the functions used for the forward modeling, as well as the other functions used in constructing and deconstructing Python/Devito objects to/from binary data as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NBVAL_IGNORE_OUTPUT\n",
    "import numpy as np\n",
    "\n",
    "from scipy import optimize\n",
    "\n",
    "\n",
    "from distributed import Client, LocalCluster, wait\n",
    "\n",
    "import cloudpickle as pickle\n",
    "\n",
    "# Import acoustic solver, source and receiver modules.\n",
    "from examples.seismic import demo_model, AcquisitionGeometry, Receiver\n",
    "from examples.seismic.acoustic import AcousticWaveSolver\n",
    "\n",
    "# Import convenience function for plotting results\n",
    "from examples.seismic import plot_image\n",
    "\n",
    "\n",
    "# Set up inversion parameters.\n",
    "param = {\n",
    "    't0': 0.,\n",
    "    'tn': 1000.,              # Simulation last 1 second (1000 ms)\n",
    "    'f0': 0.010,              # Source peak frequency is 10Hz (0.010 kHz)\n",
    "    'nshots': 5,              # Number of shots to create gradient from\n",
    "    'shape': (101, 101),      # Number of grid points (nx, nz).\n",
    "    'spacing': (10., 10.),    # Grid spacing in m. The domain size is now 1km by 1km.\n",
    "    'origin': (0, 0),         # Need origin to define relative source and receiver locations.\n",
    "    'nbl': 40                 # nbl thickness.\n",
    "}\n",
    "\n",
    "\n",
    "def get_true_model():\n",
    "    ''' Define the test phantom; in this case we are using\n",
    "    a simple circle so we can easily see what is going on.\n",
    "    '''\n",
    "    return demo_model('circle-isotropic', vp_circle=3.0, vp_background=2.5,\n",
    "                      origin=param['origin'], shape=param['shape'],\n",
    "                      spacing=param['spacing'], nbl=param['nbl'])\n",
    "\n",
    "\n",
    "def get_initial_model():\n",
    "    '''The initial guess for the subsurface model.\n",
    "    '''\n",
    "    # Make sure both model are on the same grid\n",
    "    grid = get_true_model().grid\n",
    "    return demo_model('circle-isotropic', vp_circle=2.5, vp_background=2.5,\n",
    "                      origin=param['origin'], shape=param['shape'],\n",
    "                      spacing=param['spacing'], nbl=param['nbl'],\n",
    "                      grid=grid)\n",
    "\n",
    "\n",
    "def wrap_model(x, astype=None):\n",
    "    '''Wrap a flat array as a subsurface model.\n",
    "    '''\n",
    "    model = get_initial_model()\n",
    "    v_curr = 1.0/np.sqrt(x.reshape(model.shape))\n",
    "\n",
    "    if astype:\n",
    "        model.update('vp', v_curr.astype(astype).reshape(model.shape))\n",
    "    else:\n",
    "        model.update('vp', v_curr.reshape(model.shape))\n",
    "    return model\n",
    "\n",
    "\n",
    "def load_model(filename):\n",
    "    \"\"\" Returns the current model. This is used by the\n",
    "    worker to get the current model.\n",
    "    \"\"\"\n",
    "    with open(filename, 'rb') as fh:\n",
    "        pkl = pickle.load(fh)\n",
    "\n",
    "    return pkl['model']\n",
    "\n",
    "\n",
    "def dump_model(filename, model):\n",
    "    ''' Dump model to disk.\n",
    "    '''\n",
    "    with open(filename, \"wb\") as fh:\n",
    "        pickle.dump({'model': model}, fh)\n",
    "\n",
    "\n",
    "def load_shot_data(shot_id, dt):\n",
    "    ''' Load shot data from disk, resampling to the model time step.\n",
    "    '''\n",
    "    with open(f\"shot_{shot_id}.p\", \"rb\") as fh:\n",
    "        pkl = pickle.load(fh)\n",
    "\n",
    "    return pkl['geometry'], pkl['rec'].resample(dt)\n",
    "\n",
    "\n",
    "def dump_shot_data(shot_id, rec, geometry):\n",
    "    ''' Dump shot data to disk.\n",
    "    '''\n",
    "    with open(f'shot_{shot_id}.p', \"wb\") as fh:\n",
    "        pickle.dump({'rec': rec, 'geometry': geometry}, fh)\n",
    "\n",
    "\n",
    "def generate_shotdata_i(param):\n",
    "    \"\"\" Inversion crime alert! Here the worker is creating the\n",
    "        'observed' data using the real model. For a real case\n",
    "        the worker would be reading seismic data from disk.\n",
    "    \"\"\"\n",
    "    # Reconstruct objects\n",
    "    with open(\"arguments.pkl\", \"rb\") as cp_file:\n",
    "        cp = pickle.load(cp_file)\n",
    "\n",
    "    solver = cp['solver']\n",
    "\n",
    "    # source position changes according to the index\n",
    "    shot_id = param['shot_id']\n",
    "\n",
    "    solver.geometry.src_positions[0, :] = [20, shot_id*1000./(param['nshots']-1)]\n",
    "    true_d = solver.forward()[0]\n",
    "    dump_shot_data(shot_id, true_d.resample(4.0), solver.geometry.src_positions)\n",
    "\n",
    "\n",
    "def generate_shotdata(solver):\n",
    "    # Pick devito objects (save on disk)\n",
    "    cp = {'solver': solver}\n",
    "    with open(\"arguments.pkl\", \"wb\") as cp_file:\n",
    "        pickle.dump(cp, cp_file)\n",
    "\n",
    "    work = [dict(param) for i in range(param['nshots'])]\n",
    "    # synthetic data is generated here twice: serial(loop below) and parallel (via dask map functionality)\n",
    "    for i in range(param['nshots']):\n",
    "        work[i]['shot_id'] = i\n",
    "        generate_shotdata_i(work[i])\n",
    "\n",
    "    # Map worklist to cluster, We pass our function and the dictionary to the map() function of the client\n",
    "    # This returns a list of futures that represents each task\n",
    "    futures = c.map(generate_shotdata_i, work)\n",
    "\n",
    "    # Wait for all futures\n",
    "    wait(futures)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.02 s\n",
      "Operator `Forward` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.02 s\n"
     ]
    }
   ],
   "source": [
    "# NBVAL_IGNORE_OUTPUT\n",
    "\n",
    "# Client setup\n",
    "cluster = LocalCluster(n_workers=2, death_timeout=600)\n",
    "c = Client(cluster)\n",
    "\n",
    "# Generate shot data.\n",
    "true_model = get_true_model()\n",
    "# Source coords definition\n",
    "src_coordinates = np.empty((1, len(param['shape'])))\n",
    "# Number of receiver locations per shot.\n",
    "nreceivers = 101\n",
    "# Set up receiver data and geometry.\n",
    "rec_coordinates = np.empty((nreceivers, len(param['shape'])))\n",
    "rec_coordinates[:, 1] = np.linspace(\n",
    "    param['spacing'][0],\n",
    "    true_model.domain_size[0] - param['spacing'][0],\n",
    "    num=nreceivers\n",
    ")\n",
    "rec_coordinates[:, 0] = 980.  # 20m from the right end\n",
    "# Geometry\n",
    "geometry = AcquisitionGeometry(true_model, rec_coordinates, src_coordinates,\n",
    "                               param['t0'], param['tn'], src_type='Ricker',\n",
    "                               f0=param['f0'])\n",
    "# Set up solver\n",
    "solver = AcousticWaveSolver(true_model, geometry, space_order=4)\n",
    "generate_shotdata(solver)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dask specifics\n",
    "\n",
    "Previously in [03_fwi.ipynb](https://github.com/devitocodes/devito/blob/main/examples/seismic/tutorials/03_fwi.ipynb), we defined a function to calculate the individual contribution to the functional and gradient for each shot, which was then used in a loop over all shots. However, when using distributed frameworks such as Dask we instead think in terms of creating a worklist which gets *mapped* onto the worker pool. The sum reduction is also performed in parallel. For now however we assume that the scipy.optimize.minimize itself is running on the *main* process; this is a reasonable simplification because the computational cost of calculating (f, g) far exceeds the other compute costs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because we want to be able to use standard reduction operators such as sum on (f, g) we first define it as a type so that we can define the `__add__` (and `__radd__` method)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a type to store the functional and gradient.\n",
    "class fg_pair:\n",
    "    def __init__(self, f, g):\n",
    "        self.f = f\n",
    "        self.g = g\n",
    "\n",
    "    def __add__(self, other):\n",
    "        f = self.f + other.f\n",
    "        g = self.g + other.g\n",
    "\n",
    "        return fg_pair(f, g)\n",
    "\n",
    "    def __radd__(self, other):\n",
    "        if other == 0:\n",
    "            return self\n",
    "        else:\n",
    "            return self.__add__(other)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create operators for gradient based inversion\n",
    "To perform the inversion we are going to use [scipy.optimize.minimize(method=’L-BFGS-B’)](https://docs.scipy.org/doc/scipy/reference/optimize.minimize-lbfgsb.html#optimize-minimize-lbfgsb).\n",
    "\n",
    "First we define the functional, ```f```, and gradient, ```g```, operator (i.e. the function ```fun```) for a single shot of data. This is the work that is going to be performed by the worker on a unit of data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NBVAL_IGNORE_OUTPUT\n",
    "from devito import Function\n",
    "\n",
    "\n",
    "# Create FWI gradient kernel for a single shot\n",
    "def fwi_gradient_i(param):\n",
    "\n",
    "    # Load the current model and the shot data for this worker.\n",
    "    # Note, unlike the serial example the model is not passed in\n",
    "    # as an argument. Broadcasting large datasets is considered\n",
    "    # a programming anti-pattern and at the time of writing it\n",
    "    # it only worked reliably with Dask main. Therefore, the\n",
    "    # the model is communicated via a file.\n",
    "    model0 = load_model(param['model'])\n",
    "\n",
    "    dt = model0.critical_dt\n",
    "    nbl = model0.nbl\n",
    "\n",
    "    # Get src_position and data\n",
    "    src_positions, rec = load_shot_data(param['shot_id'], dt)\n",
    "\n",
    "    # Set up solver -- load the solver used above in the generation of the synthetic data.\n",
    "    with open(\"arguments.pkl\", \"rb\") as cp_file:\n",
    "        cp = pickle.load(cp_file)\n",
    "    solver = cp['solver']\n",
    "\n",
    "    # Set attributes to solver\n",
    "    solver.geometry.src_positions = src_positions\n",
    "    solver.geometry.resample(dt)\n",
    "\n",
    "    # Compute simulated data and full forward wavefield u0\n",
    "    d, u0 = solver.forward(vp=model0.vp, dt=dt, save=True)[0:2]\n",
    "\n",
    "    # Compute the data misfit (residual) and objective function\n",
    "    residual = Receiver(name='rec', grid=model0.grid,\n",
    "                        time_range=solver.geometry.time_axis,\n",
    "                        coordinates=solver.geometry.rec_positions)\n",
    "\n",
    "    # residual.data[:] = d.data[:residual.shape[0], :] - rec.data[:residual.shape[0], :]\n",
    "    residual.data[:] = d.data[:] - rec.data[0:d.data.shape[0], :]\n",
    "    f = .5*np.linalg.norm(residual.data.flatten())**2\n",
    "\n",
    "    # Compute gradient using the adjoint-state method. Note, this\n",
    "    # backpropagates the data misfit through the model.\n",
    "    grad = Function(name=\"grad\", grid=model0.grid)\n",
    "    solver.gradient(rec=residual, u=u0, vp=model0.vp, dt=dt, grad=grad)\n",
    "\n",
    "    # Copying here to avoid a (probably overzealous) destructor deleting\n",
    "    # the gradient before Dask has had a chance to communicate it.\n",
    "    g = np.array(grad.data[:])[nbl:-nbl, nbl:-nbl]\n",
    "\n",
    "    # return the objective functional and gradient.\n",
    "    return fg_pair(f, g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the global functional-gradient operator. This does the following:\n",
    "* Maps the worklist (shots) to the workers so that the individual contributions to (f, g) are computed.\n",
    "* Sum individual contributions to (f, g) and returns the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fwi_gradient(model, param):\n",
    "    # Dump a copy of the current model for the workers\n",
    "    # to pick up when they are ready.\n",
    "    param['model'] = \"model_0.p\"\n",
    "    dump_model(param['model'], wrap_model(model))\n",
    "\n",
    "    # Define work list\n",
    "    work = [dict(param) for i in range(param['nshots'])]\n",
    "    for i in range(param['nshots']):\n",
    "        work[i]['shot_id'] = i\n",
    "\n",
    "    # Distribute worklist to workers.\n",
    "    fgi = c.map(fwi_gradient_i, work, retries=1)\n",
    "\n",
    "    # Perform reduction.\n",
    "    fg = c.submit(sum, fgi).result()\n",
    "\n",
    "    # L-BFGS in scipy expects a flat array in 64-bit floats.\n",
    "    return fg.f, fg.g.flatten().astype(np.float64)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## FWI with L-BFGS-B\n",
    "Equipped with a function to calculate the functional and gradient, we are finally ready to define the optimization function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Many optimization methods in scipy.optimize.minimize accept a callback\n",
    "# function that can operate on the solution after every iteration. Here\n",
    "# we use this to monitor the true relative solution error.\n",
    "relative_error = []\n",
    "\n",
    "\n",
    "def fwi_callbacks(x):\n",
    "    # Calculate true relative error\n",
    "    true_vp = get_true_model().vp.data[param['nbl']:-param['nbl'], param['nbl']:-param['nbl']]\n",
    "    true_m = 1.0 / (true_vp.reshape(-1).astype(np.float64))**2\n",
    "    relative_error.append(np.linalg.norm((x-true_m)/true_m))\n",
    "\n",
    "\n",
    "# FWI with L-BFGS\n",
    "ftol = 0.1\n",
    "maxiter = 5\n",
    "\n",
    "\n",
    "def fwi(model, param, ftol=ftol, maxiter=maxiter):\n",
    "    # Initial guess\n",
    "    v0 = model.vp.data[param['nbl']:-param['nbl'], param['nbl']:-param['nbl']]\n",
    "    m0 = 1.0 / (v0.reshape(-1).astype(np.float64))**2\n",
    "\n",
    "    # Define bounding box constraints on the solution.\n",
    "    vmin = 1.4    # do not allow velocities slower than water\n",
    "    vmax = 4.0\n",
    "    bounds = [(1.0/vmax**2, 1.0/vmin**2) for _ in range(np.prod(model.shape))]    # in [s^2/km^2]\n",
    "\n",
    "    result = optimize.minimize(fwi_gradient,\n",
    "                               m0, args=(param, ), method='L-BFGS-B', jac=True,\n",
    "                               bounds=bounds, callback=fwi_callbacks,\n",
    "                               options={'ftol': ftol,\n",
    "                                        'maxiter': maxiter,\n",
    "                                        'disp': True})\n",
    "\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now apply our FWI function and have a look at the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.04 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.03 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.04 s\n",
      "Operator `Gradient` ran in 0.03 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Gradient` ran in 0.05 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Gradient` ran in 0.03 s\n",
      "Operator `Gradient` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Gradient` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Gradient` ran in 0.04 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Gradient` ran in 0.03 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Gradient` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Gradient` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Gradient` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Forward` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Gradient` ran in 0.02 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` ran in 0.01 s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  message: STOP: TOTAL NO. OF ITERATIONS REACHED LIMIT\n",
      "  success: False\n",
      "   status: 1\n",
      "      fun: 149.9846\n",
      "        x: [ 1.569e-01  1.562e-01 ...  1.551e-01  1.702e-01]\n",
      "      nit: 5\n",
      "      jac: [ 4.010e+01  3.765e+01 ... -7.748e-01 -2.025e+00]\n",
      "     nfev: 8\n",
      "     njev: 8\n",
      " hess_inv: <10201x10201 LbfgsInvHessProduct with dtype=float64>\n"
     ]
    }
   ],
   "source": [
    "# NBVAL_IGNORE_OUTPUT\n",
    "\n",
    "model0 = get_initial_model()\n",
    "\n",
    "# Baby steps\n",
    "result = fwi(model0, param)\n",
    "\n",
    "# Print out results of optimizer.\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# NBVAL_SKIP\n",
    "\n",
    "# Plot FWI result\n",
    "\n",
    "slices = tuple(slice(param['nbl'], -param['nbl']) for _ in range(2))\n",
    "vp = 1.0/np.sqrt(result['x'].reshape(true_model.shape))\n",
    "plot_image(true_model.vp.data[slices], vmin=2.4, vmax=2.8, cmap=\"cividis\")\n",
    "plot_image(vp, vmin=2.4, vmax=2.8, cmap=\"cividis\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# NBVAL_SKIP\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Plot model error\n",
    "plt.plot(range(1, maxiter+1), relative_error)\n",
    "plt.xlabel('Iteration number')\n",
    "plt.ylabel('L2-model error')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As can be observed in last figures, the results we obtain are exactly the same to the ones obtained in [04_dask.ipynb](https://github.com/devitocodes/devito/blob/main/examples/seismic/tutorials/04_dask.ipynb)"
   ]
  }
 ],
 "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}