 archived/Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e110fecc",
   "metadata": {},
   "source": [
    "# Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ad85d74",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "This notebook's CI test result for us-west-2 is as follows. CI test results in other regions can be found at the end of the notebook. \n",
    "\n",
    "![This us-west-2 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/us-west-2/introduction_to_applying_machine_learning|dynamic_pricing_with_causal_ml_and_optimization|Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker.ipynb)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc4b1528",
   "metadata": {},
   "source": [
    "This notebook describes and implements a dynamic pricing experiment on Amazon SageMaker.\n",
    "\n",
    "### Table of contents\n",
    "\n",
    "1. Generate synthetic data\n",
    "    1. Input parameters\n",
    "    2. Shapes\n",
    "    3. Data Generation Process (DGP)\n",
    "    4. References\n",
    "2. Estimation of cross-price elasticity with Double Machine Learning (DML)\n",
    "    1. Introduction\n",
    "    2. DML experiment\n",
    "    3. CATE interpretation\n",
    "3. Forecast expected quantities\n",
    "4. Optimization\n",
    "    1. Objective functions\n",
    "        1. Revenue\n",
    "        2. Profit\n",
    "    2. Optimization constraints\n",
    "        1. Linear constraints\n",
    "        2. Bounds\n",
    "    3. Solution\n",
    "5. Simulation\n",
    "    1. Procedure"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3988532c",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Dependencies</b><br><br>\n",
    "The Python libraries used in this post are:\n",
    "<ol>\n",
    "<li><a href=\"https://numpy.org/\">NumPy</a>, <a href=\"https://pandas.pydata.org/\">Pandas</a> for data manipulation.\n",
    "</li><li><a href=\"https://matplotlib.org/\">Matplotlib</a> for data visualization.\n",
    "</li><li><a href=\"https://scipy.org/\">SciPy</a> for optimization.\n",
    "</li><li><a href=\"https://econml.azurewebsites.net/\">EconML</a> and <a href=\"https://scikit-learn.org/stable/\">scikit-learn</a> for Causal Machine Learning.\n",
    "</li>\n",
    "</ol>\n",
    "NumPy, Pandas, Matplotlib, scikit-learn and SciPy are natively available inside an AWS SageMaker notebook instance for Data Science.<br>\n",
    "To install EconML, type inside a notebook cell:\n",
    "\n",
    "<p style=\"background-color:white;padding:3px;\">!pip install econml</p>\n",
    "\n",
    "as follows:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01c00821",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install econml"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ab456ea",
   "metadata": {},
   "source": [
    "## 1. Generate synthetic data\n",
    "\n",
    "\n",
    "In our Causal Machine Learning experiment:\n",
    "- The __price__ represents the __treatment T__.\n",
    "- The __volume__ represents the __outcome Y__.\n",
    "- __Confounders W__ are features with an effect on both treatment and outcome. Some examples:\n",
    "  - Discounts\n",
    "  - Coupon\n",
    "  - Stores\n",
    "  - Seasonality\n",
    "  - Inflation\n",
    "  - Cost of energy or materials\n",
    "  - Number of customers\n",
    "  - Social media reactions (sentiment, likes), \n",
    "  - ...\n",
    "- We generate __synthetic data__ so that:\n",
    "  - Both __price and volume are function of__ a set of __confounders__. \n",
    "  - Price __elasticities are negative__ to mimic the law of supply and demand.\n",
    "\n",
    "### 1.1 Input parameters\n",
    "- Number of products: $N_p$\n",
    "- Number of observations (days): $N_d$\n",
    "- Number of confounders: $N_w$\n",
    "- Price offset: $T_0$\n",
    "- Cost offset: $C_0$\n",
    "- Cost fraction (to introduce a proportionality between cost and price): $cost_{fraction}$\n",
    "- Minimum and maximum values for the price elasticity: $K_{ii}{min}, K_{ii}{max}$\n",
    "- Minimum and maximum values for the cross-price elasticity: $K_{ij}{min}, K_{ij}{max}$\n",
    "- Error magnitude: $error_{magnitude}$\n",
    "\n",
    "### 1.2 Shapes\n",
    "- $W: (N_d, N_w)$\n",
    "- $T: (N_d, N_p)$\n",
    "- $β: (N_w, )$\n",
    "- $ϵ: (N_d, )$\n",
    "\n",
    "### 1.3 Data Generation Process (DGP)\n",
    "\n",
    "Assuming:\n",
    "- $β ∼ Uniform(0, 1)$\n",
    "- $ϵ ∼ Uniform(- error_{magnitude}, + error_{magnitude})$ \n",
    "- $W ∼ Normal(0, 1)$\n",
    "\n",
    "__Price-elasticity__: the effect of change in price in the i-th product over the units sold _of the same i-th product_:\n",
    "- $K_{ii} ∼ Uniform(K_{ii}{min}, K_{ii}{max})$\n",
    "\n",
    "__Cross-price-elasticity__: the effect of change in price in the i-th product over the units sold _of a different j-th product_:\n",
    "- $K_{ij} ∼ Uniform(K_{ij}{min}, K_{ij}{max})$\n",
    "\n",
    "__Price__ (treatment) of the i-th product:\n",
    "- $T_i ∼ Uniform(-| (W ⋅ β) + ϵ|, +| (W ⋅ β) + ϵ|) + T_0$\n",
    "\n",
    "__Cost__ of the i-th product:\n",
    "- $C_i ∼ cost_{fraction} ⋅ T_i + C_0 + ϵ$\n",
    "\n",
    "__Volume__ (outcome) for the i-th product:\n",
    "- $Y_i ∼ K_{ii} ⋅ T_i + \\sum_{j}^{N_p-i}(K_{ij} ⋅ T_j) + |(W ⋅ β)| + Y_{0i}$\n",
    "\n",
    "Where:\n",
    "- $Y_{0i} = \\begin{cases}\n",
    "  |min(Y_i)|\\text{ if }min(Y_i)<0 \\\\\n",
    "  0\\text{ otherwise }\n",
    "  \\end{cases}$\n",
    "\n",
    "### 1.4 References\n",
    "\n",
    "- The shape of the control variables $W$ is inspired by <a href=\"https://arxiv.org/pdf/1806.03467.pdf\">Oprescu et al. [2018]</a>.\n",
    "- The shapes of the treatment $T$ and outcome $Y$ satisfy the structural assumptions of Double Machine Learning as per <a href=\"https://arxiv.org/pdf/1608.00060.pdf\">Chernozhukov [2016]</a>.\n",
    "- The choice of the uniform distrubution is based on the principle of maximum entropy as per <a href=\"https://www.imsc.res.in/~sitabhra/teaching/asm17/Guiasu_Shenitzer_MathIntelligencer_1985_The_principle_of_maximum_entropy.pdf\">Guiasu [1985]</a>. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b65ecb14",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "def generate_data(\n",
    "    n_p=10,\n",
    "    n_d=200,\n",
    "    n_w=5,\n",
    "    t_0=5,\n",
    "    c_0=2,\n",
    "    cost_fraction=0.1,\n",
    "    K_ii_min=-5,\n",
    "    K_ii_max=-2,\n",
    "    K_ij_min=-2,\n",
    "    K_ij_max=-1,\n",
    "    err=0.05,\n",
    "):\n",
    "    \"\"\"\n",
    "    This function generates synthetic time series for:\n",
    "    - prices T\n",
    "    - volumes Y\n",
    "    - costs C\n",
    "    - confounders W\n",
    "    as multi-dimensional numpy arrays whose shape depends on the user input.\n",
    "\n",
    "    Args:\n",
    "    - n_p: number of products (default 10)\n",
    "    - n_d: number of observations / days (default 100)\n",
    "    - n_w: number of confounders (default 5)\n",
    "    - t_0: price offset (default 10)\n",
    "    - c_0: cost offset (default 2)\n",
    "    - cost_fraction: proportional relationship between cost and price (default: 0.1)\n",
    "    - K_ii_min: minimum price elasticity for the same product i: effect of price i on volume i (default -5)\n",
    "    - K_ii_max: maximum price elasticity for the same product i: effect of price i on volume i (default -2)\n",
    "    - K_ij_min: minimum cross-price elasticity for different products i and j: effect of price i on volume j (default -2)\n",
    "    - K_ij_max: maximum cross-price elasticity for different products i and j: effect of price i on volume j (default -1)\n",
    "    - err: error magnitude, boundaries of the white noise distribution (default 0.05)\n",
    "    \"\"\"\n",
    "\n",
    "    # Define beta\n",
    "    beta = np.random.uniform(0, 1, size=n_w)\n",
    "\n",
    "    # Define confounders\n",
    "    W = np.random.normal(0, 1, size=(n_d, n_w))\n",
    "\n",
    "    # Define white noise term\n",
    "    epsilon = np.random.uniform(-err, err, size=n_d)\n",
    "\n",
    "    # Prepare <W ⋅ β> + ϵ for the treatment T\n",
    "    T_W = np.abs(np.dot(W, beta) + epsilon)\n",
    "\n",
    "    # Define empty matrices for treatment T (prices), outcomes Y (volumes), and costs C\n",
    "    T = np.zeros((n_d, n_p))\n",
    "    Y = np.zeros((n_d, n_p))\n",
    "    C = np.zeros((n_d, n_p))\n",
    "\n",
    "    # Initialize the first row of T and C\n",
    "    T[0, :] = np.random.uniform(-T_W[0], T_W[0], size=(n_p,))\n",
    "    C[0, :] = T[0, :] * cost_fraction + epsilon[0]\n",
    "\n",
    "    # For each observation / day\n",
    "    for i in range(1, n_d):\n",
    "        # Populate the price T and cost C row\n",
    "        T[i, :] = T[i - 1, :] + np.random.uniform(-T_W[i], T_W[i], size=(n_p,))\n",
    "        C[i, :] = T[i, :] * cost_fraction + epsilon[i]\n",
    "\n",
    "    # Consider only the absolute value to remove negative prices and costs and add the offset\n",
    "    T = np.abs(T + t_0)\n",
    "    C = np.abs(C + c_0)\n",
    "\n",
    "    # For each product\n",
    "    for i in range(0, n_p):\n",
    "        # Populate volumes Y\n",
    "        Y[:, i] = (\n",
    "            np.random.randint(K_ii_min, K_ii_max) * T[:, i]\n",
    "            + sum([np.random.randint(K_ij_min, K_ij_max) * y for y in np.delete(Y, i, axis=1).T])\n",
    "            + np.abs((W[i] * beta).sum())\n",
    "        )\n",
    "        if Y[:, i].min() < 0:\n",
    "            Y[:, i] += np.abs(Y[:, i].min())\n",
    "    return T, Y, C, W"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53d7a394",
   "metadata": {},
   "outputs": [],
   "source": [
    "n_p = 2  # Number of products\n",
    "n_d = 365  # Number of days\n",
    "n_w = 3  # Number of confounders\n",
    "\n",
    "# Set random seed for reproducibility\n",
    "np.random.seed(23)\n",
    "\n",
    "T, Y, C, W = generate_data(n_p=n_p, n_d=n_d, n_w=n_w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "163b741e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.style.use(\"ggplot\")\n",
    "\n",
    "labels = [\"Product n° \" + str(i + 1) for i in range(0, n_p)]\n",
    "\n",
    "plt.plot(T)\n",
    "plt.title(\"Product prices\", y=1.02)\n",
    "plt.xlabel(\"Days\", labelpad=10)\n",
    "plt.legend(labels, loc=\"center left\", bbox_to_anchor=(1.0, 0.5))\n",
    "ax = plt.gca()\n",
    "ax.set_xlim([0, n_d + 1])\n",
    "ax.set_ylim([-T.mean().round(), T.max().round() + T.mean().round()]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58d796fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(Y)\n",
    "plt.title(\"Product volumes\", y=1.02)\n",
    "plt.xlabel(\"Days\", labelpad=10)\n",
    "plt.legend(labels, loc=\"center left\", bbox_to_anchor=(1.0, 0.5))\n",
    "ax = plt.gca()\n",
    "ax.set_xlim([0, n_d + 1])\n",
    "ax.set_ylim([-Y.mean().round(), Y.max().round() + Y.mean().round()]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0eb362d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(C)\n",
    "plt.title(\"Product costs\", y=1.02)\n",
    "plt.xlabel(\"Days\", labelpad=10)\n",
    "plt.legend(labels, loc=\"center left\", bbox_to_anchor=(1.0, 0.5))\n",
    "ax = plt.gca()\n",
    "ax.set_xlim([0, n_d + 1])\n",
    "ax.set_ylim([-C.mean().round(), C.max().round() + C.mean().round()]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf596895",
   "metadata": {},
   "source": [
    "## 2. Estimation of cross-price elasticity with Double Machine Learning (DML)\n",
    "\n",
    "### 2.1 Introduction\n",
    "\n",
    "Price elasticity represents the relationship between price and demand sales volume for a given product. \n",
    "\n",
    "Under the assumption of a linear relationship, elasticity $K$ is defined as:\n",
    "\n",
    "$$∆V=K⋅∆P$$\n",
    " \n",
    " \n",
    "In the previous formula:\n",
    "- $∆V$: change in volume (demand, units sold) caused by the change in price.\n",
    "- $∆P$: change in price.\n",
    "- $K$: proportionality coefficient known as price elasticity.\n",
    "More information on the topic can be found in [Anderson et al. (1997)](https://scholar.harvard.edu/files/alada/files/price_elasticity_of_demand_handout.pdf).\n",
    "\n",
    "We estimate price elasticity through __Double Machine Learning (DML)__ as in [Chernozhukov (2016)](https://arxiv.org/abs/1608.00060).\n",
    "\n",
    "In brief, Double Machine Learning is a method for estimating __heterogeneous treatment effects__ over a target variable called outcome, when all the confounders are observed. \n",
    "\n",
    "__Confounders__ are features that affect both treatment and outcome. \n",
    "\n",
    "In dynamic pricing, the treatment is the conscious manipulation of product’s price towards profit or revenue maximization, while the outcome is the demand or volume for that product. \n",
    "\n",
    "Confounders may be, for instance, the application of discounts, coupons, seasonality, and any information that may affect both the price and the demand for a product. \n",
    "\n",
    "The structural assumptions of the model are as follows:\n",
    "\n",
    "$$Y= θ(X)⋅T+g(X,W)+ϵ$$\n",
    "$$T= f(X,W)+η$$\n",
    "$$Ε[ϵ|X,W]=0$$\n",
    "$$Ε[η|X,W]=0$$\n",
    "$$Ε[η⋅ϵ|X,W]=0$$\n",
    "\n",
    "where:\n",
    "- $Y$: outcomes. In our case, the demand/volume.\n",
    "- $T$: treatment. In our case, the prices.\n",
    "- $X$: features that only affect the outcome, namely variables.\n",
    "- $W$: features that affect both outcome and treatment, namely confounders.\n",
    "- $θ(X)$: marginal conditional average treatment effect (CATE). In our case, the price elasticity K.\n",
    "- $ϵ$ and $η$ represent error terms.\n",
    "- $Ε[⋅|⋅]$: conditional expectation function.\n",
    "\n",
    "### 2.2 DML experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a060e318",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import MultiTaskElasticNetCV\n",
    "from econml.dml import LinearDML\n",
    "\n",
    "# Double ML estimator\n",
    "est = LinearDML(\n",
    "    model_y=MultiTaskElasticNetCV(cv=3, tol=1, selection=\"random\"),\n",
    "    model_t=MultiTaskElasticNetCV(cv=3),\n",
    ")\n",
    "\n",
    "# Model fit\n",
    "est.fit(Y=Y, T=T, X=None, W=W)\n",
    "\n",
    "# Model summary\n",
    "est.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e21d3fe",
   "metadata": {},
   "source": [
    "### 2.3 CATE interpretation\n",
    "\n",
    "The above estimate suggests that __increasing the price of product n° 1 by +10%__ ($T_0$) results in: \n",
    "- __sales drop of 30% for product n°1__ ($Y_0$), and\n",
    "- __sales increase of 60% for product n°2__ ($Y_1$). \n",
    "\n",
    "The cross-price elasticity is not the final result of our solution, but rather a necessary intermediate step.  Nevertheless, it could still be leveraged independently from this solution as a powerful information to:\n",
    "\n",
    "- Determine __whether and how products compete with one another__, then assess this competition using quantifiable and understandable metrics.\n",
    "- Considering the product's competitors, make an educated guess as to the potential __impact of discounts or marketing initiatives__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a59dac6",
   "metadata": {},
   "outputs": [],
   "source": [
    "K = np.array([[-3.0, 0.0], [6.002, -4.003]])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6571e4d9",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b>\n",
    "    In our procedure, we estimate the price-elasticity.<br>\n",
    "    By doing this, we assume that we are in <b>elastic</b> conditions, meaning that a price variation corresponds to a proportional change in the demand. <br>\n",
    "    This is true for most businesses, from retail to large distribution.<br>\n",
    "    Nevertheless, not all businesses work under this assumption. They are referred to as <b>inelastic</b>. In those cases, this strategy is not applicable.    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e2261f1",
   "metadata": {},
   "source": [
    "## 3. Forecast expected quantities\n",
    "\n",
    "While DML gives us an estimate of the causal effect θ(X) of price manipulation over demand, __our final goal is the prediction of the set of prices that will maximize the business objectives__. \n",
    "\n",
    "In Causal Machine Learning, these prices are referred to as __counterfactual__, as they are directly produced by the intervention.\n",
    "\n",
    "As we cannot predict directly the counterfactual prices and demand, we can write them as a combination of observational quantities and a contribution due to the intervention:\n",
    "\n",
    "$$V_c=V_o+δV$$\n",
    "\n",
    "where:\n",
    "- $V_c$: counterfactual volume. The subscripts $c$ stands for $counterfactual$ quantities.\n",
    "- $V_o$: observational volume. The subscripts $o$ stands for $observational$ quantities.\n",
    "- $δV$: additional effect due to the treatment.\n",
    "\n",
    "Therefore, the next step in our strategy is __forecasting the observational quantities__. \n",
    "\n",
    "Unlike counterfactual ones, __observational quantities are based entirely on previous values__. They refer to a condition in which the treatment is not applied, therefore no price manipulation is assumed. \n",
    "\n",
    "As a result, we can use __forecasting techniques__ to predict the observational quantities. \n",
    "\n",
    "In a real dynamic pricing application, we should forecast demands and prices for multiple products. For this reason, we could leverage the advantages provided by __DeepAR__ by [Salinas et al. (2019)](https://arxiv.org/pdf/1704.04110.pdf) from Amazon Research.\n",
    "\n",
    "Indeed, in situations with many similar time series across a cross-sectional unit, such as the demand for a set of products over the past 12 months, one can benefit from training a single model jointly over all of the time series. __DeepAR__ uses this approach, and, in such scenarios, it __outperforms the standard ARIMA and ETS methods__.\n",
    "\n",
    "Conveniently, DeepAr is __already available__ as Amazon SageMaker [estimator](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html). The detailed implementation for the forecast of observational quantities is not the main scope of this notebook. For this reason, we will limit ourselves in considering the last price and volume values in our time series as example. Still, DeepAR would provide significant advantages where the demand and prices of multiple products should be predicted. One may find a __detailed, end-to-end tutorial on using DeepAR in a SageMaker Studio Notebook__ [here](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/deepar_synthetic/deepar_synthetic.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b1f4d40",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = C[-1, :]\n",
    "V_obs = Y[-1, :]\n",
    "P_obs = T[-1, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a58a7f6c",
   "metadata": {},
   "source": [
    "## 4. Optimization \n",
    "\n",
    "We previously defined the counterfactual quantities as a combination of observational ones and an intervention effect:\n",
    "\n",
    "$$V_c=V_o+δV$$\n",
    "\n",
    "By using the definition of price elasticity, we can rewrite this expression for the i-th product as:\n",
    "\n",
    "$$ {{V_c}^i} = {{V_o}^i} + \\sum \\limits _{j=1} ^{N} K_{ij} ⋅ δP^j$$\n",
    "\n",
    "$$ {{V_c}^i} = {{V_o}^i} + \\sum \\limits _{j=1} ^{N} K_{ij} ⋅ ({{P_c}^j} - {{P_o}^j} )$$\n",
    "\n",
    "In particular:\n",
    "- $V_c^i$: counterfactual volume/demand of the i-th product.\n",
    "- $V_o^i$: observational volume/demand of the i-th product (known from forecasting).\n",
    "- $K_{ij}$: effect of the variation of price of the i-th product over the demand of the j-th product (cross-price elasticity known from DML).\n",
    "- $P_c^j$: counterfactual price of the j-th product (known from forecasting).\n",
    "- $P_o^j$: observational price of the j-th product (known from forecasting).\n",
    "\n",
    "The previous analytical expression can be plugged in any objective function such as profit and optimized with respect to the counterfactual prices. \n",
    "\n",
    "Furthermore, we can impose constraints to the optimization problem modifying the feasible region in which the counterfactual prices are evaluated. Custom policies, regulations, and business rules can all be used as optimization constraints. Our framework provides the flexibility to accommodate any type and number of constraints.\n",
    "\n",
    "The following sections provide the complete derivation for popular objective functions: __profit__ and __revenue__.\n",
    "\n",
    "### 4.1 Objective functions\n",
    "\n",
    "#### 4.1.1 Revenue\n",
    "\n",
    "Define revenue $R$ as:\n",
    "\n",
    "$$R = V_c ⋅ P_c$$\n",
    "\n",
    "Formulate the problem of finding the set of prices that maximize the revenue as an optimization task:\n",
    "\n",
    "$$ {max}_{P_c} \\sum \\limits _{i=1} ^{N} {{P_c}^i} ⋅ [ {V_{o}^i} + \\sum \\limits _{j=1} ^{N} K_{ij} ( {P_{c}^j} - {P_{o}^j} ) ]$$\n",
    "\n",
    "In matrix form, posed as minimization problem:\n",
    "\n",
    "$$  {min}_{P_C} - [ P_{c}^T ⋅ ( V_{o} + K ⋅ ( P_{c} - P_{o} ) ) ]$$\n",
    "\n",
    "In conclusion, the problem can be framed as follow:\n",
    "\n",
    "- Objective function $f(P_{c})$: \n",
    "\n",
    "$$ -( P_{c}^T ⋅ (V_{o} + K ⋅ (P_{c} - P_{o}) ))$$\n",
    "\n",
    "- Gradient $\\nabla f(P_{C})$:\n",
    "\n",
    "$$ - (K ⋅ ( P_{C} - P_{o}) + V_{o} + K^T ⋅ P_{c} $$\n",
    "\n",
    "- Hessian $\\nabla^2 f(P_{c})$:\n",
    "\n",
    "$$- (K + K^T)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1180d4a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def revenue(x):\n",
    "    return -np.dot(x, (V_obs + np.dot(K, (x - P_obs))))\n",
    "\n",
    "\n",
    "def revenue_gradient(x):\n",
    "    return -(np.dot(K, (x - P_obs)) + V_obs + np.dot(K.transpose(), x))\n",
    "\n",
    "\n",
    "def revenue_hessian(x):\n",
    "    return -(K + K.transpose())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69054948",
   "metadata": {},
   "source": [
    "#### 4.1.2 Profit\n",
    "\n",
    "Define profit $Pr$ as:\n",
    "\n",
    "$$ Pr = V_{c} ⋅ ( P_{c} - C)$$\n",
    "\n",
    "Assumption: cost is independent from any potential modification of price:\n",
    "\n",
    "$$ C_{c} = C_{o} = C $$\n",
    "\n",
    "Formulate the problem of finding the set of prices that maximize the profit as an optimization task:\n",
    "\n",
    "$$ {max}_{P_c} \\sum \\limits _{i=1} ^{N} {(P_{c}^i} - C^i) ⋅ [ {V_{o}^i} + \\sum \\limits _{j=1} ^{N} K_{ij} ( {P_{c}^j} - {P_{o}^j} ) ]$$\n",
    "\n",
    "In matrix form, posed as minimization problem:\n",
    "\n",
    "$$ {min}_{P_c} - [ (P_{c} - C)^T ⋅ ( V_{o} + K ⋅ ( P_{c} - P_{o} ) ) ]$$\n",
    "\n",
    "In conclusion, the problem can be framed as follow:\n",
    "\n",
    "- Objective function $f(P_{c})$: \n",
    "\n",
    "$$ -( (P_{c} - C)^T ⋅ (V_{o} + K ⋅ (P_{c} - P_{o}) ))$$\n",
    "\n",
    "- Gradient $\\nabla f(P_{C})$:\n",
    "\n",
    "$$ - (K ⋅ ( P_{c} - P_{o}) + V_{o} + K^T ⋅ (P_{c} - C)$$\n",
    "\n",
    "- Hessian $\\nabla^2 f(P_{c})$:\n",
    "\n",
    "$$- (K + K^T)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "303ae127",
   "metadata": {},
   "outputs": [],
   "source": [
    "def profit(x):\n",
    "    return -(np.dot((x - c), (V_obs + np.dot(K, (x - P_obs)))))\n",
    "\n",
    "\n",
    "def profit_gradient(x):\n",
    "    return -(np.dot(K, (x - P_obs)) + V_obs + np.dot(K.transpose(), (x - c)))\n",
    "\n",
    "\n",
    "def profit_hessian(x):\n",
    "    return -(K + K.transpose())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1d75eb7",
   "metadata": {},
   "source": [
    "### 4.2 Optimization constraints\n",
    "\n",
    "#### 4.2.1 Linear constraints\n",
    "\n",
    "We need to ensure that the feasible region will only account for positive counterfactual volumes. This can be achieved with a linear constraint, imposing: \n",
    "\n",
    "$$V_c≥0$$\n",
    "\n",
    "Through price elasticity, we can formulate this condition as:\n",
    "\n",
    "$$V_o+δV≥0$$\n",
    "\n",
    "$$V_o+K ⋅(P_c-P_o )≥0$$\n",
    "\n",
    "$$ K⋅P_c≥-V_o+K⋅P_o $$\n",
    "\n",
    "Therefore, we can write the following linear constraint:\n",
    "\n",
    "$$\\text{ Lower bound } ≤ A⋅X ≤  \\text{ Upper bound }$$\n",
    "\n",
    "where:\n",
    "- $A=K$\n",
    "- $X= P_c$\n",
    "- $\\text{ Lower bound } = -V_o + K⋅P_o$\n",
    "- $\\text{ Upper bound } = Inf$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "014ef5f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.optimize import LinearConstraint\n",
    "\n",
    "A = K\n",
    "lower_bound = -V_obs + np.dot(K, P_obs)\n",
    "upper_bound = np.inf\n",
    "lin_cons = LinearConstraint(A, lb=lower_bound, ub=upper_bound)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82c97a8c",
   "metadata": {},
   "source": [
    "#### 4.2.2 Bounds\n",
    "\n",
    "Bounds allow to estimate the objective function only between a specified range for the input variables.\n",
    "\n",
    "In our case, we want the feasible region to be described by minimum and maximum prices. \n",
    "\n",
    "The application of such a perimeter allows to avoid sudden and highly different prices in short spans of time, in case the optimum price is too different from the one currently applied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9cf6e695",
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.optimize import Bounds\n",
    "\n",
    "# Min historical prices for each product\n",
    "min_prices = T.min(axis=0).tolist()\n",
    "\n",
    "# Max historical prices for each product\n",
    "max_prices = T.max(axis=0).tolist()\n",
    "\n",
    "# Bounds on counterfactual prices\n",
    "bounds = Bounds(min_prices, max_prices)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7eaa0782",
   "metadata": {},
   "source": [
    "### 4.3 Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ddb5ecb",
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.optimize import minimize\n",
    "\n",
    "result = minimize(\n",
    "    revenue, P_obs, method=\"SLSQP\", jac=revenue_gradient, bounds=bounds, constraints=lin_cons\n",
    ")\n",
    "\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4987670e",
   "metadata": {},
   "source": [
    "We found the set of counterfactual prices that maximize revenue.\n",
    "\n",
    "We can observe the feasible region and the found minimizer:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19bd070d",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Dimensionality</b><br><br>\n",
    "The following code snippet plots the objective function with respect to the counterfactual prices of two products.\n",
    "<br>\n",
    "When reproducing this notebook, please consider that a 3-D plot of the objective function is only possible when considering two products, one for each axis.<br>\n",
    "<b>If more than two products have been generated in the previous passages, the following plot is not possible</b>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d222fd7",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.style.use(\"default\")\n",
    "\n",
    "\n",
    "def revenue_by_xy(x, y):\n",
    "    return -(\n",
    "        V_obs[0] * x\n",
    "        + V_obs[1] * y\n",
    "        + x * (K[0][0] * (x - P_obs[0]) + K[0][1] * (y - P_obs[1]))\n",
    "        + y * ((K[1][0] * (x - P_obs[0]) + K[1][1] * (y - P_obs[1])))\n",
    "    )\n",
    "\n",
    "\n",
    "def plot_revenue(min_value=0, max_value=10000):\n",
    "    # Objective function\n",
    "    x = np.linspace(min_value, max_value, 30)\n",
    "    y = np.linspace(min_value, max_value, 30)\n",
    "    X, Y = np.meshgrid(x, y)\n",
    "    Z = revenue_by_xy(X, Y)\n",
    "\n",
    "    # Minimum from the optimization task\n",
    "    min_x0, min_x1 = np.meshgrid(result.x[0], result.x[1])\n",
    "    min_z = revenue_by_xy(min_x0, min_x1)\n",
    "\n",
    "    # Bounds area\n",
    "    X0_bound, X1_bound = np.meshgrid(\n",
    "        np.linspace(min_prices[0], max_prices[0], 20), np.linspace(min_prices[1], max_prices[1], 20)\n",
    "    )\n",
    "    Z_bound = revenue_by_xy(X0_bound, X1_bound)\n",
    "\n",
    "    # Plot\n",
    "    fig = plt.figure(figsize=(15, 15))\n",
    "\n",
    "    ax = fig.add_subplot(1, 2, 1, projection=\"3d\")\n",
    "    ax.contour3D(X, Y, Z, 100, cmap=\"plasma\")\n",
    "    ax.scatter(min_x0, min_x1, min_z, marker=\"o\", color=\"red\", linewidth=5)\n",
    "    ax.plot_surface(X0_bound, X1_bound, Z_bound, color=\"black\", alpha=0.6)\n",
    "\n",
    "    ax.set_xlabel(\"$P_1$\")\n",
    "    ax.set_ylabel(\"$P_2$\")\n",
    "    ax.view_init(20, 40)\n",
    "    ax.set_zlabel(\"$f(p)$\")\n",
    "\n",
    "    ax = fig.add_subplot(1, 2, 2, projection=\"3d\")\n",
    "    ax.contour3D(X, Y, Z, 100, cmap=\"plasma\")\n",
    "    ax.scatter(min_x0, min_x1, min_z, marker=\"o\", color=\"red\", linewidth=5)\n",
    "    ax.plot_surface(X0_bound, X1_bound, Z_bound, color=\"black\", alpha=0.6)\n",
    "    ax.set_xlabel(\"$P_1$\")\n",
    "    ax.set_ylabel(\"$P_2$\")\n",
    "    ax.view_init(89, -90)\n",
    "    ax.axes.zaxis.set_ticklabels([])\n",
    "    ax.set_zlabel(\"$f(p)$\")\n",
    "\n",
    "\n",
    "plot_revenue(-30, 30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c57eadd",
   "metadata": {},
   "source": [
    "Let us estimate counterfactual volumes and compare counterfactual and observational revenue:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77e88592",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Counterfactual volumes\n",
    "V_count = np.abs(\n",
    "    np.floor(\n",
    "        np.array(\n",
    "            [\n",
    "                V_obs[i]\n",
    "                + (np.array([K[i][j] * (result.x[j] - P_obs[j]) for j in range(0, n_p)]).sum())\n",
    "                for i in range(0, n_p)\n",
    "            ]\n",
    "        )\n",
    "    )\n",
    ")\n",
    "\n",
    "# Counterfactual revenue\n",
    "revenue_count = np.array([V_count[i] * result.x[i] for i in range(0, n_p)]).sum()\n",
    "\n",
    "# Observational (expected) revenue\n",
    "revenue_obs = np.array([V_obs[i] * P_obs[i] for i in range(0, n_p)]).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3885ba71",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "pd.DataFrame(\n",
    "    [P_obs.round(2), result.x.round(2), np.floor(V_obs), V_count],\n",
    "    columns=labels,\n",
    "    index=[\"Expected Prices\", \"Optimized Prices\", \"Expected Volumes\", \"Optimized Volumes\"],\n",
    ").T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20f59bfd",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Expected revenue:\\t{:.2f}\".format(revenue_obs))\n",
    "print(\"Counterfactual revenue:\\t{:.2f}\".format(revenue_count))\n",
    "print(\"Revenue increase:\\t{:.2f}\".format((revenue_count - revenue_obs) * 100 / revenue_obs) + \"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e32660f8",
   "metadata": {},
   "source": [
    "## 5. Simulation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c4da4ae",
   "metadata": {},
   "source": [
    "Optimization provides a set of prices that maximizes a certain business goal (profit, revenue, ..).\n",
    "Instead, __simulation works backwards__.\n",
    "\n",
    "Simulation allows to __apply any custom price__, and verify what would happen to the business goal.\n",
    "In this way, business users are free to __experiment different scenarios__ and further __adapt the solution__.\n",
    "\n",
    "In conclusion, the simulation utility provides flexibility to business users answering the question: _What would happen to revenue or profit if I applied these prices?_\n",
    "\n",
    "#### 5.1 Procedure\n",
    "\n",
    "Decide, for each product, the price to be applied during the simulation: \n",
    "\n",
    "$$ \\sum \\limits _{i=1} ^{N} {set: P_c^i } $$\n",
    "\n",
    "Estimate the volumes resulting from this application:\n",
    "\n",
    "$$ {{V_c}^i} = {{V_o}^i} + \\sum \\limits _{j=1} ^{N} K_{ij} ⋅ ({{P_c}^j} - {{P_o}^j} )$$\n",
    "\n",
    "Calculate resulting counterfactual profit $Pr$:\n",
    "\n",
    "$$ Pr_c = V_{c} ⋅ ( P_{c} - C)$$\n",
    "\n",
    "$$ Pr_c = \\sum \\limits _{i=1} ^{N} {(P_{c}^i} - C^i) ⋅ [ {V_{o}^i} + \\sum \\limits _{j=1} ^{N} K_{ij} ( {P_{c}^j} - {P_{o}^j} ) ]$$\n",
    "\n",
    "Compare it with the expected (observational profit) and verify a gain or loss:\n",
    "\n",
    "$$ Pr_o = \\sum \\limits _{i=1} ^{N} {(P_{o}^i} - C^i) ⋅ {V_{o}^i}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8fd0a5a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simulated prices: custom prices applied by business users\n",
    "sim_P = np.array([5, 5])\n",
    "\n",
    "# Simulated volumes: expected from the simulated prices through elasticity\n",
    "sim_V = np.floor(\n",
    "    np.abs(\n",
    "        np.array(\n",
    "            [\n",
    "                V_obs[i]\n",
    "                + (np.array([K[i][j] * (sim_P[j] - P_obs[j]) for j in range(0, n_p)]).sum())\n",
    "                for i in range(0, n_p)\n",
    "            ]\n",
    "        )\n",
    "    )\n",
    ")\n",
    "\n",
    "# Simulated revenue\n",
    "sim_revenue = np.array([sim_V[i] * sim_P[i] for i in range(0, n_p)]).sum()\n",
    "\n",
    "print(\"Expected revenue:\\t{:.2f}\".format(revenue_obs))\n",
    "print(\"Simulated revenue:\\t{:.2f}\".format(sim_revenue))\n",
    "print(\"Revenue increase:\\t{:.2f}\".format((sim_revenue - revenue_obs) * 100 / revenue_obs) + \"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43f0a8e6",
   "metadata": {},
   "source": [
    "## Notebook CI Test Results\n",
    "\n",
    "This notebook was tested in multiple regions. The test results are as follows, except for us-west-2 which is shown at the top of the notebook.\n",
    "\n",
    "![This us-east-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/us-east-1/introduction_to_applying_machine_learning|dynamic_pricing_with_causal_ml_and_optimization|Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker.ipynb)\n",
    "\n",
    "![This us-east-2 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/us-east-2/introduction_to_applying_machine_learning|dynamic_pricing_with_causal_ml_and_optimization|Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker.ipynb)\n",
    "\n",
    "![This us-west-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/us-west-1/introduction_to_applying_machine_learning|dynamic_pricing_with_causal_ml_and_optimization|Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker.ipynb)\n",
    "\n",
    "![This ca-central-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/ca-central-1/introduction_to_applying_machine_learning|dynamic_pricing_with_causal_ml_and_optimization|Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker.ipynb)\n",
    "\n",
    "![This sa-east-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/sa-east-1/introduction_to_applying_machine_learning|dynamic_pricing_with_causal_ml_and_optimization|Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker.ipynb)\n",
    "\n",
    "![This eu-west-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/eu-west-1/introduction_to_applying_machine_learning|dynamic_pricing_with_causal_ml_and_optimization|Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker.ipynb)\n",
    "\n",
    "![This eu-west-2 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/eu-west-2/introduction_to_applying_machine_learning|dynamic_pricing_with_causal_ml_and_optimization|Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker.ipynb)\n",
    "\n",
    "![This eu-west-3 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/eu-west-3/introduction_to_applying_machine_learning|dynamic_pricing_with_causal_ml_and_optimization|Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker.ipynb)\n",
    "\n",
    "![This eu-central-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/eu-central-1/introduction_to_applying_machine_learning|dynamic_pricing_with_causal_ml_and_optimization|Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker.ipynb)\n",
    "\n",
    "![This eu-north-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/eu-north-1/introduction_to_applying_machine_learning|dynamic_pricing_with_causal_ml_and_optimization|Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker.ipynb)\n",
    "\n",
    "![This ap-southeast-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/ap-southeast-1/introduction_to_applying_machine_learning|dynamic_pricing_with_causal_ml_and_optimization|Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker.ipynb)\n",
    "\n",
    "![This ap-southeast-2 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/ap-southeast-2/introduction_to_applying_machine_learning|dynamic_pricing_with_causal_ml_and_optimization|Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker.ipynb)\n",
    "\n",
    "![This ap-northeast-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/ap-northeast-1/introduction_to_applying_machine_learning|dynamic_pricing_with_causal_ml_and_optimization|Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker.ipynb)\n",
    "\n",
    "![This ap-northeast-2 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/ap-northeast-2/introduction_to_applying_machine_learning|dynamic_pricing_with_causal_ml_and_optimization|Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker.ipynb)\n",
    "\n",
    "![This ap-south-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/ap-south-1/introduction_to_applying_machine_learning|dynamic_pricing_with_causal_ml_and_optimization|Dynamic Pricing with Causal Machine Learning and Optimization on Amazon SageMaker.ipynb)\n"
   ]
  }
 ],
 "metadata": {
  "availableInstances": [
   {
    "_defaultOrder": 0,
    "_isFastLaunch": true,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 4,
    "name": "ml.t3.medium",
    "vcpuNum": 2
   },
   {
    "_defaultOrder": 1,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 8,
    "name": "ml.t3.large",
    "vcpuNum": 2
   },
   {
    "_defaultOrder": 2,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 16,
    "name": "ml.t3.xlarge",
    "vcpuNum": 4
   },
   {
    "_defaultOrder": 3,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 32,
    "name": "ml.t3.2xlarge",
    "vcpuNum": 8
   },
   {
    "_defaultOrder": 4,
    "_isFastLaunch": true,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 8,
    "name": "ml.m5.large",
    "vcpuNum": 2
   },
   {
    "_defaultOrder": 5,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 16,
    "name": "ml.m5.xlarge",
    "vcpuNum": 4
   },
   {
    "_defaultOrder": 6,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 32,
    "name": "ml.m5.2xlarge",
    "vcpuNum": 8
   },
   {
    "_defaultOrder": 7,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 64,
    "name": "ml.m5.4xlarge",
    "vcpuNum": 16
   },
   {
    "_defaultOrder": 8,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 128,
    "name": "ml.m5.8xlarge",
    "vcpuNum": 32
   },
   {
    "_defaultOrder": 9,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 192,
    "name": "ml.m5.12xlarge",
    "vcpuNum": 48
   },
   {
    "_defaultOrder": 10,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 256,
    "name": "ml.m5.16xlarge",
    "vcpuNum": 64
   },
   {
    "_defaultOrder": 11,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 384,
    "name": "ml.m5.24xlarge",
    "vcpuNum": 96
   },
   {
    "_defaultOrder": 12,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 8,
    "name": "ml.m5d.large",
    "vcpuNum": 2
   },
   {
    "_defaultOrder": 13,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 16,
    "name": "ml.m5d.xlarge",
    "vcpuNum": 4
   },
   {
    "_defaultOrder": 14,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 32,
    "name": "ml.m5d.2xlarge",
    "vcpuNum": 8
   },
   {
    "_defaultOrder": 15,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 64,
    "name": "ml.m5d.4xlarge",
    "vcpuNum": 16
   },
   {
    "_defaultOrder": 16,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 128,
    "name": "ml.m5d.8xlarge",
    "vcpuNum": 32
   },
   {
    "_defaultOrder": 17,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 192,
    "name": "ml.m5d.12xlarge",
    "vcpuNum": 48
   },
   {
    "_defaultOrder": 18,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 256,
    "name": "ml.m5d.16xlarge",
    "vcpuNum": 64
   },
   {
    "_defaultOrder": 19,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 384,
    "name": "ml.m5d.24xlarge",
    "vcpuNum": 96
   },
   {
    "_defaultOrder": 20,
    "_isFastLaunch": false,
    "category": "General purpose",
    "gpuNum": 0,
    "hideHardwareSpecs": true,
    "memoryGiB": 0,
    "name": "ml.geospatial.interactive",
    "supportedImageNames": [
     "sagemaker-geospatial-v1-0"
    ],
    "vcpuNum": 0
   },
   {
    "_defaultOrder": 21,
    "_isFastLaunch": true,
    "category": "Compute optimized",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 4,
    "name": "ml.c5.large",
    "vcpuNum": 2
   },
   {
    "_defaultOrder": 22,
    "_isFastLaunch": false,
    "category": "Compute optimized",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 8,
    "name": "ml.c5.xlarge",
    "vcpuNum": 4
   },
   {
    "_defaultOrder": 23,
    "_isFastLaunch": false,
    "category": "Compute optimized",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 16,
    "name": "ml.c5.2xlarge",
    "vcpuNum": 8
   },
   {
    "_defaultOrder": 24,
    "_isFastLaunch": false,
    "category": "Compute optimized",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 32,
    "name": "ml.c5.4xlarge",
    "vcpuNum": 16
   },
   {
    "_defaultOrder": 25,
    "_isFastLaunch": false,
    "category": "Compute optimized",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 72,
    "name": "ml.c5.9xlarge",
    "vcpuNum": 36
   },
   {
    "_defaultOrder": 26,
    "_isFastLaunch": false,
    "category": "Compute optimized",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 96,
    "name": "ml.c5.12xlarge",
    "vcpuNum": 48
   },
   {
    "_defaultOrder": 27,
    "_isFastLaunch": false,
    "category": "Compute optimized",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 144,
    "name": "ml.c5.18xlarge",
    "vcpuNum": 72
   },
   {
    "_defaultOrder": 28,
    "_isFastLaunch": false,
    "category": "Compute optimized",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 192,
    "name": "ml.c5.24xlarge",
    "vcpuNum": 96
   },
   {
    "_defaultOrder": 29,
    "_isFastLaunch": true,
    "category": "Accelerated computing",
    "gpuNum": 1,
    "hideHardwareSpecs": false,
    "memoryGiB": 16,
    "name": "ml.g4dn.xlarge",
    "vcpuNum": 4
   },
   {
    "_defaultOrder": 30,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 1,
    "hideHardwareSpecs": false,
    "memoryGiB": 32,
    "name": "ml.g4dn.2xlarge",
    "vcpuNum": 8
   },
   {
    "_defaultOrder": 31,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 1,
    "hideHardwareSpecs": false,
    "memoryGiB": 64,
    "name": "ml.g4dn.4xlarge",
    "vcpuNum": 16
   },
   {
    "_defaultOrder": 32,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 1,
    "hideHardwareSpecs": false,
    "memoryGiB": 128,
    "name": "ml.g4dn.8xlarge",
    "vcpuNum": 32
   },
   {
    "_defaultOrder": 33,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 4,
    "hideHardwareSpecs": false,
    "memoryGiB": 192,
    "name": "ml.g4dn.12xlarge",
    "vcpuNum": 48
   },
   {
    "_defaultOrder": 34,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 1,
    "hideHardwareSpecs": false,
    "memoryGiB": 256,
    "name": "ml.g4dn.16xlarge",
    "vcpuNum": 64
   },
   {
    "_defaultOrder": 35,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 1,
    "hideHardwareSpecs": false,
    "memoryGiB": 61,
    "name": "ml.p3.2xlarge",
    "vcpuNum": 8
   },
   {
    "_defaultOrder": 36,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 4,
    "hideHardwareSpecs": false,
    "memoryGiB": 244,
    "name": "ml.p3.8xlarge",
    "vcpuNum": 32
   },
   {
    "_defaultOrder": 37,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 8,
    "hideHardwareSpecs": false,
    "memoryGiB": 488,
    "name": "ml.p3.16xlarge",
    "vcpuNum": 64
   },
   {
    "_defaultOrder": 38,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 8,
    "hideHardwareSpecs": false,
    "memoryGiB": 768,
    "name": "ml.p3dn.24xlarge",
    "vcpuNum": 96
   },
   {
    "_defaultOrder": 39,
    "_isFastLaunch": false,
    "category": "Memory Optimized",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 16,
    "name": "ml.r5.large",
    "vcpuNum": 2
   },
   {
    "_defaultOrder": 40,
    "_isFastLaunch": false,
    "category": "Memory Optimized",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 32,
    "name": "ml.r5.xlarge",
    "vcpuNum": 4
   },
   {
    "_defaultOrder": 41,
    "_isFastLaunch": false,
    "category": "Memory Optimized",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 64,
    "name": "ml.r5.2xlarge",
    "vcpuNum": 8
   },
   {
    "_defaultOrder": 42,
    "_isFastLaunch": false,
    "category": "Memory Optimized",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 128,
    "name": "ml.r5.4xlarge",
    "vcpuNum": 16
   },
   {
    "_defaultOrder": 43,
    "_isFastLaunch": false,
    "category": "Memory Optimized",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 256,
    "name": "ml.r5.8xlarge",
    "vcpuNum": 32
   },
   {
    "_defaultOrder": 44,
    "_isFastLaunch": false,
    "category": "Memory Optimized",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 384,
    "name": "ml.r5.12xlarge",
    "vcpuNum": 48
   },
   {
    "_defaultOrder": 45,
    "_isFastLaunch": false,
    "category": "Memory Optimized",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 512,
    "name": "ml.r5.16xlarge",
    "vcpuNum": 64
   },
   {
    "_defaultOrder": 46,
    "_isFastLaunch": false,
    "category": "Memory Optimized",
    "gpuNum": 0,
    "hideHardwareSpecs": false,
    "memoryGiB": 768,
    "name": "ml.r5.24xlarge",
    "vcpuNum": 96
   },
   {
    "_defaultOrder": 47,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 1,
    "hideHardwareSpecs": false,
    "memoryGiB": 16,
    "name": "ml.g5.xlarge",
    "vcpuNum": 4
   },
   {
    "_defaultOrder": 48,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 1,
    "hideHardwareSpecs": false,
    "memoryGiB": 32,
    "name": "ml.g5.2xlarge",
    "vcpuNum": 8
   },
   {
    "_defaultOrder": 49,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 1,
    "hideHardwareSpecs": false,
    "memoryGiB": 64,
    "name": "ml.g5.4xlarge",
    "vcpuNum": 16
   },
   {
    "_defaultOrder": 50,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 1,
    "hideHardwareSpecs": false,
    "memoryGiB": 128,
    "name": "ml.g5.8xlarge",
    "vcpuNum": 32
   },
   {
    "_defaultOrder": 51,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 1,
    "hideHardwareSpecs": false,
    "memoryGiB": 256,
    "name": "ml.g5.16xlarge",
    "vcpuNum": 64
   },
   {
    "_defaultOrder": 52,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 4,
    "hideHardwareSpecs": false,
    "memoryGiB": 192,
    "name": "ml.g5.12xlarge",
    "vcpuNum": 48
   },
   {
    "_defaultOrder": 53,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 4,
    "hideHardwareSpecs": false,
    "memoryGiB": 384,
    "name": "ml.g5.24xlarge",
    "vcpuNum": 96
   },
   {
    "_defaultOrder": 54,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 8,
    "hideHardwareSpecs": false,
    "memoryGiB": 768,
    "name": "ml.g5.48xlarge",
    "vcpuNum": 192
   },
   {
    "_defaultOrder": 55,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 8,
    "hideHardwareSpecs": false,
    "memoryGiB": 1152,
    "name": "ml.p4d.24xlarge",
    "vcpuNum": 96
   },
   {
    "_defaultOrder": 56,
    "_isFastLaunch": false,
    "category": "Accelerated computing",
    "gpuNum": 8,
    "hideHardwareSpecs": false,
    "memoryGiB": 1152,
    "name": "ml.p4de.24xlarge",
    "vcpuNum": 96
   }
  ],
  "kernelspec": {
   "display_name": "Python 3 (Data Science 3.0)",
   "language": "python",
   "name": "python3__SAGEMAKER_INTERNAL__arn:aws:sagemaker:us-west-2:236514542706:image/sagemaker-data-science-310-v1"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  },
  "vscode": {
   "interpreter": {
    "hash": "3c60b78628a6b83670c48b2d5c5ff221aeaf244d12976eebda2addf061acc6d7"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}