pricing/price-optimization-multiple-time-intervals.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Price and Markdown Optimization for Multiple Time Intervals\n",
    "\n",
    "This notebook demonstrates how to optimize promotion/markdown calendars under inventory constraints.\n",
    "\n",
    "### Use Case\n",
    "We assume an end-of-season sales scenario. We have a limited stock of a certain product and `N` consecutive time intervals each of which has its own demand function. Our goal is to sell out the stock in time maximizing the revenue. We also assume that the valid price levels are limited to a discrete dataset. \n",
    "\n",
    "### Prototype: Approach and Data\n",
    "The problem can be naturally represented in integer programming (IP) terms. We implement a linear relaxation of this IP to achieve better scalability.\n",
    "\n",
    "### Usage and Productization\n",
    "This notebook can be directly used to optimized promotion/markdown calendars. The linear programming approach provides enough flexibility to incorporate additional constraints such as cross-product dependencies.\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": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Imports and settings\n",
    "#\n",
    "import sympy as sy\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\", floatfmt=\".2f\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "plevels = [89, 79, 69, 59, 49] # allowed price levels\n",
    "C = 700                        # stock level\n",
    "\n",
    "price = sy.symbols(\"price\")\n",
    "\n",
    "def rectified(f):\n",
    "    return sy.Piecewise( (0, f < 0), (f, True))\n",
    "\n",
    "# Demand functions estimated for each week of the sale\n",
    "demands = [rectified(1500 - 10*price), # week 1\n",
    "           rectified(1300 - 15*price), # week 2\n",
    "           rectified(1200 - 15*price), # week 3\n",
    "           rectified(1100 - 18*price)] # week 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D =\n",
      "╒════════╤════════╤════════╤════════╤═════════╕\n",
      "│ 610.00 │ 710.00 │ 810.00 │ 910.00 │ 1010.00 │\n",
      "├────────┼────────┼────────┼────────┼─────────┤\n",
      "│   0.00 │ 115.00 │ 265.00 │ 415.00 │  565.00 │\n",
      "├────────┼────────┼────────┼────────┼─────────┤\n",
      "│   0.00 │  15.00 │ 165.00 │ 315.00 │  465.00 │\n",
      "├────────┼────────┼────────┼────────┼─────────┤\n",
      "│   0.00 │   0.00 │   0.00 │  38.00 │  218.00 │\n",
      "╘════════╧════════╧════════╧════════╧═════════╛\n",
      "R =\n",
      "╒══════════╤══════════╤══════════╤══════════╤══════════╕\n",
      "│ 54290.00 │ 56090.00 │ 55890.00 │ 53690.00 │ 49490.00 │\n",
      "├──────────┼──────────┼──────────┼──────────┼──────────┤\n",
      "│     0.00 │  9085.00 │ 18285.00 │ 24485.00 │ 27685.00 │\n",
      "├──────────┼──────────┼──────────┼──────────┼──────────┤\n",
      "│     0.00 │  1185.00 │ 11385.00 │ 18585.00 │ 22785.00 │\n",
      "├──────────┼──────────┼──────────┼──────────┼──────────┤\n",
      "│     0.00 │     0.00 │     0.00 │  2242.00 │ 10682.00 │\n",
      "╘══════════╧══════════╧══════════╧══════════╧══════════╛\n"
     ]
    }
   ],
   "source": [
    "# Evaluate values of demand functions for each price level\n",
    "D = np.array([[q.subs(price, p) for p in plevels] for q in demands])\n",
    "tabprint(\"D =\", D)\n",
    "\n",
    "# Evaluate revenue for each demand function and each price level\n",
    "R = np.array([[p*q.subs(price, p) for p in plevels] for q in demands])\n",
    "tabprint(\"R =\", R)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now we solve the following optimization problem:\n",
    "# (q is demand, P is price, T is the number of time periods, and K is the number of price levels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\text{max} \\quad \\sum_{t=1}^{T} \\sum_{i=1}^{K} z_{it} \\cdot P_{i} \\cdot q\\left(P_{i},t\\right)$ \n",
    "\n",
    "$\\text{subject to}$\n",
    "\n",
    "$\\quad \\sum_{t=1}^{T} \\sum_{i=1}^{K} z_{it} \\cdot q\\left(P_{i},t\\right) \\le C $\n",
    "\n",
    "$\\quad \\sum_{i=1}^{K} z_{it} = 1, \\quad \\text{for}\\ t=1,\\ldots,T $\n",
    "\n",
    "$\\quad z_{it}\\ge 0 $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M = \n",
      "╒══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╕\n",
      "│ 1.00 │ 1.00 │ 1.00 │ 1.00 │ 1.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │\n",
      "├──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┤\n",
      "│ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 1.00 │ 1.00 │ 1.00 │ 1.00 │ 1.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │\n",
      "├──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┤\n",
      "│ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 1.00 │ 1.00 │ 1.00 │ 1.00 │ 1.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │\n",
      "├──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┤\n",
      "│ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 0.00 │ 1.00 │ 1.00 │ 1.00 │ 1.00 │ 1.00 │\n",
      "╘══════╧══════╧══════╧══════╧══════╧══════╧══════╧══════╧══════╧══════╧══════╧══════╧══════╧══════╧══════╧══════╧══════╧══════╧══════╧══════╛\n",
      "Revenue value: $ 61400.000000123204\n",
      "Price schedule:\n",
      "╒══════╤══════╤══════╤══════╕\n",
      "│ 1.00 │ 0.29 │ 0.47 │ 0.33 │\n",
      "├──────┼──────┼──────┼──────┤\n",
      "│ 0.00 │ 0.71 │ 0.53 │ 0.33 │\n",
      "├──────┼──────┼──────┼──────┤\n",
      "│ 0.00 │ 0.00 │ 0.00 │ 0.33 │\n",
      "├──────┼──────┼──────┼──────┤\n",
      "│ 0.00 │ 0.00 │ 0.00 │ 0.00 │\n",
      "├──────┼──────┼──────┼──────┤\n",
      "│ 0.00 │ 0.00 │ 0.00 │ 0.00 │\n",
      "╘══════╧══════╧══════╧══════╛\n"
     ]
    }
   ],
   "source": [
    "L = len(demands)*len(plevels)\n",
    "\n",
    "# First, we generate a binary mask to ensure that all z's \n",
    "# in one time interval sum up to 1.0, that is z.M = B\n",
    "M = np.array([[\n",
    "    1 if i >= len(plevels)*j and i < len(plevels)*(j+1) else 0\n",
    "    for i in range(L)\n",
    "] for j in range(len(demands))])\n",
    "\n",
    "tabprint(\"M = \", M)\n",
    "\n",
    "B = [1 for i in range(len(demands))]\n",
    "\n",
    "# Second, we ensure that the sum of all demands is less than the available stock level,\n",
    "# that is z.Df <= C\n",
    "Df = np.array(D).reshape(1, L)\n",
    "\n",
    "res = linprog(-np.array(R).flatten(), \n",
    "              A_eq=M, \n",
    "              b_eq=B, \n",
    "              A_ub=Df, \n",
    "              b_ub=np.array([C]), \n",
    "              bounds=(0, None))\n",
    "\n",
    "print(\"Revenue value: $\", -res.fun)\n",
    "\n",
    "# Each column of the solution matrix corresponds to a time period (one week).  \n",
    "# Each row corresponds to z value that can be interpreted as the percentage \n",
    "# of time z't price level should be used in the corresponding time period. \n",
    "tabprint(\"Price schedule:\", np.array(res.x).reshape(len(demands), len(plevels)).T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}