notebooks/auxiliary_tools/assortment_example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assortment Example\n",
    "A short example for assortment optimization under the conditional Logit and more.\n",
    "\n",
    "- [Intoduction](#introduction)\n",
    "    - [Dataset](#dataset)\n",
    "    - [Choice model specification](#choice-model-specification)\n",
    "    - [Choice model estimation](#choice-model-estimation)\n",
    "- [Assortment Optimization](#assortment-optimization)\n",
    "    - [Preparing the data](#preparing-the-data)\n",
    "    - [Choice-Learn's AssortmentOptimizer](#choice-learns-assortmentoptimizer)\n",
    "    - [Assortment with Latent Class models](#latent-class-assortment-optimizer)\n",
    "    - [Adding Capacity Constraints](#adding-capacity-constraints)\n",
    "- [Pricing and assortment](#pricing-and-assortment-optimization)\n",
    "\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/artefactory/choice-learn/blob/main/notebooks/auxiliary_tools/assortment_example.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install necessary requirements\n",
    "\n",
    "# If you run this notebook on Google Colab, or in standalone mode, you need to install the required packages.\n",
    "# Uncomment the following lines:\n",
    "\n",
    "# !pip install choice-learn\n",
    "\n",
    "# If you run the notebook within the GitHub repository, you need to run the following lines, that can skipped otherwise:\n",
    "import os\n",
    "import sys\n",
    "\n",
    "sys.path.append(\"../../\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing the right base libraries\n",
    "import os\n",
    "# Remove GPU use\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"\"\n",
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "### Dataset\n",
    "\n",
    "We will use the TaFeng Dataset that is available on [Kaggle](https://www.kaggle.com/datasets/chiranjivdas09/ta-feng-grocery-dataset). You can load it automatically with Choice-Learn !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from choice_learn.datasets import load_tafeng"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>TRANSACTION_DT</th>\n",
       "      <th>CUSTOMER_ID</th>\n",
       "      <th>AGE_GROUP</th>\n",
       "      <th>PIN_CODE</th>\n",
       "      <th>PRODUCT_SUBCLASS</th>\n",
       "      <th>PRODUCT_ID</th>\n",
       "      <th>AMOUNT</th>\n",
       "      <th>ASSET</th>\n",
       "      <th>SALES_PRICE</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>11/1/2000</td>\n",
       "      <td>1104905</td>\n",
       "      <td>45-49</td>\n",
       "      <td>115</td>\n",
       "      <td>110411</td>\n",
       "      <td>4710199010372</td>\n",
       "      <td>2</td>\n",
       "      <td>24</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>11/1/2000</td>\n",
       "      <td>418683</td>\n",
       "      <td>45-49</td>\n",
       "      <td>115</td>\n",
       "      <td>120107</td>\n",
       "      <td>4710857472535</td>\n",
       "      <td>1</td>\n",
       "      <td>48</td>\n",
       "      <td>46</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>11/1/2000</td>\n",
       "      <td>1057331</td>\n",
       "      <td>35-39</td>\n",
       "      <td>115</td>\n",
       "      <td>100407</td>\n",
       "      <td>4710043654103</td>\n",
       "      <td>2</td>\n",
       "      <td>142</td>\n",
       "      <td>166</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>11/1/2000</td>\n",
       "      <td>1849332</td>\n",
       "      <td>45-49</td>\n",
       "      <td>Others</td>\n",
       "      <td>120108</td>\n",
       "      <td>4710126092129</td>\n",
       "      <td>1</td>\n",
       "      <td>32</td>\n",
       "      <td>38</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>11/1/2000</td>\n",
       "      <td>1981995</td>\n",
       "      <td>50-54</td>\n",
       "      <td>115</td>\n",
       "      <td>100205</td>\n",
       "      <td>4710176021445</td>\n",
       "      <td>1</td>\n",
       "      <td>14</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  TRANSACTION_DT  CUSTOMER_ID AGE_GROUP PIN_CODE  PRODUCT_SUBCLASS  \\\n",
       "0      11/1/2000      1104905     45-49      115            110411   \n",
       "1      11/1/2000       418683     45-49      115            120107   \n",
       "2      11/1/2000      1057331     35-39      115            100407   \n",
       "3      11/1/2000      1849332     45-49   Others            120108   \n",
       "4      11/1/2000      1981995     50-54      115            100205   \n",
       "\n",
       "      PRODUCT_ID  AMOUNT  ASSET  SALES_PRICE  \n",
       "0  4710199010372       2     24           30  \n",
       "1  4710857472535       1     48           46  \n",
       "2  4710043654103       2    142          166  \n",
       "3  4710126092129       1     32           38  \n",
       "4  4710176021445       1     14           18  "
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Short illustration of the dataset\n",
    "tafeng_df = load_tafeng(as_frame=True)\n",
    "tafeng_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Choice Model Specification\n",
    "\n",
    "In this example we will use the sales_price and age_group features to estimate a discrete choice model in the form of a conditional MNL:\n",
    "\n",
    "for a customer $z$ and a product $i$, we define the utility function:\n",
    "\n",
    "$$U(i, z) = u_i + e_{dem(z)} \\cdot p_i$$\n",
    "\n",
    "with:\n",
    "- $u_i$ the base utility of product $i$\n",
    "- $p_i$ the price of product $i$\n",
    "- $e_{dem(z)}$ the price elasticity of customer $z$ depending of its age\n",
    "\n",
    "We decide to estimate three coefficients of price elasticity for customers <=25 y.o, 26<=.<=55 y.o. and =>56 y.o."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:Shared Features Names were not provided, will not be able to\n",
      "                                    fit models needing them such as Conditional Logit.\n",
      "WARNING:root:Items Features Names were not provided, will not be able to\n",
      "                                fit models needing them such as Conditional Logit.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age Categories Encoding for choices 0, 4 and 16:\n",
      "[[0. 1. 0.]\n",
      " [1. 0. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# Let's reload the TaFeng dataset as a Choice Dataset\n",
    "dataset = load_tafeng(as_frame=False, preprocessing=\"assort_example\")\n",
    "\n",
    "# The age categories are encoded as OneHot features:\n",
    "print(\"Age Categories Encoding for choices 0, 4 and 16:\")\n",
    "print(dataset.shared_features_by_choice[0][[0, 4, 16]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define a custom model that would fit our formulation using Choice-Learn's ChoiceModel inheritance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from choice_learn.models.base_model import ChoiceModel\n",
    "\n",
    "\n",
    "class TaFengMNL(ChoiceModel):\n",
    "    \"\"\"Custom model for the TaFeng dataset.\"\"\"\n",
    "\n",
    "    def __init__(self, **kwargs):\n",
    "        \"\"\"Instantiation of our custom model.\"\"\"\n",
    "        # Standard inheritance stuff\n",
    "        super().__init__(**kwargs)\n",
    "\n",
    "        # Instantiation of base utilties weights\n",
    "        # We have 25 items in the dataset making 25 weights\n",
    "        self.base_utilities = tf.Variable(\n",
    "                            tf.random_normal_initializer(0.0, 0.02, seed=42)(shape=(1, 25))\n",
    "                        )\n",
    "        # Instantiation of price elasticities weights\n",
    "        # We have 3 age categories making 3 weights\n",
    "        self.price_elasticities = tf.Variable(\n",
    "                            tf.random_normal_initializer(0.0, 0.02, seed=42)(shape=(1, 3))\n",
    "                        )\n",
    "        # Don't forget to add the weights to be optimized in self.weights !\n",
    "        self.trainable_weights = [self.base_utilities, self.price_elasticities]\n",
    "\n",
    "    def compute_batch_utility(self,\n",
    "                              shared_features_by_choice,\n",
    "                              items_features_by_choice,\n",
    "                              available_items_by_choice,\n",
    "                              choices):\n",
    "        \"\"\"Method that defines how the model computes the utility of a product.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        shared_features_by_choice : tuple of np.ndarray (choices_features)\n",
    "            a batch of shared features\n",
    "            Shape must be (n_choices, n_shared_features)\n",
    "        items_features_by_choice : tuple of np.ndarray (choices_items_features)\n",
    "            a batch of items features\n",
    "            Shape must be (n_choices, n_items_features)\n",
    "        available_items_by_choice : np.ndarray\n",
    "            A batch of items availabilities\n",
    "            Shape must be (n_choices, n_items)\n",
    "        choices_batch : np.ndarray\n",
    "            Choices\n",
    "            Shape must be (n_choices, )\n",
    "\n",
    "        Returns:\n",
    "        --------\n",
    "        np.ndarray\n",
    "            Utility of each product for each choice.\n",
    "            Shape must be (n_choices, n_items)\n",
    "        \"\"\"\n",
    "        # Unused arguments\n",
    "        _ = (available_items_by_choice, choices)\n",
    "\n",
    "        # Get the right price elasticity coefficient according to the age cateogry\n",
    "        price_coeffs = tf.tensordot(shared_features_by_choice,\n",
    "                                    tf.transpose(self.price_elasticities),\n",
    "                                    axes=1)\n",
    "        # Compute the utility: u_i + p_i * c\n",
    "        return tf.multiply(items_features_by_choice[:, :, 0], price_coeffs) + self.base_utilities\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Choice Model Estimation\n",
    "\n",
    "We estimate the coefficients values using .fit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using L-BFGS optimizer, setting up .fit() function\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:L-BFGS Opimization finished:\n",
      "WARNING:root:---------------------------------------------------------------\n",
      "WARNING:root:Number of iterations: 225\n",
      "WARNING:root:Algorithm converged before reaching max iterations: True\n"
     ]
    }
   ],
   "source": [
    "model = TaFengMNL(optimizer=\"lbfgs\", epochs=1000, tolerance=1e-4)\n",
    "history = model.fit(dataset, verbose=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can observe estimated coefficients with the .weights argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model Negative Log-Likelihood:  tf.Tensor(2.7657256, shape=(), dtype=float32)\n",
      "Model Weights:\n",
      "Base Utilities u_i: [[ 0.5068263   2.935736    1.998015    0.5470789   0.72602475  1.0055478\n",
      "  -0.7196758  -0.970541   -0.00946927 -3.042058    1.0770373   1.6368566\n",
      "  -3.6405432  -1.2479168   3.0117846   1.6831478   1.8547137  -1.2627332\n",
      "  -1.1671457  -0.08575154 -1.773998   -1.9642268  -1.7941352   1.5037025\n",
      "  -0.7460297 ]]\n",
      "Price Elasticities: [[-0.06286521 -0.05761966 -0.05427208]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Model Negative Log-Likelihood: \", model.evaluate(dataset))\n",
    "print(\"Model Weights:\")\n",
    "print(\"Base Utilities u_i:\", model.trainable_weights[0].numpy())\n",
    "print(\"Price Elasticities:\", model.trainable_weights[1].numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a short analysis we can observe that the price elasticiy in negative as expected and the younger the population the more impacted by the price.\\\n",
    "Our models looks good enough for a first and fast modelization.\n",
    "Now let's see how to compute an optimal assortment using our model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assortment Optimization\n",
    "\n",
    "### Preparing the data\n",
    "\n",
    "The first step is to compute the utility of each product. Here, let's consider that the last prices will also be the future prices of our products in our future assortment.\\\n",
    "It can be easily adapted if theses prices were to be changed.\\\n",
    "We can compute each age category utility using the *compute_batch_utility* method of our ChoiceModel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true
   },
   "outputs": [],
   "source": [
    "future_prices = np.stack([dataset.items_features_by_choice[0][-1]]*3, axis=0)\n",
    "age_category = np.array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]).astype(\"float32\")\n",
    "predicted_utilities = model.compute_batch_utility(shared_features_by_choice=age_category,\n",
    "                                                  items_features_by_choice=future_prices,\n",
    "                                                  available_items_by_choice=None,\n",
    "                                                  choices=None\n",
    "                                                  )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We compute the ratio of each age category appearance in our dataset to obtain an average utility for each product."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated final utilities for each product: [-0.24978125 -0.3917887  -0.7043624  -0.5408898  -0.4812412  -0.38806686\n",
      " -0.6586153  -0.93256587 -0.72640586 -1.5850058  -1.3158809  -0.17763059\n",
      " -1.6322378  -0.83469564 -0.49966928 -0.80931807 -1.0566555  -0.8396344\n",
      " -0.8077719  -0.69473463 -0.99102306 -1.0163671  -1.0167683  -1.3830209\n",
      " -0.4294889 ]\n"
     ]
    }
   ],
   "source": [
    "age_frequencies = np.mean(dataset.shared_features_by_choice[0], axis=0)\n",
    "\n",
    "final_utilities = []\n",
    "for freq, ut in zip(age_frequencies, predicted_utilities):\n",
    "    final_utilities.append(freq*ut)\n",
    "final_utilities = np.mean(final_utilities, axis=0)\n",
    "print(\"Estimated final utilities for each product:\", final_utilities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to define what quantity needs to be optimized by our assortment. A usual answer is to optimize the revenue or margin. In our case we do not have these values, so let's say that we want to obtain the assortment with 12 products that will generate the highest turnover.\n",
    "\n",
    "### Choice-Learn's AssortmentOptimizer\n",
    "Choice-Learn integrates algorithms for assortment planning based on Gurobi or OR-Tools. You can choose which solver you want by specifying `solver=\"gurobi\"` or `solver=\"or-tools\"`.\\\n",
    "Gurobi needs a license (free for Academics), however, it is usually faster than the open-source OR-Tools.\\\n",
    "Let's see an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "solver = \"gurobi\"\n",
    "# solver = \"or-tools\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from choice_learn.toolbox.assortment_optimizer import MNLAssortmentOptimizer\n",
    "\n",
    "opt = MNLAssortmentOptimizer(\n",
    "    solver=solver,\n",
    "    utilities=np.exp(final_utilities), # Utilities need to be transformed with exponential function\n",
    "    itemwise_values=future_prices[0][:, 0], # Values to optimize for each item, here price that is used to compute turnover\n",
    "    assortment_size=12) # Size of the assortment we want"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our Optimal Assortment is:\n",
      "[0. 1. 1. 1. 0. 0. 0. 1. 1. 1. 1. 0. 1. 0. 1. 1. 1. 0. 0. 0. 0. 0. 0. 1.\n",
      " 0.]\n",
      "With an estimated average revenue of: 51.57688285623652\n"
     ]
    }
   ],
   "source": [
    "assortment, opt_obj = opt.solve()\n",
    "print(\"Our Optimal Assortment is:\")\n",
    "print(assortment)\n",
    "print(\"With an estimated average revenue of:\", opt_obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Latent Class Assortment Optimizer\n",
    "\n",
    "This simplistic version is not optimal since it uses an averaged utility of each product over the population resulting in an approximative probability.\\\n",
    "Choice-Learn also proposes an implementation of the Mixed-Integer Programming approach described in [1]. This version works for latent class models and fits well in our case with different populations.\\\n",
    "The usage is similar with the object LatentClassAssortmentOptimizer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from choice_learn.toolbox.assortment_optimizer import LatentClassAssortmentOptimizer\n",
    "\n",
    "opt = LatentClassAssortmentOptimizer(\n",
    "    solver=solver,\n",
    "    class_weights=age_frequencies, # Weights of each class\n",
    "    class_utilities=np.exp(predicted_utilities), # utilities in the shape (n_classes, n_items)\n",
    "    itemwise_values=future_prices[0][:, 0], # Values to optimize for each item, here price that is used to compute turnover\n",
    "    assortment_size=12) # Size of the assortment we want"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our Optimal Assortment is:\n",
      "[0. 1. 1. 1. 1. 1. 0. 0. 1. 0. 1. 1. 0. 0. 1. 1. 1. 0. 0. 0. 0. 0. 0. 1.\n",
      " 0.]\n",
      "With an estimated average revenue of: 35.79552031037327\n",
      "Totalling 12.0 items in the assortment, which is fine with our limit of 12.\n"
     ]
    }
   ],
   "source": [
    "assortment, opt_obj = opt.solve()\n",
    "print(\"Our Optimal Assortment is:\")\n",
    "print(assortment)\n",
    "print(\"With an estimated average revenue of:\", opt_obj)\n",
    "print(\"Totalling\", np.sum(assortment), \"items in the assortment, which is fine with our limit of 12.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With this version, our results are slightly more precise - however we used integer in the LP formulation that can lead to slower results with large number of items."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding capacity constraints\n",
    "It is possible to add some constraints. A recurrent case is that the assortment of product will be placed in store and we need to take into account the available space.\n",
    "\n",
    "For the example we will imaginary values for each item size and a maximum total size of the assortment of 35."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The random items sizes are: [3 3 7 2 4 7 2 1 2 1 1 4 5 1 1 5 2 8 4 3 5 8 3 5 9]\n",
      "Capacity of previous optimal assortment: 43.0\n",
      "Higher than our limit of 35!\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(123)\n",
    "sizes = np.random.randint(1, 10, size=len(assortment))\n",
    "print(\"The random items sizes are:\", sizes)\n",
    "print(\"Capacity of previous optimal assortment:\", np.sum(sizes * assortment))\n",
    "print(\"Higher than our limit of 35!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our Optimal Assortment is:\n",
      "[0. 1. 1. 1. 1. 0. 0. 0. 0. 0. 1. 1. 0. 0. 1. 1. 1. 0. 0. 0. 0. 0. 0. 1.\n",
      " 0.]\n",
      "With an estimated average revenue of: 35.46667393198682\n",
      "Size of our assortment: 10 which is fine with our limit of 12!\n",
      "Capacity of our new assortment: 34.0 which is below our limit of 35!\n"
     ]
    }
   ],
   "source": [
    "opt = LatentClassAssortmentOptimizer(\n",
    "    solver=solver,\n",
    "    class_weights=age_frequencies, # Weights of each class\n",
    "    class_utilities=np.exp(predicted_utilities), # utilities in the shape (n_classes, n_items)\n",
    "    itemwise_values=future_prices[0][:, 0], # Values to optimize for each item, here price that is used to compute turnover\n",
    "    assortment_size=12) # Size of the assortment we want\n",
    "\n",
    "opt.add_maximal_capacity_constraint(itemwise_capacities=sizes, maximum_capacity=35)\n",
    "\n",
    "assortment, opt_obj = opt.solve()\n",
    "print(\"Our Optimal Assortment is:\")\n",
    "print(assortment)\n",
    "print(\"With an estimated average revenue of:\", opt_obj)\n",
    "print(\"Size of our assortment:\", np.sum((assortment > 0)), \"which is fine with our limit of 12!\")\n",
    "print(\"Capacity of our new assortment:\", np.sum(sizes * assortment), \"which is below our limit of 35!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The opposite constraint exists with .add_minimal_capacity_constraint() that adds a minimal value to be exceeded."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pricing and Assortment Optimization\n",
    "\n",
    "Since our model takes the price into consideration, it is possible to optimize both the assortment and the price of the products of the assortment at the same time !\n",
    "\n",
    "The optimization is slightly more complex. The idea is to define a discretization of the prices with the correspondign utilities and itemwise values.\n",
    "\n",
    "Let's take as an example a product $i$ whose utility function is $U(i) = u_i - p_i$ with $u_i$=1.5 and $p_i$ its price.\\\n",
    "We decide that the price range we accept to sell $i$ at is [2.5, 3.5] and to discretize into 6 values.\\\n",
    "If we have the cost $c_i=2.0$ we can use the margin $m_i = p_i -c_i$ as itemwise value otherwise we can take the revenue, $r_i=p_i$.\n",
    "\n",
    "<center>\n",
    "\n",
    "| Price | Utility | Margin | Revenue |\n",
    "| --- | --- | --- | --- |\n",
    "| 2.5 | -1.0 | 0.5 | 2.5 |\n",
    "| 2.7 | -1.2 | 0.7 | 2.7 |\n",
    "| 2.9 | -1.4 | 0.9 | 2.9 |\n",
    "| 3.1 | -1.6 | 1.1 | 3.1 |\n",
    "| 3.3 | -1.8 | 1.3 | 3.3 |\n",
    "| 3.5 | -2.0 | 1.5 | 3.5 |\n",
    "\n",
    "</center>\n",
    "\n",
    "The idea in the optimization is either not to choose the item because another item is more valuable or to choose at most one price that is optimal toward our objective.\n",
    "\n",
    "Coming back to our example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(25, 10) (3, 25, 10)\n"
     ]
    }
   ],
   "source": [
    "# Lets create a discretized grid of prices for each item\n",
    "prices_grid = []\n",
    "for item_index in range(25):\n",
    "    min_price = 0.9 * np.min(dataset.items_features_by_choice[0][:, item_index])\n",
    "    max_price = 1.1 * np.max(dataset.items_features_by_choice[0][:, item_index])\n",
    "    prices_grid.append(np.linspace(min_price, max_price, 10))\n",
    "prices_grid = np.stack(prices_grid, axis=0)\n",
    "\n",
    "# Computing the corresponding utilities\n",
    "items_utilities = []\n",
    "for age_index in [0, 1, 2]:\n",
    "    age_category = np.zeros((len(prices_grid[0]), 3)).astype(\"float32\")\n",
    "    age_category[:, age_index] = 1.\n",
    "    predicted_utilities = model.compute_batch_utility(shared_features_by_choice=age_category,\n",
    "                                                  items_features_by_choice=np.expand_dims(np.transpose(prices_grid), axis=-1),\n",
    "                                                  available_items_by_choice=None,\n",
    "                                                  choices=None\n",
    "                                                  )\n",
    "    items_utilities.append(np.exp(predicted_utilities).T)\n",
    "item_utilities = np.stack(items_utilities, axis=0)\n",
    "\n",
    "print(prices_grid.shape, item_utilities.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use another AssortmentOptimizer class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from choice_learn.toolbox.assortment_optimizer import LatentClassPricingOptimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our Optimal Assortment is:\n",
      "[ 0.         59.7        59.7        41.8        41.8        41.8\n",
      "  0.          0.          0.          0.         60.01111111 41.8\n",
      "  0.          0.         59.62222222 56.06666667 57.6         0.\n",
      "  0.         53.12222222  0.          0.          0.         56.7\n",
      "  0.        ]\n",
      "With an estimated average revenue of: 41.21468607531388\n",
      "Size of our assortment: 12 which is fine with our limit of 12!\n"
     ]
    }
   ],
   "source": [
    "opt = LatentClassPricingOptimizer(\n",
    "    solver=solver,\n",
    "    class_weights=age_frequencies, # Weights of each class\n",
    "    class_utilities=item_utilities, # utilities in the shape (n_classes, n_items)\n",
    "    itemwise_values=prices_grid, # Values to optimize for each item, here price that is used to compute turnover\n",
    "    assortment_size=12) # Size of the assortment we want\n",
    "\n",
    "# opt.add_maximal_capacity_constraint(itemwise_capacities=sizes, maximum_capacity=35)\n",
    "\n",
    "assortment, opt_obj = opt.solve()\n",
    "print(\"Our Optimal Assortment is:\")\n",
    "print(assortment)\n",
    "print(\"With an estimated average revenue of:\", opt_obj)\n",
    "print(\"Size of our assortment:\", np.sum((assortment > 0)), \"which is fine with our limit of 12!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can first observe that the estimated average revenue is higher than the previous one with the chosen prices.\\\n",
    "Let's look at the difference:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| Previous price | Optimized price |\n",
      "------------------------------------\n",
      "|      72.0      |      59.7       |\n",
      "|      72.0      |      59.7       |\n",
      "|      38.0      |      41.8       |\n",
      "|      38.0      |      41.8       |\n",
      "|      38.0      |      41.8       |\n",
      "|      88.0      |      60.0       |\n",
      "|      38.0      |      41.8       |\n",
      "|      79.0      |      59.6       |\n",
      "|      72.0      |      56.1       |\n",
      "|      88.0      |      57.6       |\n",
      "|      35.0      |      53.1       |\n",
      "|      99.0      |      56.7       |\n"
     ]
    }
   ],
   "source": [
    "print(\"| Previous price\",\"|\", \"Optimized price |\")\n",
    "print(\"------------------------------------\")\n",
    "for i in range(len(assortment)):\n",
    "    if assortment[i] > 0:\n",
    "        print(\"|     \", future_prices[0][i, 0], \"     |     \", np.round(assortment[i], 1), \"      |\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As previously, we can add capacity constraints:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep_output": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our Optimal Assortment is:\n",
      "[ 0.         59.7        59.7        41.8         0.          0.\n",
      "  0.          0.         41.8         0.         60.01111111 41.8\n",
      "  0.          0.         59.62222222 56.06666667 57.6         0.\n",
      "  0.         53.12222222  0.          0.          0.         56.7\n",
      "  0.        ]\n",
      "With an estimated average revenue of: 41.164100003155916\n",
      "Size of our assortment: 11 which is fine with our limit of 12!\n",
      "Capacity of our new assortment: 35 which is below our limit of 35!\n"
     ]
    }
   ],
   "source": [
    "opt = LatentClassPricingOptimizer(\n",
    "    solver=solver,\n",
    "    class_weights=age_frequencies, # Weights of each class\n",
    "    class_utilities=item_utilities, # utilities in the shape (n_classes, n_items)\n",
    "    itemwise_values=prices_grid, # Values to optimize for each item, here price that is used to compute turnover\n",
    "    assortment_size=12) # Size of the assortment we want\n",
    "\n",
    "opt.add_maximal_capacity_constraint(itemwise_capacities=sizes, maximum_capacity=35)\n",
    "\n",
    "assortment, opt_obj = opt.solve()\n",
    "print(\"Our Optimal Assortment is:\")\n",
    "print(assortment)\n",
    "print(\"With an estimated average revenue of:\", opt_obj)\n",
    "print(\"Size of our assortment:\", np.sum((assortment > 0)), \"which is fine with our limit of 12!\")\n",
    "print(\"Capacity of our new assortment:\", np.sum(sizes * (assortment > 0)), \"which is below our limit of 35!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ending Notes\n",
    "- In this example, the outside option is automatically integrated in the AssortmentOptimizer and not computed through the model. If you compute the outside option utility and give it to AssortmentOptimizer you can set its attribute *outside_option_given* to True.\n",
    "- The current AssortmentOptimzer uses [Gurobi](https://www.gurobi.com/) for which you need a license (free for Academics) or [OR-Tools](https://developers.google.com/optimization?hl=fr) that is OpenSource.\n",
    "- If you want to add custom constraints you can use the base code of the AssortmentOptimizer and manually add your constraints. Future developments will add an easy interface to integrate such needs.\n",
    "\n",
    "## References\n",
    "\n",
    "[1] Isabel Méndez-Díaz, Juan José Miranda-Bront, Gustavo Vulcano, Paula Zabala,\n",
    "A branch-and-cut algorithm for the latent-class logit assortment problem,\n",
    "Discrete Applied Mathematics,\n",
    "Volume 164, Part 1,\n",
    "2014,\n",
    "Pages 246-263,\n",
    "ISSN 0166-218X,\n",
    "https://doi.org/10.1016/j.dam.2012.03.003.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "name": "Assortment Example",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "tf_env",
   "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.8.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}