pricing/price-optimization-multiple-products.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Price and Markdown Optimization for Multiple Products\n",
    "\n",
    "This notebook demonstrates how to optimize prices or markdowns for multiple related products such as substitutable products within one category.\n",
    "\n",
    "### Use Case\n",
    "We consider a scenario where a seller offers multiple products in a category or group, so that the products are fully or partly substitutable. We assume that each product has its own price-demand function which is dependent on all other products. Our goal is to determine the revenue/profit-optimal price for each product taking into account the cross-dependencies.\n",
    "\n",
    "### Prototype: Approach and Data\n",
    "In the general case, the demand function for each product depends on all individual prices of other products. This brings a layer of complexity to accurate estimation and optimization, especially in the dynamic pricing settings. One possible simplification is to use a demand function that depends not on the individual prices of other products, but on the average price within a group of substitutable products. This can be an accurate approximation in many cases, because the ratio between a product’s own price and the average price in the group reflects the competitiveness of the product and quantifies demand cannibalization. In this case, we can assume a demand model that estimates multiple values for each possible average price instead of separate demand values for each product-price pair (the set of possible average prices is finite because the set of valid price levels is discrete). \n",
    "\n",
    "This concept can naturally be implemented using integer programming (IP). We formulate the optimization problem in linear programming (LP) terms for the sake of scalability (technique known as *linear relaxation*).\n",
    "\n",
    "### Usage and Productization\n",
    "The prototype uses the LP-based approach which provides enough scalability for optimizing large sets of products. Productization would requre to specify price-demand functions that account for the average price.\n",
    "\n",
    "### References\n",
    "1. Ferreira K., Simchi-Levi D., and Wang H. -- Online Network Revenue Management Using Thompson Sampling, November 2017"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Imports and settings\n",
    "#\n",
    "import numpy as np\n",
    "from tabulate import tabulate\n",
    "from scipy.optimize import linprog\n",
    "\n",
    "def tabprint(msg, A):\n",
    "    print(msg)\n",
    "    print(tabulate(A, tablefmt=\"fancy_grid\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Markdown Optimization as an LP Problem\n",
    "\n",
    "We solve the following optimization problem:\n",
    "\n",
    "$\\text{max} \\quad \\sum_{i=1}^{N} \\sum_{k=1}^{K} z_{ik} \\cdot p_{k} \\cdot q\\left(i, p_{k}, c\\right)$ \n",
    "\n",
    "$\\text{subject to}$\n",
    "\n",
    "$\\quad \\sum_{i=1}^{N} \\sum_{k=1}^{K} z_{ik} \\cdot q\\left(i, p_{k}, c\\right) = c$\n",
    "\n",
    "$\\quad \\sum_{k=1}^{N} z_{ik} = 1, \\quad \\text{for}\\ i=1,\\ldots,N $\n",
    "\n",
    "$\\quad z_{ik}\\ge 0 $\n",
    "\n",
    "where q is demand, p is price, N is the number products, K is the number of price levels, and c is the sum of prices (the measure of the average price). The demand values are assumed to be computed for a specific values of $c$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prices - k-dimensional vector of allowed price levels \n",
    "# demands - n x k matrix of demand predictions\n",
    "# c - required sum of prices \n",
    "# where k is the number of price levels, n is number of products\n",
    "def optimal_prices_category(prices, demands, c):\n",
    "    \n",
    "    n, k = np.shape(demands)  \n",
    "\n",
    "    # prepare inputs   \n",
    "    r = np.multiply(np.tile(prices, n), np.array(demands).reshape(1, k*n))\n",
    "    A = np.array([[\n",
    "        1 if j >= k*(i) and j < k*(i+1) else 0\n",
    "        for j in range(k*n)\n",
    "    ] for i in range(n)])\n",
    "    A = np.append(A, np.tile(prices, n), axis=0)\n",
    "    b = [np.append(np.ones(n), c)]\n",
    "\n",
    "    # solve the linear program\n",
    "    res = linprog(-r.flatten(), \n",
    "              A_eq = A, \n",
    "              b_eq = b,  \n",
    "              bounds=(0, 1))\n",
    "\n",
    "    return np.array(res.x).reshape(n, k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Test run\n",
    "#\n",
    "r = optimal_prices_category(\n",
    "  np.array([[1.00, 1.50, 2.00, 2.50]]),   # allowed price levels\n",
    "  np.array([\n",
    "    [ 28, 23, 20, 13],                    # demands for product 1\n",
    "    [ 30, 22, 16, 12],                    # demands for product 2\n",
    "    [ 32, 26, 19, 15]                     # demands for product 3\n",
    "  ]), 5.50)                               # sum of prices for all three products"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "prices = \n",
      "╒═════════════╤═════════════╤═════════════╤═════════════╕\n",
      "│ 3.53009e-11 │ 2.68242e-10 │ 1           │ 3.29004e-10 │\n",
      "├─────────────┼─────────────┼─────────────┼─────────────┤\n",
      "│ 6.92591e-11 │ 1           │ 3.21738e-10 │ 2.62897e-10 │\n",
      "├─────────────┼─────────────┼─────────────┼─────────────┤\n",
      "│ 2.4468e-10  │ 0.5         │ 1.29104e-09 │ 0.5         │\n",
      "╘═════════════╧═════════════╧═════════════╧═════════════╛\n"
     ]
    }
   ],
   "source": [
    "tabprint('prices = ', r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# output\n",
    "# [[0  0     1   0  ]                            # price vector for product 1 ($2.00)\n",
    "#  [0  1     0   0  ]                            # price vector for product 2 ($1.50)\n",
    "#  [0  0.5   0   0.5]]                           # price vector for product 3 ($1.50 and 2.50)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}