monte_carlo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Monte Carlo\n",
    "\n",
    "This notebook creates two files. For a given number of market situations and a given set of prices, it creates features and saves them in the `demand_prediction_data` file. Next, for each market situation and each price, the notebook runs multiple simulations and tracks purchases. The notebook then calculates the probabilities of a purchase for each price and market situation and stores them in the `PEW_comparison` file. The time horizon is 1.\n",
    "\n",
    "Because of performance reasons the number of simulations and the number of considered market situations used in the start configuration are smaller than the ones used for the data for the paper. The inline comments show the values used in the paper, which lead to a longer runtime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "import csv\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set start values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "num_firm = 5                                   # the number of firms which we simulate\n",
    "time_horizon = 1                               # set the time horizon which we watch to 1 \n",
    "num_market_events = 2                          # the max price adjustments each firm will make\n",
    "mean_betw_customer_arrival = 2                 # chose mean for how often customers appear\n",
    "prices = np.arange(0,15.1,0.2)                 # values used for paper: (np.arange(0,15.1,0.1))\n",
    "watched_firm = 0                            \n",
    "num_sims = 100                                 # the number of simulations, value used for paper: 10000 \n",
    "num_market_situations = 10                     # the number of market situations with different start scenarios, \n",
    "                                               # value used for paper: 40\n",
    "num_customer_events = 4                        # the maximum number of customers\n",
    "reaction_time_firm = time_horizon              # watched firm doesn't update price in time horizon\n",
    "setups = [\"S1\",\"S2\",\"S3\"]                      # set the name of the setups from the paper\n",
    "random.seed(12530586)                          # set a random seed to always get comparable results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def explanatory_vars(explanatory_var, num_price, market_situation):\n",
    "    return {\n",
    "        '0' : 1,\n",
    "        '1' : price_ranks_firm[market_situation][num_price],\n",
    "        '2' : 1 if price_ranks_firm[market_situation][num_price]==1 else 0,\n",
    "        '3' : qual_rank_firm[market_situation],\n",
    "        '4' : rating_ranks[market_situation][watched_firm],\n",
    "        '5' : prices[num_price],\n",
    "        '6' : prices[num_price] - min([prices_firm_pred[j][market_situation] for j in range(num_firm) if j!=watched_firm]) if num_firm > 1 else 0,\n",
    "        '7' : qual_firm_pred[watched_firm][market_situation],\n",
    "        '8' : rating_firm_pred[watched_firm][market_situation],\n",
    "        '9' : 15 - (prices[num_price] +\n",
    "                    0.5*qual_firm_pred[watched_firm][market_situation] +\n",
    "                    0.25*(100-rating_firm_pred[watched_firm][market_situation])) \n",
    "        if((prices[num_price] +\n",
    "            0.5*qual_firm_pred[watched_firm][market_situation] +\n",
    "            0.25*(100-rating_firm_pred[watched_firm][market_situation])) \n",
    "           < min([\n",
    "               prices_firm_pred[j][market_situation] +\n",
    "               0.5*qual_firm_pred[j][market_situation] +\n",
    "               0.25*(100-rating_firm_pred[j][market_situation]) \n",
    "               for j in range(num_firm) \n",
    "               if j!= watched_firm]))\n",
    "        else 0,\n",
    "    }[str(explanatory_var)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Create the features for each starting situation from each market situation and save them as a file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "prices_firm_pred = np.round(np.random.uniform(6, 16, size=(num_firm, num_market_situations)), decimals = 2)\n",
    "                            \n",
    "qual_firm_pred = np.round(np.random.uniform(0.5, 5.5, size=(num_firm, num_market_situations)))\n",
    "                          \n",
    "rating_firm_pred = np.round(np.random.uniform(90, 100, size=(num_firm, num_market_situations)), decimals = 1)\n",
    "\n",
    "price_ranks_firm = np.array(\n",
    "    [[\n",
    "              1 +  \n",
    "              sum([\n",
    "                  1 \n",
    "                  for i in range(num_firm) \n",
    "                  if prices[j]> prices_firm_pred[i][w] and i!=watched_firm]) \n",
    "              +\n",
    "              sum([\n",
    "                  1 \n",
    "                  for i in range(num_firm) \n",
    "                  if prices[j]== prices_firm_pred[i][w] and i!=watched_firm])/2\n",
    "              for j in range(len(prices))]\n",
    "        for w in range(num_market_situations)])\n",
    "                            \n",
    "qual_rank_firm = np.array(\n",
    "    [\n",
    "         1 +  \n",
    "         sum([\n",
    "             1 \n",
    "             for i in range(num_firm) \n",
    "             if qual_firm_pred[watched_firm][w]> qual_firm_pred[i][w] and i!=watched_firm]) \n",
    "         +\n",
    "         sum([\n",
    "             1 \n",
    "             for i in range(num_firm) \n",
    "             if qual_firm_pred[watched_firm][w]== qual_firm_pred[i][w] and i!=watched_firm])/2\n",
    "         for w in range(num_market_situations)])\n",
    "                         \n",
    "rating_ranks = np.array(\n",
    "    [[\n",
    "              1 +  \n",
    "              sum([\n",
    "                  1 \n",
    "                  for i in range(num_firm) \n",
    "                  if rating_firm_pred[j][w]> rating_firm_pred[i][w] and i!=j]) \n",
    "              +\n",
    "              sum([\n",
    "                  1 \n",
    "                  for i in range(num_firm) \n",
    "                  if rating_firm_pred[j][w]== rating_firm_pred[i][w] and i!=j])/2\n",
    "              for j in range(num_firm)]\n",
    "        for w in range(num_market_situations)])\n",
    "\n",
    "num_explanatory_vars = 10\n",
    "\n",
    "value_explanatory_vars = [[[\n",
    "            explanatory_vars(explanatory_var, num_price, w) \n",
    "            for explanatory_var in range(num_explanatory_vars)] \n",
    "        for num_price in range(len(prices))]\n",
    "    for w in range(num_market_situations)]\n",
    "\n",
    "with open('demand_prediction_data_S3.csv', 'w') as file:\n",
    "    writer = csv.writer(file, delimiter='\\t')\n",
    "    for market_situation in range(num_market_situations):\n",
    "        for num_price in range(len(prices)):\n",
    "            line = list(value_explanatory_vars[market_situation][num_price])\n",
    "            line.remove(1)\n",
    "            line.insert(0, prices[num_price])\n",
    "            line.insert(0, market_situation+1)\n",
    "            writer.writerow(line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def price_if_smaller_else(price, price_threshold, min_price, prices_firm, c):\n",
    "    return(\n",
    "        price \n",
    "        if min([prices_firm[c] for firm in range(num_firm) if firm!=c]) < price_threshold \n",
    "        else round(\n",
    "            min([\n",
    "                    max(min_price, prices_firm[firm] - 0.5) for firm in range(num_firm) if firm != c])\n",
    "            ,2))\n",
    "\n",
    "s1 = {\n",
    "        '0' : lambda prices_firm, c: round(random.uniform(0,15),2),\n",
    "        '1' : lambda prices_firm, c: round(random.uniform(5,15),2),\n",
    "        '2' : lambda prices_firm, c: round(random.uniform(5,15),2),\n",
    "        '3' : lambda prices_firm, c: round(random.uniform(5,15),2),\n",
    "        '4' : lambda prices_firm, c: round(random.uniform(5,15),2)\n",
    "    }\n",
    "\n",
    "s2 = {\n",
    "        '0' : lambda prices_firm, c: price_if_smaller_else(10,5,4.9,prices_firm,c),\n",
    "        '1' : lambda prices_firm, c: price_if_smaller_else(10,5,4.9,prices_firm,c),\n",
    "        '2' : lambda prices_firm, c: price_if_smaller_else(10,5,4.9,prices_firm,c),\n",
    "        '3' : lambda prices_firm, c: price_if_smaller_else(10,5,4.9,prices_firm,c),\n",
    "        '4' : lambda prices_firm, c: price_if_smaller_else(10,5,4.9,prices_firm,c)\n",
    "    }\n",
    "\n",
    "s3 = {\n",
    "        '0' : lambda prices_firm, c: price_if_smaller_else(10,5,4.9,prices_firm,c),\n",
    "        '1' : lambda prices_firm, c: price_if_smaller_else(9,4,3.9,prices_firm,c),\n",
    "        '2' : lambda prices_firm, c: price_if_smaller_else(12,6,5.9,prices_firm,c),\n",
    "        '3' : lambda prices_firm, c: 11,\n",
    "        '4' : lambda prices_firm, c: 13\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def calc_prices(prices_firm_adjust, adjusting_firm, setup):\n",
    "    prices_firm_adjust = np.array(prices_firm_adjust)\n",
    "    #weird indexing because there are actually no price adjustments at time 0 nor on the price horizon\n",
    "    for i in range(1,len(prices_firm_adjust)-1):        \n",
    "        prices_firm_adjust[i:,adjusting_firm[i]] = setup[str(adjusting_firm[i])](prices_firm_adjust[i-1],adjusting_firm[i])\n",
    "    return prices_firm_adjust"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculate all the necessary information for when firms adjusts their prices and how often they adjust their prices.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_betw_market_events_firm = np.random.uniform(0.8, 1.2, size = (len(prices), num_market_situations, num_sims, num_firm, num_market_events))\n",
    "\n",
    "time_adjusts_firm = time_betw_market_events_firm\n",
    "\n",
    "time_adjusts_firm[:, :, :, :, 0] = np.random.uniform(0, 1, size = (len(prices), num_market_situations, num_sims, num_firm))\n",
    "\n",
    "# calculate the time when each company adjusts their prices\n",
    "for p in range(len(prices)):\n",
    "    for w in range(num_market_situations):\n",
    "        for sim_num in range(num_sims):\n",
    "            for c in range(num_firm):\n",
    "                for i in range(1,num_market_events):\n",
    "                    time_adjusts_firm[p,w,sim_num,c,i] = time_adjusts_firm[p,w,sim_num,c,i-1] + time_betw_market_events_firm[p,w,sim_num,c,i]  \n",
    "\n",
    "price_adjusts_before_horizon = np.array(\n",
    "    [[[\n",
    "                set([\n",
    "                    time_adjusts_firm[p,w,sim_num].flatten()[i] \n",
    "                    for i in range(len(time_adjusts_firm[p,w,sim_num].flatten())) \n",
    "                    if time_adjusts_firm[p,w,sim_num].flatten()[i] < time_horizon]) \n",
    "                for sim_num in range(num_sims)]\n",
    "            for w in range(num_market_situations)]\n",
    "        for p in range(len(prices))])\n",
    "\n",
    "price_adjusts_before_horizon = np.array(\n",
    "    [[[\n",
    "                [0] + sorted(price_adjusts_before_horizon[p,w,sim_num]) + [time_horizon] \n",
    "                for sim_num in range(num_sims)]\n",
    "            for w in range(num_market_situations)]\n",
    "        for p in range(len(prices))])\n",
    "\n",
    "num_price_adjusts_before_horizon = np.array(\n",
    "    [[[\n",
    "                len(price_adjusts_before_horizon[p,w,sim_num]) \n",
    "                for sim_num in range(num_sims)]\n",
    "            for w in range(num_market_situations)]\n",
    "        for p in range(len(prices))])\n",
    "\n",
    "adjusting_firm = np.array(\n",
    "    [[[[\n",
    "                    min(np.where(time_adjusts_firm[p,w,sim_num]==price_adjusts_before_horizon[p,w,sim_num][i] )[0]) \n",
    "                    if price_adjusts_before_horizon[p,w,sim_num][i]!= time_horizon and i!=0 \n",
    "                    else -1 \n",
    "                    for i in range(num_price_adjusts_before_horizon[p,w,sim_num])] \n",
    "                for sim_num in range(num_sims)]\n",
    "            for w in range(num_market_situations)]\n",
    "        for p in range(len(prices))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculate when customers will arrive and how they will score the quality and rating of all firms."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "time_betw_customer_events = mean_betw_customer_arrival * np.random.exponential(size = (len(prices), num_market_situations, num_sims, num_customer_events))\n",
    "\n",
    "time_customer_events = time_betw_customer_events\n",
    "\n",
    "#calculate the arrival of customers after the first one\n",
    "for p in range(len(prices)):\n",
    "    for w in range(num_market_situations):\n",
    "        for sim_num in range(num_sims):\n",
    "            for c in range(1, num_customer_events):\n",
    "                time_customer_events[p,w,sim_num,c] = time_customer_events[p,w,sim_num,c-1] + time_betw_customer_events[p,w,sim_num,c]\n",
    "\n",
    "rand_customer_score_qual = np.random.uniform(0, 1, size = (len(prices), num_market_situations ,num_sims, num_customer_events))\n",
    "\n",
    "rand_customer_score_rating = np.random.uniform(0, 0.5, size = (len(prices), num_market_situations ,num_sims, num_customer_events))\n",
    "\n",
    "#calculate the score from each customer for each firm based on quality and rating of the offers\n",
    "customer_score_qual_rating = np.array(\n",
    "    [[[[[\n",
    "                        (rand_customer_score_qual[p,w,s][c]*qual_firm_pred[k,w] +\n",
    "                         rand_customer_score_rating[p,w,s][c]*(100-rating_firm_pred[k,w]))\n",
    "                        for k in range(num_firm)] \n",
    "                    for c in range(num_customer_events)] \n",
    "                for s in range(num_sims)]\n",
    "            for w in range(num_market_situations)]\n",
    "        for p in range(len(prices))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculate the prices adjustments for each firm in the time horizon."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "prices_firm = np.array(\n",
    "    [[[\n",
    "                prices_firm_pred[k,w] \n",
    "                if k!=watched_firm \n",
    "                else prices[a] \n",
    "                for w in range(num_market_situations)] \n",
    "            for a in range(len(prices))]  \n",
    "        for k in range(num_firm)])\n",
    "\n",
    "prices_firm_adjust = np.array(\n",
    "    [[[[[\n",
    "                        prices_firm[k,a,w]  \n",
    "                        for k in range(num_firm)]\n",
    "                    for _ in range(num_price_adjusts_before_horizon[a,w,s])] \n",
    "                for s in range(num_sims)] \n",
    "            for w in range(num_market_situations)] \n",
    "        for a in range(len(prices))])\n",
    "\n",
    "prices_firm_adjust = np.array(\n",
    "    [[[[\n",
    "                    np.array(calc_prices(prices_firm_adjust[a,w,s], adjusting_firm[a,w,s], globals()[\"s{}\".format(setup+1)])) \n",
    "                    for s in range(num_sims)] \n",
    "                for w in range(num_market_situations)] \n",
    "            for a in range(len(prices))]\n",
    "        for setup in range(len(setups))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we don't want to know what happens after or on the time horizon, we will always substract 1 when using the value num_price_adjusts_before_horizon in the following code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# get all the customers that appear between market events, so we don't always have to iterate through each customer\n",
    "gen = np.array(\n",
    "    [[[[[\n",
    "                        x \n",
    "                        for x in range(num_customer_events) \n",
    "                        if price_adjusts_before_horizon[a,w,s][i]< time_customer_events[a,w,s][x]< price_adjusts_before_horizon[a,w,s][i+1]] \n",
    "                    for i in range(num_price_adjusts_before_horizon[a,w,s] - 1)] \n",
    "                for s in range(num_sims)] \n",
    "            for w in range(num_market_situations)] \n",
    "        for a in range(len(prices))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simulate the customer by completing the score using the current prices of each firm and then calculating a decision for each customer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "rand_customer_score = np.array(\n",
    "    [[[[[[[\n",
    "                                (prices_firm_adjust[setup,a,w,s][i,k] + customer_score_qual_rating[a,w,s,c,k]) \n",
    "                                for k in range(num_firm)]\n",
    "                            for c in gen[a,w,s][i]]\n",
    "                        for i in range(num_price_adjusts_before_horizon[a,w,s] - 1)] \n",
    "                    for s in range(num_sims)] \n",
    "                for w in range(num_market_situations)] \n",
    "            for a in range(len(prices))]\n",
    "        for setup in range(len(setups))])\n",
    "\n",
    "rand_customer_decision = np.array(\n",
    "    [[[[[[\n",
    "                            np.argmin(rand_customer_score[setup,a,w,s][i][c]) \n",
    "                            if min(rand_customer_score[setup,a,w,s][i][c])< random.uniform(5,15) \n",
    "                            else -1 \n",
    "                            for c in range(len(gen[a,w,s][i]))]\n",
    "                        for i in range(num_price_adjusts_before_horizon[a,w,s] - 1)] \n",
    "                    for s in range(num_sims)] \n",
    "                for w in range(num_market_situations)] \n",
    "            for a in range(len(prices))]\n",
    "        for setup in range(len(setups))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculate different metrics and save them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# count how often a firm sold anything in each simulation\n",
    "As = np.array(\n",
    "    [[[[[\n",
    "                        np.count_nonzero(np.hstack(rand_customer_decision[setup,a,w,s])== k) \n",
    "                        for k in range(num_firm)]\n",
    "                    for s in range(num_sims)] \n",
    "                for w in range(num_market_situations)] \n",
    "            for a in range(len(prices))]\n",
    "        for setup in range(len(setups))])\n",
    "\n",
    "# count how often a firm sold a certain something a certain number of times in all the simulations \n",
    "A = np.array(\n",
    "    [[[[[\n",
    "                        1/num_sims*np.count_nonzero(As[setup,a,w,:,k]==x) \n",
    "                        for k in range(num_firm)]\n",
    "                    for x in range(6)]\n",
    "                for w in range(num_market_situations)] \n",
    "            for a in range(len(prices))]\n",
    "        for setup in range(len(setups))])\n",
    "\n",
    "# probability that the watched firm sold something\n",
    "P_ori = [[[\n",
    "            1- A[setup,a,w,0,watched_firm]\n",
    "            for w in range(num_market_situations)] \n",
    "        for a in range(len(prices))]\n",
    "    for setup in range(len(setups))]\n",
    "\n",
    "# probability that the watched firm sold more than 2 articles\n",
    "P_ori2 = [[[\n",
    "            sum([\n",
    "                A[setup,a,w,x,watched_firm]\n",
    "                for x in range(2,6)])\n",
    "            for w in range(num_market_situations)] \n",
    "        for a in range(len(prices))]\n",
    "    for setup in range(len(setups))]\n",
    "\n",
    "# the estimated profit\n",
    "EW_ori = [[[\n",
    "            prices[a]*P_ori[setup][a][w] \n",
    "            for w in range(num_market_situations)]\n",
    "        for a in range(len(prices))]\n",
    "    for setup in range(len(setups))]\n",
    "\n",
    "for setup in range(len(setups)):\n",
    "    with open('PEW_comparison_{}.csv'.format(setups[setup]), 'w') as file:\n",
    "        writer = csv.writer(file, delimiter='\\t')\n",
    "        for w in range(num_market_situations):\n",
    "            for a in range(len(prices)):\n",
    "                line = [w+1,prices[a],P_ori[setup][a][w], P_ori2[setup][a][w], EW_ori[setup][a][w]]\n",
    "                writer.writerow(line)"
   ]
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}