Code/8.2-NestedLogitModels/02-logit-nested-market.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Nested Logit Model: Compute Market Shares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import biogeme.database as db\n",
    "import biogeme.biogeme as bio\n",
    "import biogeme.models as models\n",
    "import biogeme.optimization as opt\n",
    "import biogeme.results as res\n",
    "from biogeme.expressions import Beta, DefineVariable\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Import Optima data**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "pandas = pd.read_csv(\"../../Data/8-DiscreteChoiceModels/optima.dat\",sep='\\t')\n",
    "database = db.Database (\"data/optima\", pandas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Use collumn names as variables**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "globals().update(database.variables)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exclude some unwanted entries**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "exclude = (Choice == -1.)\n",
    "database.remove(exclude)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Define some dummy variables**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "male = (Gender == 1)\n",
    "female = (Gender == 2)\n",
    "unreportedGender = (Gender == -1)\n",
    "\n",
    "fulltime = (OccupStat == 1)\n",
    "notfulltime = (OccupStat != 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Rescale some data**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "TimePT_scaled = TimePT / 200\n",
    "TimeCar_scaled = TimeCar / 200\n",
    "MarginalCostPT_scaled = MarginalCostPT / 10 \n",
    "CostCarCHF_scaled = CostCarCHF / 10\n",
    "distance_km_scaled = distance_km / 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Create parameters to be estimated**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "ASC_CAR              = Beta('ASC_CAR',0,None,None,0)\n",
    "ASC_PT               = Beta('ASC_PT',0,None,None,1)\n",
    "ASC_SM               = Beta('ASC_SM',0,None,None,0)\n",
    "BETA_TIME_FULLTIME   = Beta('BETA_TIME_FULLTIME',0,None,None,0)\n",
    "BETA_TIME_OTHER      = Beta('BETA_TIME_OTHER',0,None,None,0)\n",
    "BETA_DIST_MALE       = Beta('BETA_DIST_MALE',0,None,None,0)\n",
    "BETA_DIST_FEMALE     = Beta('BETA_DIST_FEMALE',0,None,None,0)\n",
    "BETA_DIST_UNREPORTED = Beta('BETA_DIST_UNREPORTED',0,None,None,0)\n",
    "BETA_COST            = Beta('BETA_COST',0,None,None,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Define the utility functions**\n",
    "\n",
    "\\begin{align}\n",
    "V_{PT} & = \\beta_{PT} + \\beta_{time_{fulltime}} X_{time_{PT}} X_{fulltime} + \\beta_{time_{other}} X_{time_{PT}} X_{not\\_fulltime} + \\beta_{cost} X_{cost_{PT}} \\\\\n",
    "V_{car} & = \\beta_{car} + \\beta_{time_{fulltime}} X_{time_{car}} X_{fulltime} + \\beta_{time_{other}} X_{time_{car}} X_{not\\_fulltime} + \\beta_{cost} X_{cost_{car}} \\\\\n",
    "V_{SM} & = \\beta_{SM} + \\beta_{male} X_{distance} X_{male} + \\beta_{female} X_{distance} X_{female} + \\beta_{unreported} X_{distance} X_{unreported}\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "V_PT = ASC_PT + BETA_TIME_FULLTIME * TimePT_scaled * fulltime + \\\n",
    "       BETA_TIME_OTHER * TimePT_scaled * notfulltime + \\\n",
    "       BETA_COST * MarginalCostPT_scaled\n",
    "V_CAR = ASC_CAR + \\\n",
    "        BETA_TIME_FULLTIME * TimeCar_scaled * fulltime + \\\n",
    "        BETA_TIME_OTHER * TimeCar_scaled * notfulltime + \\\n",
    "        BETA_COST * CostCarCHF_scaled\n",
    "V_SM = ASC_SM + \\\n",
    "       BETA_DIST_MALE * distance_km_scaled * male + \\\n",
    "       BETA_DIST_FEMALE * distance_km_scaled * female + \\\n",
    "       BETA_DIST_UNREPORTED * distance_km_scaled * unreportedGender"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Associate utility functions with alternatives and associate availability of alternatives**\n",
    "\n",
    "In this example all alternatives are available for each individual"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "V = {0: V_PT,\n",
    "     1: V_CAR,\n",
    "     2: V_SM}\n",
    "\n",
    "av = {0: 1,\n",
    "      1: 1,\n",
    "      2: 1}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Define the nests**\n",
    "\n",
    "1. Define the nests paramenters\n",
    "2. List alternatives in nests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "MU_NO_CAR = Beta('MU_NO_CAR', 1.,1.,None,0)\n",
    "\n",
    "CAR_NEST = 1., [1]\n",
    "NO_CAR_NEST = MU_NO_CAR, [0, 2]\n",
    "\n",
    "nests = CAR_NEST, NO_CAR_NEST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Define the choice probabilities**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "prob_pt  = models.nested(V, av , nests , 0)\n",
    "prob_car = models.nested(V, av , nests , 1)\n",
    "prob_sm  = models.nested(V, av , nests , 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Compute normalizing weights for each alternative**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "sumWeight = database.data['Weight'].sum()\n",
    "normalized_Weight = Weight * len(database.data['Weight']) / sumWeight"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Define what we want to simulate**\n",
    "\n",
    "1. Normalized weights\n",
    "2. Choice probabilities for each choice\n",
    "3. Revenues for the Public Transportation alternative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "simulate ={'weight':  normalized_Weight ,\n",
    "           'Prob. car':  prob_car ,\n",
    "           'Prob. public transportation':  prob_pt ,\n",
    "           'Prob. slow modes': prob_sm ,\n",
    "           'Revenue public transportation': prob_pt * MarginalCostPT}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Define the Biogeme object**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "biogeme = bio.BIOGEME(database, simulate)\n",
    "biogeme.modelName = \"optima_nested_logit_market\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Retrieve the names of the variables we want to use. Then retrieve the results from the model that we estimated earlier**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting the following variables:\n",
      "\t ASC_CAR\n",
      "\t ASC_SM\n",
      "\t BETA_COST\n",
      "\t BETA_DIST_FEMALE\n",
      "\t BETA_DIST_MALE\n",
      "\t BETA_DIST_UNREPORTED\n",
      "\t BETA_TIME_FULLTIME\n",
      "\t BETA_TIME_OTHER\n",
      "\t MU_NO_CAR\n"
     ]
    }
   ],
   "source": [
    "betas = biogeme.freeBetaNames\n",
    "\n",
    "print('Extracting the following variables:')\n",
    "for k in betas:\n",
    "    print('\\t',k)\n",
    "\n",
    "results = res.bioResults(pickleFile='optima_nested_logit.pickle')\n",
    "betaValues = results.getBetaValues ()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Perform the simulation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "simulatedValues = biogeme.simulate(betaValues)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Compute confidente intervals using this simulation. Compare results using normal estimation and with bootstrapping.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "betas = biogeme.freeBetaNames\n",
    "b_bootstrap = results.getBetasForSensitivityAnalysis(betas)\n",
    "b_normal = results.getBetasForSensitivityAnalysis(\n",
    "    betas, size=100, useBootstrap=False\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Returns data frame containing, for each simulated value, the left\n",
    "# and right bounds of the confidence interval calculated by\n",
    "# simulation.\n",
    "left_bootstrap, right_bootstrap = biogeme.confidenceIntervals(b_bootstrap, 0.9)\n",
    "left_normal, right_normal = biogeme.confidenceIntervals(b_normal, 0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Car Market Share**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Market share for car: 65.3% bootstrap[61.5%, 69.2%] normal[59.9%, 68.8%]\n"
     ]
    }
   ],
   "source": [
    "simulatedValues['Weighted prob. car'] = (\n",
    "    simulatedValues['weight'] * simulatedValues['Prob. car']\n",
    ")\n",
    "left_bootstrap['Weighted prob. car'] = (\n",
    "    left_bootstrap['weight'] * left_bootstrap['Prob. car']\n",
    ")\n",
    "right_bootstrap['Weighted prob. car'] = (\n",
    "    right_bootstrap['weight'] * right_bootstrap['Prob. car']\n",
    ")\n",
    "left_normal['Weighted prob. car'] = (\n",
    "    left_normal['weight'] * left_normal['Prob. car']\n",
    ")\n",
    "right_normal['Weighted prob. car'] = (\n",
    "    right_normal['weight'] * right_normal['Prob. car']\n",
    ")\n",
    "\n",
    "marketShare_car = simulatedValues['Weighted prob. car'].mean()\n",
    "\n",
    "marketShare_car_left_bootstrap = left_bootstrap['Weighted prob. car'].mean()\n",
    "marketShare_car_right_bootstrap = right_bootstrap['Weighted prob. car'].mean()\n",
    "marketShare_car_left_normal = left_normal['Weighted prob. car'].mean()\n",
    "marketShare_car_right_normal = right_normal['Weighted prob. car'].mean()\n",
    "\n",
    "print(\n",
    "    f'Market share for car: {100*marketShare_car:.1f}% '\n",
    "    f'bootstrap[{100*marketShare_car_left_bootstrap:.1f}%, '\n",
    "    f'{100*marketShare_car_right_bootstrap:.1f}%]'\n",
    "    f' normal[{100*marketShare_car_left_normal:.1f}%, '\n",
    "    f'{100*marketShare_car_right_normal:.1f}%]'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Public Transportation Market Share**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Market share for PT: 28.1% bootstrap[24.1%, 31.8%]normal[23.7%, 32.5%]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "simulatedValues['Weighted prob. PT'] = (\n",
    "    simulatedValues['weight'] * simulatedValues['Prob. public transportation']\n",
    ")\n",
    "\n",
    "marketShare_pt = simulatedValues['Weighted prob. PT'].mean()\n",
    "\n",
    "marketShare_pt_left_bootstrap = (\n",
    "    left_bootstrap['Prob. public transportation'] * left_bootstrap['weight']\n",
    ").mean()\n",
    "marketShare_pt_right_bootstrap = (\n",
    "    right_bootstrap['Prob. public transportation'] * right_bootstrap['weight']\n",
    ").mean()\n",
    "marketShare_pt_left_normal = (\n",
    "    left_normal['Prob. public transportation'] * left_normal['weight']\n",
    ").mean()\n",
    "marketShare_pt_right_normal = (\n",
    "    right_normal['Prob. public transportation'] * right_normal['weight']\n",
    ").mean()\n",
    "\n",
    "print(\n",
    "    f'Market share for PT: {100*marketShare_pt:.1f}% '\n",
    "    f'bootstrap[{100*marketShare_pt_left_bootstrap:.1f}%, '\n",
    "    f'{100*marketShare_pt_right_bootstrap:.1f}%]'\n",
    "    f'normal[{100*marketShare_pt_left_normal:.1f}%, '\n",
    "    f'{100*marketShare_pt_right_normal:.1f}%]'\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Slow Modes Market Share**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Market share for slow modes: 6.6% bootstrap[4.2%, 9.5%] normal[4.9%, 11.0%]\n"
     ]
    }
   ],
   "source": [
    "marketShare_sm = (\n",
    "    simulatedValues['Prob. slow modes'] * simulatedValues['weight']\n",
    ").mean()\n",
    "\n",
    "marketShare_sm_left_bootstrap = (\n",
    "    left_bootstrap['Prob. slow modes'] * left_bootstrap['weight']\n",
    ").mean()\n",
    "marketShare_sm_right_bootstrap = (\n",
    "    right_bootstrap['Prob. slow modes'] * right_bootstrap['weight']\n",
    ").mean()\n",
    "marketShare_sm_left_normal = (\n",
    "    left_normal['Prob. slow modes'] * left_normal['weight']\n",
    ").mean()\n",
    "marketShare_sm_right_normal = (\n",
    "    right_normal['Prob. slow modes'] * right_normal['weight']\n",
    ").mean()\n",
    "\n",
    "print(\n",
    "    f'Market share for slow modes: {100*marketShare_sm:.1f}% '\n",
    "    f'bootstrap[{100*marketShare_sm_left_bootstrap:.1f}%, '\n",
    "    f'{100*marketShare_sm_right_bootstrap:.1f}%]'\n",
    "    f' normal[{100*marketShare_sm_left_normal:.1f}%, '\n",
    "    f'{100*marketShare_sm_right_normal:.1f}%]'\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Public Transportation revenue estimation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Revenues for PT: 3018.371 bootstrap[2448.232, 3579.859] normal[2485.135, 3875.832]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "revenues_pt = (\n",
    "    simulatedValues['Revenue public transportation']\n",
    "    * simulatedValues['weight']\n",
    ").sum()\n",
    "\n",
    "revenues_pt_left_bootstrap = (\n",
    "    left_bootstrap['Revenue public transportation'] * left_bootstrap['weight']\n",
    ").sum()\n",
    "revenues_pt_right_bootstrap = (\n",
    "    right_bootstrap['Revenue public transportation']\n",
    "    * right_bootstrap['weight']\n",
    ").sum()\n",
    "revenues_pt_left_normal = (\n",
    "    left_normal['Revenue public transportation'] * left_normal['weight']\n",
    ").sum()\n",
    "revenues_pt_right_normal = (\n",
    "    right_normal['Revenue public transportation'] * right_normal['weight']\n",
    ").sum()\n",
    "print(\n",
    "    f'Revenues for PT: {revenues_pt:.3f} '\n",
    "    f'bootstrap[{revenues_pt_left_bootstrap:.3f}, '\n",
    "    f'{revenues_pt_right_bootstrap:.3f}]'\n",
    "    f' normal[{revenues_pt_left_normal:.3f}, '\n",
    "    f'{revenues_pt_right_normal:.3f}]'\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}