ipynb/daisuke_oyama-ddp_ex_rust96_py.ipynb

{
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "# DiscreteDP Example: Automobile Replacement"
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "**Daisuke Oyama**\n\n*Faculty of Economics, University of Tokyo*"
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "We study the finite-state version of the automobile replacement problem as considered in\nRust (1996, Section 4.2.2)."
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "* J. Rust, \"Numerical Dynamic Programming in Economics\",\n  <i>Handbook of Computational Economics</i>, Volume 1, 619-729, 1996."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [],
            "source": [
                "%matplotlib inline"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "metadata": {},
            "outputs": [],
            "source": [
                "import numpy as np\n",
                "import itertools\n",
                "import scipy.optimize\n",
                "import matplotlib.pyplot as plt\n",
                "import pandas as pd\n",
                "from quantecon.markov import DiscreteDP"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 3,
            "metadata": {},
            "outputs": [],
            "source": [
                "# matplotlib settings\n",
                "plt.rcParams['axes.autolimit_mode'] = 'round_numbers'\n",
                "plt.rcParams['axes.xmargin'] = 0\n",
                "plt.rcParams['axes.ymargin'] = 0\n",
                "plt.rcParams['patch.force_edgecolor'] = True\n",
                "\n",
                "from cycler import cycler\n",
                "plt.rcParams['axes.prop_cycle'] = cycler(color='bgrcmyk')"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "## Setup"
        },
        {
            "cell_type": "code",
            "execution_count": 4,
            "metadata": {},
            "outputs": [],
            "source": [
                "lambd = 0.5        # Exponential distribution parameter\n",
                "c = 200            # (Constant) marginal cost of maintainance\n",
                "net_price = 10**5  # Replacement cost"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 5,
            "metadata": {},
            "outputs": [],
            "source": [
                "n = 100  # Number of states; s = 0, ..., n-1: level of utilization of the asset\n",
                "m = 2    # Number of actions; 0: keep, 1: replace"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 6,
            "metadata": {},
            "outputs": [],
            "source": [
                "# Reward array\n",
                "R = np.empty((n, m))\n",
                "R[:, 0] = -c * np.arange(n)   # Costs for maintainance\n",
                "R[:, 1] = -net_price - c * 0  # Costs for replacement"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 7,
            "metadata": {},
            "outputs": [],
            "source": [
                "# Transition probability array\n",
                "# For each state s, s' distributes over\n",
                "# s, s+1, ..., min{s+supp_size-1, n-1} if a = 0\n",
                "# 0, 1, ..., supp_size-1 if a = 1\n",
                "# according to the (discretized and truncated) exponential distribution\n",
                "# with parameter lambd\n",
                "supp_size = 12\n",
                "probs = np.empty(supp_size)\n",
                "probs[0] = 1 - np.exp(-lambd * 0.5)\n",
                "for j in range(1, supp_size-1):\n",
                "    probs[j] = np.exp(-lambd * (j - 0.5)) - np.exp(-lambd * (j + 0.5))\n",
                "probs[supp_size-1] = 1 - np.sum(probs[:-1])\n",
                "\n",
                "Q = np.zeros((n, m, n))\n",
                "\n",
                "# a = 0\n",
                "for i in range(n-supp_size):\n",
                "    Q[i, 0, i:i+supp_size] = probs\n",
                "for k in range(supp_size):\n",
                "    Q[n-supp_size+k, 0, n-supp_size+k:] = probs[:supp_size-k]/probs[:supp_size-k].sum()\n",
                "\n",
                "# a = 1\n",
                "for i in range(n):\n",
                "    Q[i, 1, :supp_size] = probs"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 8,
            "metadata": {},
            "outputs": [],
            "source": [
                "# Discount factor\n",
                "beta = 0.95"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "## Continuous-state benchmark"
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Let us compute the value function of the continuous-state version\nas described in equations (2.22) and (2.23) in Section 2.3."
        },
        {
            "cell_type": "code",
            "execution_count": 9,
            "metadata": {},
            "outputs": [],
            "source": [
                "def f(x, s):\n",
                "    return (c/(1-beta)) * \\\n",
                "        ((x-s) - (beta/(lambd*(1-beta))) * (1 - np.exp(-lambd*(1-beta)*(x-s))))"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "The optimal stopping boundary $\\gamma$ for the contiuous-state version, given by (2.23):"
        },
        {
            "cell_type": "code",
            "execution_count": 10,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "52.86545636058919\n"
                    ]
                }
            ],
            "source": [
                "gamma = scipy.optimize.brentq(lambda x: f(x, 0) - net_price, 0, 100)\n",
                "print(gamma)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "The value function for the continuous-state version, given by (2.24):"
        },
        {
            "cell_type": "code",
            "execution_count": 11,
            "metadata": {},
            "outputs": [],
            "source": [
                "def value_func_cont_time(s):\n",
                "    return -c*gamma/(1-beta) + (s < gamma) * f(gamma, s)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 12,
            "metadata": {},
            "outputs": [],
            "source": [
                "v_cont = value_func_cont_time(np.arange(n))"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "## Solving the problem with `DiscreteDP`"
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Construct a `DiscreteDP` instance for the disrete-state version:"
        },
        {
            "cell_type": "code",
            "execution_count": 13,
            "metadata": {},
            "outputs": [],
            "source": [
                "ddp = DiscreteDP(R, Q, beta)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Let us solve the decision problem by\n\n(0) value iteration,  \n(1) value iteration with span-based termination\n(equivalent to modified policy iteration with step $k = 0$),  \n(2) policy iteration,  \n(3) modified policy iteration."
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Following Rust (1996), we set:\n\n* $\\varepsilon = 1164$ (for value iteration and modified policy iteration),\n* $v^0 \\equiv 0$,\n* the number of iteration for iterative policy evaluation $k = 20$."
        },
        {
            "cell_type": "code",
            "execution_count": 14,
            "metadata": {},
            "outputs": [],
            "source": [
                "v_init = np.zeros(ddp.num_states)\n",
                "epsilon = 1164\n",
                "methods = ['vi', 'mpi', 'pi', 'mpi']\n",
                "labels = ['Value iteration', 'Value iteration with span-based termination',\n",
                "          'Policy iteration', 'Modified policy iteration']\n",
                "results = {}\n",
                "\n",
                "for i in range(4):\n",
                "    k = 20 if labels[i] == 'Modified policy iteration' else 0\n",
                "    results[labels[i]] = \\\n",
                "        ddp.solve(method=methods[i], v_init=v_init, epsilon=epsilon, k=k)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 15,
            "metadata": {},
            "outputs": [],
            "source": [
                "columns = [\n",
                "    'Iterations', 'Time (second)', r'$\\lVert v - v_{\\mathrm{pi}} \\rVert$',\n",
                "    r'$\\overline{b} - \\underline{b}$', r'$\\lVert v - T(v)\\rVert$'\n",
                "]\n",
                "df = pd.DataFrame(index=labels, columns=columns)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "The numbers of iterations:"
        },
        {
            "cell_type": "code",
            "execution_count": 16,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "114 \t(Value iteration)\n",
                        "65 \t(Value iteration with span-based termination)\n",
                        "5 \t(Policy iteration)\n",
                        "6 \t(Modified policy iteration)\n"
                    ]
                }
            ],
            "source": [
                "for label in labels:\n",
                "    print(results[label].num_iter, '\\t' + '(' + label + ')')\n",
                "    df.loc[label, columns[0]] = results[label].num_iter"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Policy iteration gives the optimal policy:"
        },
        {
            "cell_type": "code",
            "execution_count": 17,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
                        " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
                        " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]\n"
                    ]
                }
            ],
            "source": [
                "print(results['Policy iteration'].sigma)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Takes action 1 (\"replace\") if and only if $s \\geq \\bar{\\gamma}$, where $\\bar{\\gamma}$ is equal to:"
        },
        {
            "cell_type": "code",
            "execution_count": 18,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "53"
                        ]
                    },
                    "execution_count": 18,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "(1-results['Policy iteration'].sigma).sum()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Check that the other methods gave the correct answer:"
        },
        {
            "cell_type": "code",
            "execution_count": 19,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "True\n",
                        "True\n",
                        "True\n"
                    ]
                }
            ],
            "source": [
                "for result in results.values():\n",
                "    if result != results['Policy iteration']:\n",
                "        print(np.array_equal(result.sigma, results['Policy iteration'].sigma))"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "The deviations of the returned value function from the continuous-state benchmark:"
        },
        {
            "cell_type": "code",
            "execution_count": 20,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "1733.779101960361 \t(Value iteration)\n",
                        "1085.8057169329695 \t(Value iteration with span-based termination)\n",
                        "1162.880608632724 \t(Policy iteration)\n",
                        "1144.477283824759 \t(Modified policy iteration)\n"
                    ]
                }
            ],
            "source": [
                "diffs_cont = {}\n",
                "for label in labels:\n",
                "    diffs_cont[label] = np.abs(results[label].v - v_cont).max()\n",
                "    print(diffs_cont[label], '\\t' + '(' + label + ')')"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 21,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 576x360 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "label = 'Policy iteration'\n",
                "fig, ax = plt.subplots(figsize=(8,5))\n",
                "ax.plot(-v_cont, label='Continuous-state')\n",
                "ax.plot(-results[label].v, label=label)\n",
                "ax.set_title('Comparison of discrete vs. continuous value functions')\n",
                "ax.ticklabel_format(style='sci', axis='y', scilimits=(0,0))\n",
                "ax.set_xlabel('State')\n",
                "ax.set_ylabel(r'Value $\\times\\ (-1)$')\n",
                "plt.legend(loc=4)\n",
                "plt.show()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "In the following we try to reproduce Table 14.1 in Rust (1996), p.660,\nalthough the precise definitions and procedures there are not very clear."
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "The maximum absolute differences of $v$ from that by policy iteration:"
        },
        {
            "cell_type": "code",
            "execution_count": 22,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "571.6578080339823 \t(Value iteration)\n",
                        "124.13762614113512 \t(Value iteration with span-based termination)\n",
                        "0.0 \t(Policy iteration)\n",
                        "44.26734841032885 \t(Modified policy iteration)\n"
                    ]
                }
            ],
            "source": [
                "for label in labels:\n",
                "    diff_pi = \\\n",
                "        np.abs(results[label].v - results['Policy iteration'].v).max()\n",
                "    print(diff_pi, '\\t' + '(' + label + ')')\n",
                "    df.loc[label, columns[2]] = diff_pi"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Compute $\\lVert v - T(v)\\rVert$:"
        },
        {
            "cell_type": "code",
            "execution_count": 23,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "29.080024668044643 \t(Value iteration)\n",
                        "27.78833861692692 \t(Value iteration with span-based termination)\n",
                        "1.7462298274040222e-10 \t(Policy iteration)\n",
                        "6.597127532120794 \t(Modified policy iteration)\n"
                    ]
                }
            ],
            "source": [
                "for label in labels:\n",
                "    v = results[label].v\n",
                "    diff_max = \\\n",
                "        np.abs(v - ddp.bellman_operator(v)).max()\n",
                "    print(diff_max, '\\t' + '(' + label + ')')\n",
                "    df.loc[label, columns[4]] = diff_max"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Next we compute $\\overline{b} - \\underline{b}$\nfor the three methods other than policy iteration, where\n$I$ is the number of iterations required to fulfill the termination condition, and\n$$\n\\begin{aligned}\n\\underline{b} &= \\frac{\\beta}{1-\\beta} \\min\\left[T(v^{I-1}) - v^{I-1}\\right], \\\\\\\\\n\\overline{b}  &= \\frac{\\beta}{1-\\beta} \\max\\left[T(v^{I-1}) - v^{I-1}\\right].\n\\end{aligned}\n$$"
        },
        {
            "cell_type": "code",
            "execution_count": 24,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "26.465574393529074 \t(Value iteration)\n",
                        "1141.0513007884717 \t(Value iteration with span-based termination)\n",
                        "267.4945517340672 \t(Modified policy iteration)\n"
                    ]
                }
            ],
            "source": [
                "for i in range(4):\n",
                "    if labels[i] != 'Policy iteration':\n",
                "        k = 20 if labels[i] == 'Modified policy iteration' else 0\n",
                "        res = ddp.solve(method=methods[i], v_init=v_init, k=k,\n",
                "                        max_iter=results[labels[i]].num_iter-1)\n",
                "        diff = ddp.bellman_operator(res.v) - res.v\n",
                "        diff_span = (diff.max() - diff.min()) * ddp.beta / (1 - ddp.beta)\n",
                "        print(diff_span, '\\t' + '(' + labels[i] + ')')\n",
                "        df.loc[labels[i], columns[3]] = diff_span"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "For policy iteration, while it does not seem really relevant,\nwe compute $\\overline{b} - \\underline{b}$ with the returned value of $v$\nin place of $v^{I-1}$:"
        },
        {
            "cell_type": "code",
            "execution_count": 25,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "3.8708094507455784e-09 \t(Policy iteration)\n"
                    ]
                }
            ],
            "source": [
                "label = 'Policy iteration'\n",
                "v = results[label].v\n",
                "diff = ddp.bellman_operator(v) - v\n",
                "diff_span = (diff.max() - diff.min()) * ddp.beta / (1 - ddp.beta)\n",
                "print(diff_span, '\\t' + '(' + label + ')')\n",
                "df.loc[label, columns[3]] = diff_span"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Last, time each algorithm:"
        },
        {
            "cell_type": "code",
            "execution_count": 26,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Value iteration\n",
                        "4.47 ms ± 34.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
                        "Value iteration with span-based termination\n",
                        "4.33 ms ± 12.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
                        "Policy iteration\n",
                        "1.24 ms ± 4.19 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
                        "Modified policy iteration\n",
                        "1.46 ms ± 4.95 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
                    ]
                }
            ],
            "source": [
                "for i in range(4):\n",
                "    k = 20 if labels[i] == 'Modified policy iteration' else 0\n",
                "    print(labels[i])\n",
                "    t = %timeit -o ddp.solve(method=methods[i], v_init=v_init, epsilon=epsilon, k=k)\n",
                "    df.loc[labels[i], columns[1]] = t.best"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 27,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/html": [
                            "<div>\n",
                            "<style scoped>\n",
                            "    .dataframe tbody tr th:only-of-type {\n",
                            "        vertical-align: middle;\n",
                            "    }\n",
                            "\n",
                            "    .dataframe tbody tr th {\n",
                            "        vertical-align: top;\n",
                            "    }\n",
                            "\n",
                            "    .dataframe thead th {\n",
                            "        text-align: right;\n",
                            "    }\n",
                            "</style>\n",
                            "<table border=\"1\" class=\"dataframe\">\n",
                            "  <thead>\n",
                            "    <tr style=\"text-align: right;\">\n",
                            "      <th></th>\n",
                            "      <th>Iterations</th>\n",
                            "      <th>Time (second)</th>\n",
                            "      <th>$\\lVert v - v_{\\mathrm{pi}} \\rVert$</th>\n",
                            "      <th>$\\overline{b} - \\underline{b}$</th>\n",
                            "      <th>$\\lVert v - T(v)\\rVert$</th>\n",
                            "    </tr>\n",
                            "  </thead>\n",
                            "  <tbody>\n",
                            "    <tr>\n",
                            "      <th>Value iteration</th>\n",
                            "      <td>114</td>\n",
                            "      <td>0.00442403</td>\n",
                            "      <td>571.658</td>\n",
                            "      <td>26.4656</td>\n",
                            "      <td>29.08</td>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>Value iteration with span-based termination</th>\n",
                            "      <td>65</td>\n",
                            "      <td>0.00431911</td>\n",
                            "      <td>124.138</td>\n",
                            "      <td>1141.05</td>\n",
                            "      <td>27.7883</td>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>Policy iteration</th>\n",
                            "      <td>5</td>\n",
                            "      <td>0.00122849</td>\n",
                            "      <td>0</td>\n",
                            "      <td>3.87081e-09</td>\n",
                            "      <td>1.74623e-10</td>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>Modified policy iteration</th>\n",
                            "      <td>6</td>\n",
                            "      <td>0.00145391</td>\n",
                            "      <td>44.2673</td>\n",
                            "      <td>267.495</td>\n",
                            "      <td>6.59713</td>\n",
                            "    </tr>\n",
                            "  </tbody>\n",
                            "</table>\n",
                            "</div>"
                        ],
                        "text/plain": [
                            "                                            Iterations Time (second)  \\\n",
                            "Value iteration                                    114    0.00442403   \n",
                            "Value iteration with span-based termination         65    0.00431911   \n",
                            "Policy iteration                                     5    0.00122849   \n",
                            "Modified policy iteration                            6    0.00145391   \n",
                            "\n",
                            "                                            $\\lVert v - v_{\\mathrm{pi}} \\rVert$  \\\n",
                            "Value iteration                                                         571.658   \n",
                            "Value iteration with span-based termination                             124.138   \n",
                            "Policy iteration                                                              0   \n",
                            "Modified policy iteration                                               44.2673   \n",
                            "\n",
                            "                                            $\\overline{b} - \\underline{b}$  \\\n",
                            "Value iteration                                                    26.4656   \n",
                            "Value iteration with span-based termination                        1141.05   \n",
                            "Policy iteration                                               3.87081e-09   \n",
                            "Modified policy iteration                                          267.495   \n",
                            "\n",
                            "                                            $\\lVert v - T(v)\\rVert$  \n",
                            "Value iteration                                               29.08  \n",
                            "Value iteration with span-based termination                 27.7883  \n",
                            "Policy iteration                                        1.74623e-10  \n",
                            "Modified policy iteration                                   6.59713  "
                        ]
                    },
                    "execution_count": 27,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "df"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "### Notes"
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "It appears that our value iteration with span-based termination is different in some details\nfrom the corresponding algorithm (successive approximation with error bounds) in Rust.\nIn returing the value function, our algorithm returns\n$T(v^{I-1}) + (\\overline{b} + \\underline{b})/2$,\nwhile Rust's seems to return $v^{I-1} + (\\overline{b} + \\underline{b})/2$.\nIn fact:"
        },
        {
            "cell_type": "code",
            "execution_count": 28,
            "metadata": {},
            "outputs": [],
            "source": [
                "i = 1\n",
                "k = 0\n",
                "res = ddp.solve(method=methods[i], v_init=v_init, k=k,\n",
                "                max_iter=results[labels[i]].num_iter-1)\n",
                "diff = ddp.bellman_operator(res.v) - res.v\n",
                "v = res.v + (diff.max() + diff.min()) * ddp.beta / (1 - ddp.beta) / 2"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "$\\lVert v - v_{\\mathrm{pi}}\\rVert$:"
        },
        {
            "cell_type": "code",
            "execution_count": 29,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "503.4300117044477"
                        ]
                    },
                    "execution_count": 29,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "np.abs(v - results['Policy iteration'].v).max()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "$\\lVert v - T(v)\\rVert$:"
        },
        {
            "cell_type": "code",
            "execution_count": 30,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "48.49961796964635"
                        ]
                    },
                    "execution_count": 30,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "np.abs(v - ddp.bellman_operator(v)).max()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Compare the Table in Rust."
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "## Convergence of trajectories"
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Let us plot the convergence of $v^i$ for the four algorithms;\nsee also Figure 14.2 in Rust."
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "### Value iteration"
        },
        {
            "cell_type": "code",
            "execution_count": 31,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 576x360 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "label = 'Value iteration'\n",
                "iters = [2, 20, 40, 80]\n",
                "v = np.zeros(ddp.num_states)\n",
                "\n",
                "fig, ax = plt.subplots(figsize=(8,5))\n",
                "for i in range(iters[-1]):\n",
                "    v = ddp.bellman_operator(v)\n",
                "    if i+1 in iters:\n",
                "        ax.plot(-v, label='Iteration {0}'.format(i+1))\n",
                "ax.plot(-results['Policy iteration'].v, label='Fixed Point')\n",
                "\n",
                "ax.ticklabel_format(style='sci', axis='y', scilimits=(0,0))\n",
                "ax.set_ylim(0, 2.4e5)\n",
                "ax.set_yticks([0.4e5 * i for i in range(7)])\n",
                "ax.set_title(label)\n",
                "ax.set_xlabel('State')\n",
                "ax.set_ylabel(r'Value $\\times\\ (-1)$')\n",
                "plt.legend(loc=(0.7, 0.2))\n",
                "plt.show()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "### Value iteration with span-based termination"
        },
        {
            "cell_type": "code",
            "execution_count": 32,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 576x360 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "label = 'Value iteration with span-based termination'\n",
                "iters = [1, 10, 15, 20]\n",
                "v = np.zeros(ddp.num_states)\n",
                "\n",
                "fig, ax = plt.subplots(figsize=(8,5))\n",
                "for i in range(iters[-1]):\n",
                "    u = ddp.bellman_operator(v)\n",
                "    if i+1 in iters:\n",
                "        diff = u - v\n",
                "        w = u + ((diff.max() + diff.min()) / 2) * ddp.beta / (1 - ddp.beta)\n",
                "        ax.plot(-w, label='Iteration {0}'.format(i+1))\n",
                "    v = u\n",
                "ax.plot(-results['Policy iteration'].v, label='Fixed Point')\n",
                "\n",
                "ax.ticklabel_format(style='sci', axis='y', scilimits=(0,0))\n",
                "ax.set_ylim(1.0e5, 2.4e5)\n",
                "ax.set_yticks([1.0e5+0.2e5 * i for i in range(8)])\n",
                "ax.set_title(label)\n",
                "ax.set_xlabel('State')\n",
                "ax.set_ylabel(r'Value $\\times\\ (-1)$')\n",
                "plt.legend(loc=(0.7, 0.2))\n",
                "plt.show()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "### Policy iteration"
        },
        {
            "cell_type": "code",
            "execution_count": 33,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 576x360 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "label = 'Policy iteration'\n",
                "iters = [1, 2, 3]\n",
                "v_init = np.zeros(ddp.num_states)\n",
                "\n",
                "fig, ax = plt.subplots(figsize=(8,5))\n",
                "sigma = ddp.compute_greedy(v_init)\n",
                "for i in range(iters[-1]):\n",
                "    # Policy evaluation\n",
                "    v_sigma = ddp.evaluate_policy(sigma)\n",
                "    if i+1 in iters:\n",
                "        ax.plot(-v_sigma, label='Iteration {0}'.format(i+1))\n",
                "    # Policy improvement\n",
                "    new_sigma = ddp.compute_greedy(v_sigma)\n",
                "    sigma = new_sigma\n",
                "ax.plot(-results['Policy iteration'].v, label='Fixed Point')\n",
                "\n",
                "ax.ticklabel_format(style='sci', axis='y', scilimits=(0,0))\n",
                "ax.set_ylim(1e5, 4.2e5)\n",
                "ax.set_yticks([1e5 + 0.4e5 * i for i in range(9)])\n",
                "ax.set_title(label)\n",
                "ax.set_xlabel('State')\n",
                "ax.set_ylabel(r'Value $\\times\\ (-1)$')\n",
                "plt.legend(loc=4)\n",
                "plt.show()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "### Modified policy iteration"
        },
        {
            "cell_type": "code",
            "execution_count": 34,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 576x360 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "label = 'Modified policy iteration'\n",
                "iters = [1, 2, 3, 4]\n",
                "v = np.zeros(ddp.num_states)\n",
                "k = 20 #- 1\n",
                "\n",
                "fig, ax = plt.subplots(figsize=(8,5))\n",
                "for i in range(iters[-1]):\n",
                "    # Policy improvement\n",
                "    sigma = ddp.compute_greedy(v)\n",
                "    u = ddp.bellman_operator(v)\n",
                "    if i == results[label].num_iter-1:\n",
                "        diff = u - v\n",
                "        break\n",
                "    # Partial policy evaluation with k=20 iterations\n",
                "    for j in range(k):\n",
                "        u = ddp.T_sigma(sigma)(u)\n",
                "    v = u\n",
                "    if i+1 in iters:\n",
                "        ax.plot(-v, label='Iteration {0}'.format(i+1))\n",
                "ax.plot(-results['Policy iteration'].v, label='Fixed Point')\n",
                "\n",
                "ax.ticklabel_format(style='sci', axis='y', scilimits=(0,0))\n",
                "ax.set_ylim(0, 2.8e5)\n",
                "ax.set_yticks([0.4e5 * i for i in range(8)])\n",
                "ax.set_title(label)\n",
                "ax.set_xlabel('State')\n",
                "ax.set_ylabel(r'Value $\\times\\ (-1)$')\n",
                "plt.legend(loc=4)\n",
                "plt.show()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "## Increasing the discount factor"
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Let us consider the case with a discount factor closer to $1$, $\\beta = 0.9999$."
        },
        {
            "cell_type": "code",
            "execution_count": 35,
            "metadata": {},
            "outputs": [],
            "source": [
                "ddp.beta = 0.9999"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 36,
            "metadata": {},
            "outputs": [],
            "source": [
                "v_init = np.zeros(ddp.num_states)\n",
                "epsilon = 1164\n",
                "ddp.max_iter = 10**5 * 2\n",
                "\n",
                "results_9999 = {}\n",
                "\n",
                "for i in range(4):\n",
                "    k = 20 if labels[i] == 'Modified policy iteration' else 0\n",
                "    results_9999[labels[i]] = \\\n",
                "        ddp.solve(method=methods[i], v_init=v_init, epsilon=epsilon, k=k)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 37,
            "metadata": {},
            "outputs": [],
            "source": [
                "df_9999 = pd.DataFrame(index=labels, columns=columns)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "The numbers of iterations:"
        },
        {
            "cell_type": "code",
            "execution_count": 38,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "118900 \t(Value iteration)\n",
                        "288 \t(Value iteration with span-based termination)\n",
                        "7 \t(Policy iteration)\n",
                        "18 \t(Modified policy iteration)\n"
                    ]
                }
            ],
            "source": [
                "for label in labels:\n",
                "    print(results_9999[label].num_iter, '\\t' + '(' + label + ')')\n",
                "    df_9999.loc[label, columns[0]] = results_9999[label].num_iter"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Policy iteration gives the optimal policy:"
        },
        {
            "cell_type": "code",
            "execution_count": 39,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
                        " 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
                        " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]\n"
                    ]
                }
            ],
            "source": [
                "print(results_9999['Policy iteration'].sigma)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Takes action 1 (\"replace\") if and only if $s \\geq \\bar{\\gamma}$, where $\\bar{\\gamma}$ is equal to:"
        },
        {
            "cell_type": "code",
            "execution_count": 40,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "43"
                        ]
                    },
                    "execution_count": 40,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "(1-results_9999['Policy iteration'].sigma).sum()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Check that the other methods gave the correct answer:"
        },
        {
            "cell_type": "code",
            "execution_count": 41,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "True\n",
                        "True\n",
                        "True\n"
                    ]
                }
            ],
            "source": [
                "for result in results_9999.values():\n",
                "    if result != results_9999['Policy iteration']:\n",
                "        print(np.array_equal(result.sigma, results_9999['Policy iteration'].sigma))"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "$\\lVert v - v_{\\mathrm{pi}}\\rVert$:"
        },
        {
            "cell_type": "code",
            "execution_count": 42,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "581.9987735897303 \t(Value iteration)\n",
                        "4.377685442566872 \t(Value iteration with span-based termination)\n",
                        "0.0 \t(Policy iteration)\n",
                        "4.454900473356247 \t(Modified policy iteration)\n"
                    ]
                }
            ],
            "source": [
                "for label in labels:\n",
                "    diff_pi = \\\n",
                "        np.abs(results_9999[label].v - results_9999['Policy iteration'].v).max()\n",
                "    print(diff_pi, '\\t' + '(' + label + ')')\n",
                "    df_9999.loc[label, columns[2]] = diff_pi"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "$\\lVert v - T(v)\\rVert$:"
        },
        {
            "cell_type": "code",
            "execution_count": 43,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "0.058199912309646606 \t(Value iteration)\n",
                        "0.05580410361289978 \t(Value iteration with span-based termination)\n",
                        "4.470348358154297e-08 \t(Policy iteration)\n",
                        "0.052891805768013 \t(Modified policy iteration)\n"
                    ]
                }
            ],
            "source": [
                "for label in labels:\n",
                "    v = results_9999[label].v\n",
                "    diff_max = \\\n",
                "        np.abs(v - ddp.bellman_operator(v)).max()\n",
                "    print(diff_max, '\\t' + '(' + label + ')')\n",
                "    df_9999.loc[label, columns[4]] = diff_max"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "$\\overline{b} - \\underline{b}$:"
        },
        {
            "cell_type": "code",
            "execution_count": 44,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "0.00044699013233189737 \t(Value iteration)\n",
                        "1160.3753065593887 \t(Value iteration with span-based termination)\n",
                        "1099.686026855493 \t(Modified policy iteration)\n"
                    ]
                }
            ],
            "source": [
                "for i in range(4):\n",
                "    if labels[i] != 'Policy iteration':\n",
                "        k = 20 if labels[i] == 'Modified policy iteration' else 0\n",
                "        res = ddp.solve(method=methods[i], v_init=v_init, k=k,\n",
                "                        max_iter=results_9999[labels[i]].num_iter-1)\n",
                "        diff = ddp.bellman_operator(res.v) - res.v\n",
                "        diff_span = (diff.max() - diff.min()) * ddp.beta / (1 - ddp.beta)\n",
                "        print(diff_span, '\\t' + '(' + labels[i] + ')')\n",
                "        df_9999.loc[labels[i], columns[3]] = diff_span"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "For policy iteration:"
        },
        {
            "cell_type": "code",
            "execution_count": 45,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "0.0005959868431091965 \t(Policy iteration)\n"
                    ]
                }
            ],
            "source": [
                "label = 'Policy iteration'\n",
                "v = results_9999[label].v\n",
                "diff = ddp.bellman_operator(v) - v\n",
                "diff_span = (diff.max() - diff.min()) * ddp.beta / (1 - ddp.beta)\n",
                "print(diff_span, '\\t' + '(' + label + ')')\n",
                "df_9999.loc[label, columns[3]] = diff_span"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 46,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Value iteration\n",
                        "4.5 s ± 19.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
                        "Value iteration with span-based termination\n",
                        "19.2 ms ± 559 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
                        "Policy iteration\n",
                        "1.76 ms ± 49.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
                        "Modified policy iteration\n",
                        "4.6 ms ± 24.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
                    ]
                }
            ],
            "source": [
                "for i in range(4):\n",
                "    k = 20 if labels[i] == 'Modified policy iteration' else 0\n",
                "    print(labels[i])\n",
                "    t = %timeit -o ddp.solve(method=methods[i], v_init=v_init, epsilon=epsilon, k=k)\n",
                "    df_9999.loc[labels[i], columns[1]] = t.best"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 47,
            "metadata": {
                "scrolled": true
            },
            "outputs": [
                {
                    "data": {
                        "text/html": [
                            "<div>\n",
                            "<style scoped>\n",
                            "    .dataframe tbody tr th:only-of-type {\n",
                            "        vertical-align: middle;\n",
                            "    }\n",
                            "\n",
                            "    .dataframe tbody tr th {\n",
                            "        vertical-align: top;\n",
                            "    }\n",
                            "\n",
                            "    .dataframe thead th {\n",
                            "        text-align: right;\n",
                            "    }\n",
                            "</style>\n",
                            "<table border=\"1\" class=\"dataframe\">\n",
                            "  <thead>\n",
                            "    <tr style=\"text-align: right;\">\n",
                            "      <th></th>\n",
                            "      <th>Iterations</th>\n",
                            "      <th>Time (second)</th>\n",
                            "      <th>$\\lVert v - v_{\\mathrm{pi}} \\rVert$</th>\n",
                            "      <th>$\\overline{b} - \\underline{b}$</th>\n",
                            "      <th>$\\lVert v - T(v)\\rVert$</th>\n",
                            "    </tr>\n",
                            "  </thead>\n",
                            "  <tbody>\n",
                            "    <tr>\n",
                            "      <th>Value iteration</th>\n",
                            "      <td>118900</td>\n",
                            "      <td>4.46009</td>\n",
                            "      <td>581.999</td>\n",
                            "      <td>0.00044699</td>\n",
                            "      <td>0.0581999</td>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>Value iteration with span-based termination</th>\n",
                            "      <td>288</td>\n",
                            "      <td>0.0187313</td>\n",
                            "      <td>4.37769</td>\n",
                            "      <td>1160.38</td>\n",
                            "      <td>0.0558041</td>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>Policy iteration</th>\n",
                            "      <td>7</td>\n",
                            "      <td>0.00171783</td>\n",
                            "      <td>0</td>\n",
                            "      <td>0.000595987</td>\n",
                            "      <td>4.47035e-08</td>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>Modified policy iteration</th>\n",
                            "      <td>18</td>\n",
                            "      <td>0.00454525</td>\n",
                            "      <td>4.4549</td>\n",
                            "      <td>1099.69</td>\n",
                            "      <td>0.0528918</td>\n",
                            "    </tr>\n",
                            "  </tbody>\n",
                            "</table>\n",
                            "</div>"
                        ],
                        "text/plain": [
                            "                                            Iterations Time (second)  \\\n",
                            "Value iteration                                 118900       4.46009   \n",
                            "Value iteration with span-based termination        288     0.0187313   \n",
                            "Policy iteration                                     7    0.00171783   \n",
                            "Modified policy iteration                           18    0.00454525   \n",
                            "\n",
                            "                                            $\\lVert v - v_{\\mathrm{pi}} \\rVert$  \\\n",
                            "Value iteration                                                         581.999   \n",
                            "Value iteration with span-based termination                             4.37769   \n",
                            "Policy iteration                                                              0   \n",
                            "Modified policy iteration                                                4.4549   \n",
                            "\n",
                            "                                            $\\overline{b} - \\underline{b}$  \\\n",
                            "Value iteration                                                 0.00044699   \n",
                            "Value iteration with span-based termination                        1160.38   \n",
                            "Policy iteration                                               0.000595987   \n",
                            "Modified policy iteration                                          1099.69   \n",
                            "\n",
                            "                                            $\\lVert v - T(v)\\rVert$  \n",
                            "Value iteration                                           0.0581999  \n",
                            "Value iteration with span-based termination               0.0558041  \n",
                            "Policy iteration                                        4.47035e-08  \n",
                            "Modified policy iteration                                 0.0528918  "
                        ]
                    },
                    "execution_count": 47,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "df_9999"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 48,
            "metadata": {
                "scrolled": false
            },
            "outputs": [
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 576x360 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 576x360 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "df_time = pd.DataFrame(index=labels)\n",
                "df_time[r'$\\beta = 0.95$'] = df[columns[1]]\n",
                "df_time[r'$\\beta = 0.9999$'] = df_9999[columns[1]]\n",
                "second_max = df_time[r'$\\beta = 0.9999$'][1:].max()\n",
                "\n",
                "for xlim in [None, (0, second_max*1.2)]:\n",
                "    ax = df_time.loc[reversed(labels)][df_time.columns[::-1]].plot(\n",
                "        kind='barh', legend='reverse', xlim=xlim, figsize=(8,5)\n",
                "    )\n",
                "    ax.set_xlabel('Time (second)')"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 49,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Darwin-16.7.0-x86_64-i386-64bit\n"
                    ]
                }
            ],
            "source": [
                "import platform\n",
                "print(platform.platform())"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 50,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "3.6.5 |Anaconda, Inc.| (default, Apr 26 2018, 08:42:37) \n",
                        "[GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)]\n"
                    ]
                }
            ],
            "source": [
                "import sys\n",
                "print(sys.version)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 51,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "1.14.3\n"
                    ]
                }
            ],
            "source": [
                "print(np.__version__)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": []
        }
    ],
    "metadata": {
        "kernelspec": {
            "display_name": "Python 3",
            "language": "python",
            "name": "python3"
        },
        "language_info": {
            "codemirror_mode": {
                "name": "ipython",
                "version": 3
            },
            "file_extension": ".py",
            "mimetype": "text/x-python",
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
            "version": "3.6.5"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 1
}