ipynb/chris_conlon-post_estimation.ipynb

{
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "# Post-Estimation Tutorial"
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "'0.7.0'"
                        ]
                    },
                    "execution_count": 1,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "%matplotlib inline\n",
                "\n",
                "import pyblp\n",
                "import numpy as np\n",
                "import pandas as pd\n",
                "import matplotlib.pyplot as plt\n",
                "\n",
                "pyblp.options.digits = 2\n",
                "pyblp.options.verbose = False\n",
                "pyblp.__version__"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "This tutorial covers several features of `pyblp` which are available after estimation including:\n\n1. Calculating elasticities and diversion ratios.\n2. Calculating marginal costs and markups.\n3. Computing the effects of mergers: prices, shares, and HHI.\n4. Using a parametric bootstrap to estimate standard errors.\n5. Estimating optimal instruments.\n\n\n## Problem Results\n\nAs in the [fake cereal tutorial](nevo.ipynb), we'll first solve the fake cereal problem from [Nevo (2000)](https://pyblp.readthedocs.io/en/stable/references.html#nevo-2000). We load the fake data and estimate the model as in the previous tutorial. We output the setup of the model to confirm we have correctly configured the [`Problem`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.Problem.html#pyblp.Problem)"
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "Dimensions:\n",
                            "=================================================\n",
                            " T    N     F    I     K1    K2    D    MD    ED \n",
                            "---  ----  ---  ----  ----  ----  ---  ----  ----\n",
                            "94   2256   5   1880   1     4     4    20    1  \n",
                            "=================================================\n",
                            "\n",
                            "Formulations:\n",
                            "===================================================================\n",
                            "       Column Indices:           0           1           2      3  \n",
                            "-----------------------------  ------  --------------  -----  -----\n",
                            " X1: Linear Characteristics    prices                              \n",
                            "X2: Nonlinear Characteristics    1         prices      sugar  mushy\n",
                            "       d: Demographics         income  income_squared   age   child\n",
                            "==================================================================="
                        ]
                    },
                    "execution_count": 1,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "product_data = pd.read_csv(pyblp.data.NEVO_PRODUCTS_LOCATION)\n",
                "agent_data = pd.read_csv(pyblp.data.NEVO_AGENTS_LOCATION)\n",
                "product_formulations = (\n",
                "   pyblp.Formulation('0 + prices', absorb='C(product_ids)'),\n",
                "   pyblp.Formulation('1 + prices + sugar + mushy')\n",
                ")\n",
                "agent_formulation = pyblp.Formulation('0 + income + income_squared + age + child')\n",
                "problem = pyblp.Problem(product_formulations, product_data, agent_formulation, agent_data)\n",
                "problem"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "We'll solve the problem in the same way as before. The [`Problem.solve`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.Problem.solve.html#pyblp.Problem.solve) method returns a [`ProblemResults`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.html#pyblp.ProblemResults) class, which displays basic estimation results. The results that are displayed are simply formatted information extracted from various class attributes such as [`ProblemResults.sigma`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.html#pyblp.ProblemResults.sigma) and [`ProblemResults.sigma_se`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.html#pyblp.ProblemResults.sigma_se)."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "Problem Results Summary:\n",
                            "========================================================================================================================\n",
                            "                                                                                                   Smallest    Largest  \n",
                            "Computation  GMM   Optimization   Objective   Fixed Point  Contraction  Objective    Gradient      Hessian     Hessian  \n",
                            "   Time      Step   Iterations   Evaluations  Iterations   Evaluations    Value    Infinity Norm  Eigenvalue  Eigenvalue\n",
                            "-----------  ----  ------------  -----------  -----------  -----------  ---------  -------------  ----------  ----------\n",
                            " 00:02:06     1         51           58          46236       143503     +4.6E+00     +6.9E-06      +2.8E-05    +1.6E+04 \n",
                            "========================================================================================================================\n",
                            "\n",
                            "Nonlinear Coefficient Estimates (Robust SEs in Parentheses):\n",
                            "=====================================================================================================================\n",
                            "Sigma:      1         prices      sugar       mushy     |   Pi:      income    income_squared     age        child   \n",
                            "------  ----------  ----------  ----------  ----------  |  ------  ----------  --------------  ----------  ----------\n",
                            "  1      +5.6E-01    +0.0E+00    +0.0E+00    +0.0E+00   |    1      +2.3E+00      +0.0E+00      +1.3E+00    +0.0E+00 \n",
                            "        (+1.6E-01)                                      |          (+1.2E+00)                  (+6.3E-01)            \n",
                            "                                                        |                                                            \n",
                            "prices               +3.3E+00    +0.0E+00    +0.0E+00   |  prices   +5.9E+02      -3.0E+01      +0.0E+00    +1.1E+01 \n",
                            "                    (+1.3E+00)                          |          (+2.7E+02)    (+1.4E+01)                (+4.1E+00)\n",
                            "                                                        |                                                            \n",
                            "sugar                            -5.8E-03    +0.0E+00   |  sugar    -3.8E-01      +0.0E+00      +5.2E-02    +0.0E+00 \n",
                            "                                (+1.4E-02)              |          (+1.2E-01)                  (+2.6E-02)            \n",
                            "                                                        |                                                            \n",
                            "mushy                                        +9.3E-02   |  mushy    +7.5E-01      +0.0E+00      -1.4E+00    +0.0E+00 \n",
                            "                                            (+1.9E-01)  |          (+8.0E-01)                  (+6.7E-01)            \n",
                            "=====================================================================================================================\n",
                            "\n",
                            "Beta Estimates (Robust SEs in Parentheses):\n",
                            "==========\n",
                            "  prices  \n",
                            "----------\n",
                            " -6.3E+01 \n",
                            "(+1.5E+01)\n",
                            "=========="
                        ]
                    },
                    "execution_count": 1,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "initial_sigma = np.diag([0.3302, 2.4526, 0.0163, 0.2441])\n",
                "initial_pi = [\n",
                "  [ 5.4819,  0,      0.2037,  0     ],\n",
                "  [15.8935, -1.2000, 0,       2.6342],\n",
                "  [-0.2506,  0,      0.0511,  0     ],\n",
                "  [ 1.2650,  0,     -0.8091,  0     ]\n",
                "]\n",
                "bfgs = pyblp.Optimization('bfgs')\n",
                "results = problem.solve(\n",
                "    initial_sigma,\n",
                "    initial_pi,\n",
                "    optimization=bfgs,\n",
                "    method='1s'\n",
                ")\n",
                "results"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Additional post-estimation outputs can be computed with [`ProblemResults`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.html#pyblp.ProblemResults) methods.\n\n\n## Elasticities and Diversion Ratios\n\nWe can estimate elasticities, $\\varepsilon$, and diversion ratios, $\\mathscr{D}$, with [`ProblemResults.compute_elasticities`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.compute_elasticities.html#pyblp.ProblemResults.compute_elasticities) and [`ProblemResults.compute_diversion_ratios`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.compute_diversion_ratios.html#pyblp.ProblemResults.compute_diversion_ratios).\n\nAs a reminder, elasticities in each market are\n\n$$\\varepsilon_{jk} = \\frac{x_k}{s_j}\\frac{\\partial s_j}{\\partial x_k}.$$\n\nDiversion ratios are\n\n$$\\mathscr{D}_{jk} = -\\frac{\\partial s_k}{\\partial x_j} \\Big/ \\frac{\\partial s_j}{\\partial x_j}.$$\n\nFollowing [Conlon and Mortimer (2018)](https://pyblp.readthedocs.io/en/stable/references.html#conlon-and-mortimer-2018), we report the diversion to the outside good $D_{j0}$ on the diagonal instead of $D_{jj}=-1$."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [],
            "source": [
                "elasticities = results.compute_elasticities()\n",
                "diversions = results.compute_diversion_ratios()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Post-estimation outputs are computed for each market and stacked. We'll use [matplotlib](https://matplotlib.org/) functions to display the matrices associated with a single market."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 288x288 with 2 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "single_market = product_data['market_ids'] == 'C01Q1'\n",
                "plt.colorbar(plt.matshow(elasticities[single_market]));"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 288x288 with 2 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "plt.colorbar(plt.matshow(diversions[single_market]));"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "The diagonal of the first image consists of own elasticities and the diagonal of the second image consists of diversion ratios to the outside good. As one might expect, own price elasticities are large and negative while cross-price elasticities are positive but much smaller.\n\nElasticities and diversion ratios can be computed with respect to variables other than `prices` with the `name` argument of [`ProblemResults.compute_elasticities`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.compute_elasticities.html#pyblp.ProblemResults.compute_elasticities) and [`ProblemResults.compute_diversion_ratios`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.compute_diversion_ratios.html#pyblp.ProblemResults.compute_diversion_ratios). Additionally, [`ProblemResults.compute_long_run_diversion_ratios`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.compute_long_run_diversion_ratios.html#pyblp.ProblemResults.compute_long_run_diversion_ratios) can be used to used to understand substitution when products are eliminated from the choice set.\n\nThe convenience methods [`ProblemResults.extract_diagonals`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.extract_diagonals.html#pyblp.ProblemResults.extract_diagonals) and [`ProblemResults.extract_diagonal_means`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.extract_diagonal_means.html#pyblp.ProblemResults.extract_diagonal_means) can be used to extract information about own elasticities of demand from elasticity matrices."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [],
            "source": [
                "means = results.extract_diagonal_means(elasticities)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "An alternative to summarizing full elasticity matrices is to use [`ProblemResults.compute_aggregate_elasticities`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.compute_aggregate_elasticities.html#pyblp.ProblemResults.compute_aggregate_elasticities) to estimate aggregate elasticities of demand, $E$, in each market, which reflect the change in total sales under a proportional sales tax of some factor."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [],
            "source": [
                "aggregates = results.compute_aggregate_elasticities(factor=0.1)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Since demand for an entire product category is generally less elastic than the average elasticity of individual products, mean own elasticities are generally larger in magnitude than aggregate elasticities."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 432x288 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "plt.hist(\n",
                "    [means.flatten(), aggregates.flatten()], \n",
                "    color=['red', 'blue'], \n",
                "    bins=50\n",
                ");\n",
                "plt.legend(['Mean Own Elasticities', 'Aggregate Elasticities']);"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "## Marginal Costs and Markups\n\nTo compute marginal costs, $c$, the `product_data` passed to [`Problem`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.Problem.html#pyblp.Problem) must have had a `firm_ids` field. Since we included firm IDs when configuring the problem, we can use [`ProblemResults.compute_costs`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.compute_costs.html#pyblp.ProblemResults.compute_costs)."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 432x288 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "costs = results.compute_costs()\n",
                "plt.hist(costs, bins=50);\n",
                "plt.legend([\"Marginal Costs\"]);"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Other methods that compute supply-side outputs often compute marginal costs themselves. For example, [`ProblemResults.compute_markups`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.compute_markups.html#pyblp.ProblemResults.compute_markups) will compute marginal costs when estimating markups, $\\mathscr{M}$, but computation can be sped up if we just use our pre-computed values."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAFWhJREFUeJzt3X+Q3XV97/HnuxIbiSA/stDc/OhCDQLFNPGuBEEtSKEkVaKFeMkUGgRdYMSxtlxNqVaGTmeYNsDQseqNJZPE0QC9/ApKf3C1lMsFhA2haTCm5ccWt2RIDN6oE+I15H3/ON/Ek7jJnpwfe7KfPB8zO+ecz/fX+5PdvPa7n/M9n29kJpKkcv1StwuQJHWWQS9JhTPoJalwBr0kFc6gl6TCGfSSVDiDXpIKZ9BLUuEMekkq3GHdLgBg4sSJ2dvb2+0yJGlMWb169Q8ys2ek9Q6KoO/t7WVgYKDbZUjSmBIR/9HIeg7dSFLhDHpJKpxBL0mFOyjG6CUdOn72s58xNDTE9u3bu13KmDF+/HimTJnCuHHjmtreoJc0qoaGhjjiiCPo7e0lIrpdzkEvM9myZQtDQ0OccMIJTe3DoRtJo2r79u0ce+yxhnyDIoJjjz22pb+ADHpJo86QPzCt/nsZ9JJUOMfoJXVV76JvtnV/gzf9zojrRASXXnopX/3qVwHYsWMHkyZNYvbs2XzjG99o+FgPP/wwixcvPqBtusGg74B9/eA28gMoqfMmTJjAunXreO2113jTm97EQw89xOTJkw9oHzt27OhQde3n0I2kQ9KcOXP45jdrJ2UrV65kwYIFu5c9+eSTnHnmmcyaNYszzzyTDRs2ALBs2TLmz5/PBz7wAc4///w99vfUU08xa9YsXnjhBW644QYWL168e9lpp53G4OAgg4ODnHzyySxcuJAZM2Zw8cUXs23bNgAWLVrEqaeeyowZM7juuuva2leDXtIh6ZJLLuGOO+5g+/btrF27ltmzZ+9edvLJJ/PII4+wZs0abrzxRq6//vrdyx5//HGWL1/Ot7/97d1tjz32GFdffTX3338/J5544n6Pu2HDBvr7+1m7di1HHnkkX/ziF3n11Ve59957efbZZ1m7di2f/exn29pXg17SIWnGjBkMDg6ycuVK5s6du8eyrVu3Mn/+fE477TQ+9alP8eyzz+5edt5553HMMcfsfr1+/Xr6+/t54IEHmDZt2ojHnTp1KmeddRYAl156KY8++ihHHnkk48eP56Mf/Sj33HMPhx9+eJt6WWPQSzpkXXjhhVx33XV7DNsAfO5zn+Occ85h3bp1PPDAA3tcwz5hwoQ91p00aRLjx49nzZo1u9sOO+wwdu7cuft1/fZ7XyoZERx22GE8+eSTXHTRRdx3331ccMEFbenf7nraujdJGkOuuOIK3vKWt/D2t7+dhx9+eHf71q1bd785u2zZsv3u46ijjuL222/n/PPPZ8KECZx99tn09vbuvhLn6aef5sUXX9y9/ksvvcTjjz/Ou971LlauXMm73/1ufvKTn7Bt2zbmzp3LGWecwVvf+ta29nPEoI+IqcAK4FeAncCSzLwtIo4B7gR6gUHgw5n5w6j9uroNmAtsAy7PzKfbWrWkYnTzarQpU6bwyU9+8hfaP/3pT7Nw4UJuueUW3ve+9424n+OPP54HHniAOXPmsHTpUi666CJWrFjBzJkzeec738lJJ520e91TTjmF5cuXc9VVVzF9+nSuueYatm7dyrx589i+fTuZya233trWfkZm7n+FiEnApMx8OiKOAFYDHwQuB17NzJsiYhFwdGZ+JiLmAp+gFvSzgdsyc/Y+dg9AX19flnTjES+vlPZt/fr1nHLKKd0uoysGBwd5//vfz7p16w542+H+3SJidWb2jbTtiGP0mblx1xl5Zv4YWA9MBuYBy6vVllMLf6r2FVnzBHBU9ctCktQFBzRGHxG9wCzgO8DxmbkRar8MIuK4arXJwPfrNhuq2ja2Wmy3eIYuqR16e3ubOptvVcNX3UTEm4G7gT/IzB/tb9Vh2n5hfCgi+iNiICIGNm/e3GgZkgow0pCx9tTqv1dDZ/QRMY5ayH8tM++pml+JiEnV2fwkYFPVPgRMrdt8CvDy3vvMzCXAEqiN0TdZf1e1e44O6VAwfvx4tmzZ4lTFDdo1H/348eOb3kcjV90EcDuwPjNvqVu0ClgI3FQ93l/Xfm1E3EHtzditu4Z4JGnKlCkMDQ3hX/KN23WHqWY1ckZ/FnAZ8K8R8UzVdj21gL8rIq4EXgLmV8sepHbFzXPULq/8SNPVSSrOuHHjmr5TkpozYtBn5qMMP+4OcO4w6yfw8RbrkiS1iVMgSFLhDHpJKpxBL0mFM+glqXAGvSQVzqCXpMI5H/0ocs4cSd3gGb0kFc6gl6TCGfSSVDiDXpIKZ9BLUuEMekkqnEEvSYUz6CWpcAa9JBVuxKCPiKURsSki1tW13RkRz1Rfg7vuPBURvRHxWt2yL3eyeEnSyBqZAmEZ8AVgxa6GzPxvu55HxM3A1rr1n8/Mme0qUJLUmkZuJfhIRPQOt6y6cfiHgfe1tyxJUru0Okb/HuCVzPz3urYTImJNRPxzRLxnXxtGRH9EDETEgHeDl6TOaTXoFwAr615vBKZl5izgD4GvR8SRw22YmUsysy8z+3p6elosQ5K0L00HfUQcBvwucOeutsz8aWZuqZ6vBp4HTmq1SElS81qZj/63gO9l5tCuhojoAV7NzNcj4kRgOvBCizUWz3nqJXVSI5dXrgQeB94WEUMRcWW16BL2HLYBeC+wNiL+BfifwNWZ+Wo7C5YkHZhGrrpZsI/2y4dpuxu4u/WyJEnt4idjJalwBr0kFc6gl6TCGfSSVDiDXpIKZ9BLUuEMekkqnEEvSYUz6CWpcAa9JBXOoJekwrUye2Vx9jWLpCSNZZ7RS1LhDHpJKpxBL0mFa+TGI0sjYlNErKtruyEi/jMinqm+5tYt++OIeC4iNkTEb3eqcElSYxp5M3YZ8AVgxV7tt2bm4vqGiDiV2p2nfh34L8D/ioiTMvP1NtR6yPEWg5LaYcQz+sx8BGj0doDzgDuqm4S/CDwHnN5CfZKkFrUyRn9tRKythnaOrtomA9+vW2eoapMkdUmzQf8l4NeAmcBG4OaqPYZZN4fbQUT0R8RARAxs3ry5yTIkSSNpKugz85XMfD0zdwJf4efDM0PA1LpVpwAv72MfSzKzLzP7enp6milDktSApoI+IibVvfwQsOuKnFXAJRHxyxFxAjAdeLK1EiVJrRjxqpuIWAmcDUyMiCHg88DZETGT2rDMIHAVQGY+GxF3Ad8FdgAf94obSequEYM+MxcM03z7ftb/c+DPWylKktQ+fjJWkgpn0EtS4Qx6SSqcQS9JhTPoJalwBr0kFc6gl6TCGfSSVDiDXpIKZ9BLUuEMekkqnEEvSYUz6CWpcAa9JBXOoJekwhn0klS4EYM+IpZGxKaIWFfX9pcR8b2IWBsR90bEUVV7b0S8FhHPVF9f7mTxkqSRNXJGvwy4YK+2h4DTMnMG8G/AH9ctez4zZ1ZfV7enTElSsxq5leAjEdG7V9s/1r18Ari4vWV1Vu+ib3a7BEkaNe0Yo78C+Lu61ydExJqI+OeIeE8b9i9JasGIZ/T7ExF/AuwAvlY1bQSmZeaWiPivwH0R8euZ+aNhtu0H+gGmTZvWShmSpP1o+ow+IhYC7wd+LzMTIDN/mplbquergeeBk4bbPjOXZGZfZvb19PQ0W4YkaQRNBX1EXAB8BrgwM7fVtfdExBuq5ycC04EX2lGoJKk5Iw7dRMRK4GxgYkQMAZ+ndpXNLwMPRQTAE9UVNu8FboyIHcDrwNWZ+WqHapckNaCRq24WDNN8+z7WvRu4u9WitH/7u2po8KbfGcVKJI0FfjJWkgpn0EtS4Qx6SSqcQS9JhTPoJalwBr0kFc6gl6TCGfSSVDiDXpIK19LslTr47OtTs35iVjp0eUYvSYUz6CWpcAa9JBXOoJekwhn0klQ4g16SCtdQ0EfE0ojYFBHr6tqOiYiHIuLfq8ejq/aIiL+KiOciYm1EvKNTxUuSRtbodfTLgC8AK+raFgHfysybImJR9fozwBxq94qdDswGvlQ9qou8vl46dDV0Rp+ZjwB73/t1HrC8er4c+GBd+4qseQI4KiImtaNYSdKBa2WM/vjM3AhQPR5XtU8Gvl+33lDVtoeI6I+IgYgY2Lx5cwtlSJL2pxNvxsYwbfkLDZlLMrMvM/t6eno6UIYkCVoL+ld2DclUj5uq9iFgat16U4CXWziOJKkFrQT9KmBh9XwhcH9d++9XV9+cAWzdNcQjSRp9DV11ExErgbOBiRExBHweuAm4KyKuBF4C5lerPwjMBZ4DtgEfaXPNkqQD0FDQZ+aCfSw6d5h1E/h4K0VJktrHT8ZKUuEMekkqnEEvSYUz6CWpcAa9JBXOoJekwhn0klQ4g16SCmfQS1LhDHpJKpxBL0mFa/RWgiqUtxiUyucZvSQVzqCXpMIZ9JJUuKbH6CPibcCddU0nAn8KHAV8DNh1x+/rM/PBpiuUJLWk6aDPzA3ATICIeAPwn8C91O4odWtmLm5LhZKklrRr6OZc4PnM/I827U+S1CbtCvpLgJV1r6+NiLURsTQijm7TMSRJTWg56CPijcCFwN9WTV8Cfo3asM5G4OZ9bNcfEQMRMbB58+bhVpEktUE7zujnAE9n5isAmflKZr6emTuBrwCnD7dRZi7JzL7M7Ovp6WlDGZKk4bQj6BdQN2wTEZPqln0IWNeGY0iSmtTSFAgRcThwHnBVXfNfRMRMIIHBvZZJkkZZS0GfmduAY/dqu6yliiRJbeUnYyWpcAa9JBXOoJekwhn0klS4om88sq+bakjSoaTooFfzvPOUVA6HbiSpcAa9JBXOoJekwhn0klQ4g16SCmfQS1LhDHpJKpxBL0mFM+glqXAGvSQVruUpECJiEPgx8DqwIzP7IuIY4E6gl9pdpj6cmT9s9ViSpAPXrrluzsnMH9S9XgR8KzNviohF1evPtOlY6iLnwJHGnk4N3cwDllfPlwMf7NBxJEkjaEfQJ/CPEbE6IvqrtuMzcyNA9Xjc3htFRH9EDETEwObNm9tQhiRpOO0YujkrM1+OiOOAhyLie41slJlLgCUAfX192YY6JEnDaPmMPjNfrh43AfcCpwOvRMQkgOpxU6vHkSQ1p6Wgj4gJEXHErufA+cA6YBWwsFptIXB/K8eRJDWv1aGb44F7I2LXvr6emX8fEU8Bd0XElcBLwPwWjyNJalJLQZ+ZLwC/MUz7FuDcVvYtSWoPPxkrSYXz5uBqCz9IJR28PKOXpMIZ9JJUOINekgpn0EtS4Qx6SSqcQS9JhTPoJalwBr0kFc6gl6TCGfSSVDiDXpIKZ9BLUuGc1Ewd5WRnUvc1HfQRMRVYAfwKsBNYkpm3RcQNwMeAXXf8vj4zH2y1UB0a/MUgtV8rZ/Q7gD/KzKer2wmujoiHqmW3Zubi1suTJLWq6aDPzI3Axur5jyNiPTC5XYVJktqjLW/GRkQvMAv4TtV0bUSsjYilEXF0O44hSWpOy2/GRsSbgbuBP8jMH0XEl4A/A7J6vBm4Ypjt+oF+gGnTprVUw77GdSVJLZ7RR8Q4aiH/tcy8ByAzX8nM1zNzJ/AV4PThts3MJZnZl5l9PT09rZQhSdqPpoM+IgK4HVifmbfUtU+qW+1DwLrmy5MktaqVoZuzgMuAf42IZ6q264EFETGT2tDNIHBVSxWqSA63SaOnlatuHgVimEVeMy9JBxGnQJCkwhn0klQ4g16SCuekZlLFeXZUKs/oJalwBr0kFc6gl6TCOUavMeFAP2DluLr0c57RS1LhDHpJKpxBL0mFc4xehxwnVNOhxqCXRuAHqTTWOXQjSYXzjF5FcnhG+jmDXjpIOWSkdulY0EfEBcBtwBuAv8nMmzp1LKkb2vVXg8GtTutI0EfEG4C/Bs4DhoCnImJVZn63E8eT1F7+NVGWTp3Rnw48l5kvAETEHcA8wKCX9nKgfxm08/2HAw1ufwGMTZ0K+snA9+teDwGzO3QsSYVo15xGB+MvpG7WFJnZ/p1GzAd+OzM/Wr2+DDg9Mz9Rt04/0F+9fBuwoe2F7Gki8IMOH6Nb7NvYU2q/wL6Npl/NzJ6RVurUGf0QMLXu9RTg5foVMnMJsKRDx/8FETGQmX2jdbzRZN/GnlL7BfbtYNSpD0w9BUyPiBMi4o3AJcCqDh1LkrQfHTmjz8wdEXEt8A/ULq9cmpnPduJYkqT969h19Jn5IPBgp/bfhFEbJuoC+zb2lNovsG8HnY68GStJOng4qZkkFa64oI+ICyJiQ0Q8FxGLhln+hxHx3YhYGxHfiohf7UadzRipb3XrXRwRGRFj4uqARvoVER+uvm/PRsTXR7vGZjXw8zgtIv4pItZUP5Nzu1HngYqIpRGxKSLW7WN5RMRfVf1eGxHvGO0am9VA336v6tPaiHgsIn5jtGs8YJlZzBe1N36fB04E3gj8C3DqXuucAxxePb8GuLPbdberb9V6RwCPAE8Afd2uu03fs+nAGuDo6vVx3a67jX1bAlxTPT8VGOx23Q327b3AO4B1+1g+F/g7IIAzgO90u+Y29u3Mup/FOWOhb6Wd0e+eeiEz/x+wa+qF3TLznzJzW/XyCWrX+I8FI/at8mfAXwDbR7O4FjTSr48Bf52ZPwTIzE2jXGOzGulbAkdWz9/CXp83OVhl5iPAq/tZZR6wImueAI6KiEmjU11rRupbZj6262eRMZIhpQX9cFMvTN7P+ldSO+sYC0bsW0TMAqZm5jdGs7AWNfI9Owk4KSL+T0Q8Uc2MOhY00rcbgEsjYojaVWqfoAwH+n9xrBoTGVLafPQxTNuwlxVFxKVAH/CbHa2offbbt4j4JeBW4PLRKqhNGvmeHUZt+OZsamdP/zsiTsvM/9vh2lrVSN8WAMsy8+aIeBfw1apvOztfXkc1/H9xrIqIc6gF/bu7XctISjujH3HqBYCI+C3gT4ALM/Ono1Rbq0bq2xHAacDDETFIbVx01Rh4Q7aR79kQcH9m/iwzX6Q2L9L0UaqvFY307UrgLoDMfBwYT20+lbGuof+LY1VEzAD+BpiXmVu6Xc9ISgv6EadeqIY3/ge1kB8rY70wQt8yc2tmTszM3szspTZ2eGFmDnSn3IY1Ml3GfdTeRCciJlIbynlhVKtsTiN9ewk4FyAiTqEW9JtHtcrOWAX8fnX1zRnA1szc2O2i2iEipgH3AJdl5r91u55GFDV0k/uYeiEibgQGMnMV8JfAm4G/jQiAlzLzwq4V3aAG+zbmNNivfwDOj4jvAq8D/30snEU12Lc/Ar4SEZ+iNrRxeVaXcxzMImIltaG0idX7C58HxgFk5pepvd8wF3gO2AZ8pDuVHrgG+vanwLHAF6sM2ZEH+URnfjJWkgpX2tCNJGkvBr0kFc6gl6TCGfSSVDiDXpIKZ9BLUuEMekkqnEEvSYX7/1YNSrFocF3fAAAAAElFTkSuQmCC\n",
                        "text/plain": [
                            "<Figure size 432x288 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "markups = results.compute_markups(costs=costs)\n",
                "plt.hist(markups, bins=50);\n",
                "plt.legend([\"Markups\"]);"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "## Mergers\n\nBefore computing post-merger outputs, we'll supplement our pre-merger markups with some other outputs. We'll compute Herfindahl-Hirschman Indices, $\\text{HHI}$, with [`ProblemResults.compute_hhi`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.compute_hhi.html#pyblp.ProblemResults.compute_hhi); population-normalized gross expected profits, $\\pi$, with [`ProblemResults.compute_profits`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.compute_profits.html#pyblp.ProblemResults.compute_profits); and population-normalized consumer surpluses, $\\text{CS}$, with [`ProblemResults.compute_consumer_surpluses`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.compute_consumer_surpluses.html#pyblp.ProblemResults.compute_consumer_surpluses)."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [],
            "source": [
                "hhi = results.compute_hhi()\n",
                "profits = results.compute_profits(costs=costs)\n",
                "cs = results.compute_consumer_surpluses()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "To compute post-merger outputs, we'll create a new set of firm IDs that represent a merger of firms ``2`` and ``1``."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [],
            "source": [
                "product_data['merger_ids'] = product_data['firm_ids'].replace(2, 1)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "We can use [`ProblemResults.compute_approximate_prices`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.compute_approximate_prices.html#pyblp.ProblemResults.compute_approximate_prices) or [`ProblemResults.compute_prices`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.compute_prices.html#pyblp.ProblemResults.compute_prices) to estimate post-merger prices. The first method, which is discussed, for example, in [Nevo (1997)](https://pyblp.readthedocs.io/en/stable/references.html#nevo-1997), assumes that shares and their price derivatives are unaffected by the merger. The second method does not make these assumptions and iterates over the $\\zeta$-markup equation from [Morrow and Skerlos (2011)](https://pyblp.readthedocs.io/en/stable/references.html#morrow-and-skerlos-2011) to solve the full system of $J_t$ equations and $J_t$ unknowns in each market $t$. We'll use the latter, since it is fast enough for this example problem."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [],
            "source": [
                "changed_prices = results.compute_prices(\n",
                "    firm_ids=product_data['merger_ids'], \n",
                "    costs=costs\n",
                ")"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "If the problem was configured with more than two columns of firm IDs, we could estimate post-merger prices for the other mergers with the `firms_index` argument, which is by default `1`.\n\nWe'll compute post-merger shares with [`ProblemResults.compute_shares`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.compute_shares.html#pyblp.ProblemResults.compute_shares)."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [],
            "source": [
                "changed_shares = results.compute_shares(changed_prices)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Post-merger prices and shares are used to compute other post-merger outputs. For example, $\\text{HHI}$ increases."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 432x288 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "changed_hhi = results.compute_hhi(\n",
                "    firm_ids=product_data['merger_ids'],\n",
                "    shares=changed_shares\n",
                ")\n",
                "plt.hist(changed_hhi - hhi, bins=50);\n",
                "plt.legend([\"HHI Changes\"]);"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "Markups, $\\mathscr{M}$, and profits, $\\pi$, generally increase as well."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 432x288 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "changed_markups = results.compute_markups(changed_prices, costs)\n",
                "plt.hist(changed_markups - markups, bins=50);\n",
                "plt.legend([\"Markup Changes\"]);"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 432x288 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "changed_profits = results.compute_profits(changed_prices, changed_shares, costs)\n",
                "plt.hist(changed_profits - profits, bins=50);\n",
                "plt.legend([\"Profit Changes\"]);"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "On the other hand, consumer surpluses, $\\text{CS}$, generally decrease."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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\n",
                        "text/plain": [
                            "<Figure size 432x288 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "changed_cs = results.compute_consumer_surpluses(changed_prices)\n",
                "plt.hist(changed_cs - cs, bins=50);\n",
                "plt.legend([\"Consumer Surplus Changes\"]);"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "## Bootstrapping Results\n\nPost-estimation outputs can be informative, but they don't mean much without a sense sample-to-sample variability. One way to estimate confidence intervals for post-estimation outputs is with a standard bootstrap procedure:\n\n1. Construct a large number of bootstrap samples by sampling with replacement from the original product data.\n2. Initialize and solve a [`Problem`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.Problem.html#pyblp.Problem) for each bootstrap sample.\n3. Compute the desired post-estimation output for each bootstrapped [`ProblemResults`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.html#pyblp.ProblemResults) and from the resulting empirical distribution, construct boostrap confidence intervals.\n\nAlthough appealing because of its simplicity, the computational resources required for this procedure are often prohibatively expensive. Furthermore, human oversight of the optimization routine is often required to determine whether the routine ran into any problems and if it successfully converged. Human oversight of estimation for each bootstrapped problem is usually not feasible.\n\nA more reasonable alternative is a parametric bootstrap procedure:\n\n1. Construct a large number of draws from the estimated joint distribution of parameters.\n2. Compute the implied mean utility, $\\delta$, and shares, $s$, for each draw. If a supply side was estimated, also computed the implied marginal costs, $c$, and prices, $p$.\n3. Compute the desired post-estimation output under each of these parametric bootstrap samples. Again, from the resulting empirical distribution, construct boostrap confidence intervals.\n\nCompared to the standard bootstrap procedure, the parametric bootstrap requires far fewer computational resources, and is simple enough to not require human oversight of each bootstrap iteration. The primary complication to this procedure is that when supply is estimated, equilibrium prices and shares need to be computed for each parametric bootstrap sample by iterating over the $\\zeta$-markup equation from [Morrow and Skerlos (2011)](https://pyblp.readthedocs.io/en/stable/references.html#morrow-and-skerlos-2011). Although nontrivial, this fixed point iteration problem is much less demanding than the full optimization routine required to solve the BLP problem from the start.\n\nAn empirical distribution of results computed according to this parametric bootstrap procedure can be created with the [`ProblemResults.bootstrap`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.bootstrap.html#pyblp.ProblemResults.bootstrap) method, which returns a [`BootstrappedResults`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.BootstrappedResults.html#pyblp.BootstrappedResults) class that can be used just like [`ProblemResults`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.html#pyblp.ProblemResults) to compute various post-estimation outputs. The difference is that [`BootstrappedResults`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.BootstrappedResults.html#pyblp.BootstrappedResults) methods return arrays with an extra first dimension, along which bootstrapped results are stacked.\n\nWe'll construct 90% parametric bootstrap confidence intervals for estimated mean own elasticities in each market of the fake cereal problem. Usually, bootstrapped confidence intervals should be based on thousands of draws, but we'll only use a few for the sake of speed in this example."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "Bootstrapped Problem Results Summary:\n",
                            "======================\n",
                            "Computation  Bootstrap\n",
                            "   Time        Draws  \n",
                            "-----------  ---------\n",
                            " 00:00:24       100   \n",
                            "======================"
                        ]
                    },
                    "execution_count": 1,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "bootstrapped_results = results.bootstrap(draws=100, seed=0)\n",
                "bootstrapped_results"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "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>Lower Bound</th>\n",
                            "      <th>Mean Own Elasticity</th>\n",
                            "      <th>Upper Bound</th>\n",
                            "    </tr>\n",
                            "  </thead>\n",
                            "  <tbody>\n",
                            "    <tr>\n",
                            "      <th>C01Q1</th>\n",
                            "      <td>-14.06</td>\n",
                            "      <td>-0.81</td>\n",
                            "      <td>10.66</td>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>C01Q2</th>\n",
                            "      <td>-8.97</td>\n",
                            "      <td>-0.69</td>\n",
                            "      <td>7.54</td>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>C03Q1</th>\n",
                            "      <td>-11.64</td>\n",
                            "      <td>-0.55</td>\n",
                            "      <td>7.98</td>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>C03Q2</th>\n",
                            "      <td>-14.46</td>\n",
                            "      <td>-0.60</td>\n",
                            "      <td>6.47</td>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>C04Q1</th>\n",
                            "      <td>-12.00</td>\n",
                            "      <td>-0.68</td>\n",
                            "      <td>5.61</td>\n",
                            "    </tr>\n",
                            "  </tbody>\n",
                            "</table>\n",
                            "</div>"
                        ],
                        "text/plain": [
                            "       Lower Bound  Mean Own Elasticity  Upper Bound\n",
                            "C01Q1       -14.06                -0.81        10.66\n",
                            "C01Q2        -8.97                -0.69         7.54\n",
                            "C03Q1       -11.64                -0.55         7.98\n",
                            "C03Q2       -14.46                -0.60         6.47\n",
                            "C04Q1       -12.00                -0.68         5.61"
                        ]
                    },
                    "execution_count": 1,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "bounds = np.percentile(\n",
                "    bootstrapped_results.extract_diagonal_means(\n",
                "        bootstrapped_results.compute_elasticities()\n",
                "    ), \n",
                "    q=[10, 90], \n",
                "    axis=0\n",
                ")\n",
                "table = pd.DataFrame(index=problem.unique_market_ids, data={\n",
                "    'Lower Bound': bounds[0].flatten(), \n",
                "    'Mean Own Elasticity': aggregates.flatten(), \n",
                "    'Upper Bound': bounds[1].flatten()\n",
                "})\n",
                "table.round(2).head()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "## Optimal Instruments\n\nGiven a consistent estimate of $\\theta$, we may want to compute the optimal instruments of [Chamberlain (1987)](https://pyblp.readthedocs.io/en/stable/references.html#chamberlain-1987) and use them to re-solve the problem. Optimal instruments have been shown, for example, by [Reynaert and Verboven (2014)](https://pyblp.readthedocs.io/en/stable/references.html#reynaert-and-verboven-2014), to reduce bias, improve efficiency, and enhance stability of BLP estimates.\n\nThe [`ProblemResults.compute_optimal_instruments`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.ProblemResults.compute_optimal_instruments.html#pyblp.ProblemResults.compute_optimal_instruments) method computes the expected Jacobians that comprise the optimal instruments by integrating over the density of $\\xi$ (and $\\omega$ if a supply side was estimated). By default, the method approximates this integral by averaging over the Jacobian realizations computed under draws from the asymptotic normal distribution of the error terms. Since this process is computationally expensive and often doesn't make much of a difference, we'll use `method='approximate'` in this example to simply evaluate the Jacobians at the expected value of $\\xi$, zero."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "Optimal Instrument Results Summary:\n",
                            "=======================\n",
                            "Computation  Error Term\n",
                            "   Time        Draws   \n",
                            "-----------  ----------\n",
                            " 00:00:01        1     \n",
                            "======================="
                        ]
                    },
                    "execution_count": 1,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "instrument_results = results.compute_optimal_instruments(method='approximate')\n",
                "instrument_results"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "We can use the [`OptimalInstrumentResults.to_problem`](https://pyblp.readthedocs.io/en/stable/_api/pyblp.OptimalInstrumentResults.to_problem.html#pyblp.OptimalInstrumentResults.to_problem) method to re-create the fake cereal problem with the estimated optimal excluded instruments."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "Dimensions:\n",
                            "=================================================\n",
                            " T    N     F    I     K1    K2    D    MD    ED \n",
                            "---  ----  ---  ----  ----  ----  ---  ----  ----\n",
                            "94   2256   5   1880   1     4     4    14    1  \n",
                            "=================================================\n",
                            "\n",
                            "Formulations:\n",
                            "===================================================================\n",
                            "       Column Indices:           0           1           2      3  \n",
                            "-----------------------------  ------  --------------  -----  -----\n",
                            " X1: Linear Characteristics    prices                              \n",
                            "X2: Nonlinear Characteristics    1         prices      sugar  mushy\n",
                            "       d: Demographics         income  income_squared   age   child\n",
                            "==================================================================="
                        ]
                    },
                    "execution_count": 1,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "updated_problem = instrument_results.to_problem()\n",
                "updated_problem"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": "We can solve this updated problem just like the original one. We'll start at our consistent estimate of $\\theta$."
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "Problem Results Summary:\n",
                            "========================================================================================================================\n",
                            "                                                                                                   Smallest    Largest  \n",
                            "Computation  GMM   Optimization   Objective   Fixed Point  Contraction  Objective    Gradient      Hessian     Hessian  \n",
                            "   Time      Step   Iterations   Evaluations  Iterations   Evaluations    Value    Infinity Norm  Eigenvalue  Eigenvalue\n",
                            "-----------  ----  ------------  -----------  -----------  -----------  ---------  -------------  ----------  ----------\n",
                            " 00:01:56     1         45           53          47406       146847     +5.7E+00     +2.1E-06      +3.0E-12    +1.5E+04 \n",
                            "========================================================================================================================\n",
                            "\n",
                            "Nonlinear Coefficient Estimates (Robust SEs in Parentheses):\n",
                            "=====================================================================================================================\n",
                            "Sigma:      1         prices      sugar       mushy     |   Pi:      income    income_squared     age        child   \n",
                            "------  ----------  ----------  ----------  ----------  |  ------  ----------  --------------  ----------  ----------\n",
                            "  1      +2.2E-01    +0.0E+00    +0.0E+00    +0.0E+00   |    1      +6.2E+00      +0.0E+00      +1.0E-01    +0.0E+00 \n",
                            "        (+8.1E-02)                                      |          (+5.4E-01)                  (+2.2E-01)            \n",
                            "                                                        |                                                            \n",
                            "prices               +3.1E+00    +0.0E+00    +0.0E+00   |  prices   +4.5E+01      -2.8E+00      +0.0E+00    +3.3E+00 \n",
                            "                    (+7.0E-01)                          |          (+9.3E+01)    (+4.9E+00)                (+2.4E+00)\n",
                            "                                                        |                                                            \n",
                            "sugar                            -5.8E-03    +0.0E+00   |  sugar    -2.8E-01      +0.0E+00      +3.7E-02    +0.0E+00 \n",
                            "                                   (NA)                 |          (+3.6E-02)                  (+1.6E-02)            \n",
                            "                                                        |                                                            \n",
                            "mushy                                        +9.5E-01   |  mushy    +5.1E-01      +0.0E+00      -1.8E-01    +0.0E+00 \n",
                            "                                            (+3.0E-01)  |          (+2.7E-01)                  (+2.3E-01)            \n",
                            "=====================================================================================================================\n",
                            "\n",
                            "Beta Estimates (Robust SEs in Parentheses):\n",
                            "==========\n",
                            "  prices  \n",
                            "----------\n",
                            " -2.9E+01 \n",
                            "(+4.5E+00)\n",
                            "=========="
                        ]
                    },
                    "execution_count": 1,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "updated_results = updated_problem.solve(\n",
                "    results.sigma,\n",
                "    results.pi, \n",
                "    optimization=pyblp.Optimization('bfgs'),\n",
                "    method='1s'\n",
                ")\n",
                "updated_results"
            ]
        }
    ],
    "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.6"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 2
}