synthetic_dataset_quota_3_new_params.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import random, copy, os\n",
    "random.seed(42)\n",
    "np.random.seed(42)\n",
    "from matplotlib import pyplot as plt\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from multiprocessing import Pool\n",
    "import multiprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run helper.ipynb\n",
    "%run algorithm_functions.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rcParams['font.size'] = 14\n",
    "plt.rcParams['pdf.fonttype'] = 42\n",
    "plt.rcParams['ps.fonttype'] = 42\n",
    "plt.rcParams['axes.labelsize'] = 22\n",
    "plt.rcParams['axes.labelweight'] = 'bold'\n",
    "plt.rcParams['axes.titlesize'] = 19\n",
    "plt.rcParams['axes.linewidth'] = 3\n",
    "plt.rcParams['xtick.labelsize'] = 14\n",
    "plt.rcParams['ytick.labelsize'] = 14\n",
    "plt.rcParams['legend.fontsize'] = 15\n",
    "plt.rcParams['figure.titlesize'] = 22\n",
    "plt.rcParams['lines.linewidth'] = 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "size_v, size_u, T, driver_quota = 50, 100, 700, 3 #These are fixed now\n",
    "average_arrival_rate = T/size_v\n",
    "average_arrival_rate\n",
    "filename_append = 'quota_{}'.format(driver_quota)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "drivers, requests = [], []\n",
    "for i in range(size_u):\n",
    "    drivers.append(Driver(d_id=i, driver_race='NA', driver_gender='NA', pickup_lat_bin='NA', \n",
    "                          pickup_long_bin='NA', quota=driver_quota))\n",
    "    \n",
    "arrival_rates = np.random.multinomial(T, [1/size_v]*size_v) # sample from multinomial to ensure that arrival rates sum upto T\n",
    "\n",
    "for i in range(size_v):\n",
    "    requests.append(Request(pickup_lat_bin=i, pickup_long_bin=i, dropoff_lat_bin=i, \n",
    "                            dropoff_long_bin=i, requests_gender=i, requests_race=i, \n",
    "                            arrival_rate=int(arrival_rates[i]), # r_v is randomly chosen from a multinomial distribution\n",
    "                            distance=np.random.random())) # w_f is a random value between 0 and 1\n",
    "set_unique_ids(drivers)\n",
    "set_unique_ids(requests)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Drivers (|U|): 100, Requests (T): 700, Request Types (|V|): 50\n"
     ]
    }
   ],
   "source": [
    "print (\"Drivers (|U|): {}, Requests (T): {}, Request Types (|V|): {}\".format(len(drivers), \n",
    "                                                                       calculate_T(requests), len(requests)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "probability_matrix = np.full((size_u, size_v), -1, dtype=float) # drivers x requests\n",
    "profit_matrix = np.zeros((size_u, size_v), dtype=float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(size_u):\n",
    "    for j in range(size_v):\n",
    "        # An edge exists with probability of 0.1 and not with a probability of 0.9\n",
    "        edge_exists = np.random.choice([True, False], size=1, p=[0.1, 0.9])\n",
    "        if edge_exists[0]:\n",
    "            probability_matrix[i, j] = np.random.randint(500, 1000, size=1)[0]/1000 # randomly assign probability between 0.5 and 1\n",
    "            profit_matrix[i, j] = requests[j].distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(probability_matrix.shape[1]):\n",
    "    assert np.count_nonzero(probability_matrix[:,i] != -1) > 0\n",
    "for i in range(probability_matrix.shape[0]):\n",
    "    assert np.count_nonzero(probability_matrix[i,:] != -1) > 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Drivers' in-degree, average: 5.35, min: 2, max: 10\n",
      "Riders' in-degree, average: 10.7, min: 5, max: 18\n"
     ]
    }
   ],
   "source": [
    "r_vs = []\n",
    "for r in requests:\n",
    "    r_vs.append(r.arrival_rate)\n",
    "min(r_vs), max(r_vs)\n",
    "\n",
    "in_degree_v = []\n",
    "for i in range(len(requests)):\n",
    "    in_degree_v.append(np.count_nonzero(probability_matrix[:,i] != -1))\n",
    "\n",
    "in_degree_u = []\n",
    "for i in range(len(drivers)):\n",
    "    in_degree_u.append(np.count_nonzero(probability_matrix[i,:] != -1))\n",
    "\n",
    "print (\"Drivers' in-degree, average: {}, min: {}, max: {}\\nRiders' in-degree, average: {}, min: {}, max: {}\"\\\n",
    "       .format(np.mean(in_degree_u), min(in_degree_u), max(in_degree_u), \n",
    "               np.mean(in_degree_v), min(in_degree_v), max(in_degree_v)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cvxopt.base import matrix as m\n",
    "from cvxopt import solvers\n",
    "from cvxopt.modeling import op, dot, variable, max, min"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_f = variable(np.count_nonzero(probability_matrix != -1))\n",
    "profit, c = get_profit_objective(x_f, probability_matrix, profit_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_fair = variable(np.count_nonzero(probability_matrix != -1))\n",
    "fairness = get_fairness_objective(x_fair, probability_matrix, requests)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_inequalities_local(x_f, probability_matrix, requests, return_coefficients=False):\n",
    "    offset = 0\n",
    "    A, b = [], [] # model all inequalities as A * x <= b\n",
    "    # models the inequalities 3 and 4 in the writeup\n",
    "    for i in range(probability_matrix.shape[0]): # iterate over all drivers\n",
    "        a1, a2 = [0] * len(x_f), [0] * len(x_f) # coefficients of inequalities\n",
    "        edges_count = np.count_nonzero(probability_matrix[i] != -1)\n",
    "        edges_probabilities = probability_matrix[i][np.where(probability_matrix[i] != -1)]\n",
    "        assert len(edges_probabilities) == edges_count # sanity check\n",
    "        a1[offset:offset + edges_count] = edges_probabilities\n",
    "        a2[offset:offset + edges_count] = [1] * edges_count\n",
    "        A.append(a1)\n",
    "        A.append(a2)\n",
    "        b.append(1.0)\n",
    "        b.append(drivers[i].quota)\n",
    "        offset += edges_count\n",
    "    # Models the inequality -1 * x_f <= 0 for all edges\n",
    "    for i in range(len(x_f)):\n",
    "        a1 = [0] * len(x_f)\n",
    "        a1[i] = -1\n",
    "        A.append(a1)\n",
    "        b.append(0.0)\n",
    "    # Models inequality 5 in the writeup\n",
    "    for j in range(probability_matrix.shape[1]):# iterate over all request types\n",
    "        # j -> request; i-> driver\n",
    "        a1 = [0] * len(x_f)\n",
    "        for i in np.where(probability_matrix[:,j] != -1)[0]:\n",
    "            a1[coordinate_to_index(i, j, probability_matrix)] = 1\n",
    "        A.append(a1)\n",
    "        b.append(requests[j].arrival_rate)\n",
    "    print (len(A), len(b), len(A[0]), len(x_f))\n",
    "    \n",
    "    A, b = m(A).T, m(np.array(b))\n",
    "\n",
    "    if not return_coefficients:\n",
    "        inequality = (A * x_f <= b)\n",
    "        return inequality\n",
    "    else:\n",
    "        return A, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "785 785 535 535\n"
     ]
    }
   ],
   "source": [
    "inequality = get_inequalities_local(x_f, probability_matrix, requests)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "lp_profit = op(profit, inequality)\n",
    "lp_profit.solve(solver='glpk')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.99203187250996, -2.4454251643725913e-16)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(x_f.value), min(x_f.value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "785 785 535 535\n"
     ]
    }
   ],
   "source": [
    "inequality_fairness = get_inequalities_local(x_fair, probability_matrix, requests)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "lp_fairness = op(fairness, inequality_fairness)\n",
    "lp_fairness.solve(solver='glpk')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "When optimizing for fairness, fairness: 0.1428571428571428, profit: 48.1445199515579\n",
      "When optimizing for profit, fairness: -1.057355261547768e-17, profit: 83.47685356188364\n"
     ]
    }
   ],
   "source": [
    "optimal_profit = -1 * lp_profit.objective.value()[0]\n",
    "optimal_fairness = -1 * lp_fairness.objective.value()[0]\n",
    "print (\"When optimizing for fairness, fairness: {}, profit: {}\".format(optimal_fairness, \n",
    "                                                                      -1 * dot(c, x_fair).value()[0]))\n",
    "print (\"When optimizing for profit, fairness: {}, profit: {}\".format(\n",
    "    -1 * get_fairness_objective(x_f, probability_matrix, requests).value()[0], optimal_profit))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "lp_solution_sanity_check(x_f, x_fair, probability_matrix, requests)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "alphas, betas = np.arange(0.,1.01,0.1), np.arange(0.,1.01,0.1)\n",
    "num_loops = 5000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_requests = []\n",
    "for r in requests:\n",
    "    all_requests += [r] * int(r.arrival_rate)\n",
    "random.shuffle(all_requests)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matching_results = get_matching_results(all_requests, drivers, probability_matrix, \n",
    "                                            x_f, x_fair, alphas, num_loops)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "edges_count_results = get_edges_count_results(all_requests, matching_results, requests)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5647760336248403 0.5220000000000002\n",
      "0.5641172495589387 0.46820000000000017\n",
      "0.5669617285625664 0.4866666666666668\n",
      "0.5688358640167623 0.4840000000000002\n",
      "0.5715768910415062 0.4817333333333336\n",
      "0.5717734974541382 0.4976666666666669\n",
      "0.5724615594458788 0.4896666666666669\n",
      "0.5730610375299616 0.47820000000000024\n",
      "0.5734850876226486 0.48033333333333356\n",
      "0.5760367680306439 0.48793333333333355\n",
      "0.574225228268836 0.48033333333333356\n"
     ]
    }
   ],
   "source": [
    "profit_crs, profit_errors, fairness_crs, fairness_errors = get_profit_fairness_crs(\n",
    "    matching_results, edges_count_results, num_loops, requests, alphas, optimal_profit, optimal_fairness)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 216x216 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_lines([fairness_crs, [x/np.e for x in 1-alphas], profit_crs, [x/np.e for x in alphas]], \n",
    "           [fairness_errors, [0 for x in alphas], profit_errors, [0 for x in alphas]],\n",
    "            [\"{:.1f}\".format(x) for x in alphas], alphas, \n",
    "           r'$\\beta = 1 - \\alpha; \\Delta = {}$; Synthetic Data'.format(driver_quota), \n",
    "           r'$\\alpha$', 'Competitive Ratios', ['-', '--', '-', '--'], ['red', 'red', 'blue', 'blue'], \n",
    "            ['NAdap (fairness)', 'Lower Bound (fairness)', 'NAdap (profit)', 'Lower Bound (profit)'], \n",
    "            'plots', 'profit_fairness_crs_vs_alpha_{}_new_params'.format(filename_append), fmt='png', separate_legend=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uniform and Greedy algorithms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "uniform_params, greedy_params = [], []\n",
    "for i in range(num_loops):\n",
    "    drivers_copy = [copy.deepcopy(d) for d in drivers]\n",
    "    uniform_params.append([all_requests, drivers_copy, probability_matrix])\n",
    "for i in range(num_loops):\n",
    "    drivers_copy = [copy.deepcopy(d) for d in drivers]\n",
    "    greedy_params.append([all_requests, drivers_copy, probability_matrix])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with Pool(multiprocessing.cpu_count()) as p:\n",
    "    uniform_results = p.starmap(run_uniform, uniform_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with Pool(multiprocessing.cpu_count()) as p:\n",
    "    greedy_results = p.starmap(run_greedy, greedy_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greedy_profit = 0\n",
    "for res in greedy_results:\n",
    "    greedy_profit += res[1]\n",
    "greedy_profit /= num_loops\n",
    "greedy_profit_cr = greedy_profit/optimal_profit\n",
    "greedy_profit_cr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greedy_fairness_measure_params = []\n",
    "for i in range(num_loops):\n",
    "    greedy_fairness_measure_params.append([all_requests, greedy_results[i][0], requests])\n",
    "\n",
    "with Pool(multiprocessing.cpu_count()) as p:\n",
    "    greedy_edges_count_results = p.starmap(measure_fairness_edges_count, greedy_fairness_measure_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greedy_fairness_cr = calculate_fairness_from_array(greedy_edges_count_results, \n",
    "                                                   num_loops, requests)/optimal_fairness\n",
    "greedy_fairness_cr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "uniform_profit = 0\n",
    "for res in uniform_results:\n",
    "    uniform_profit += res[1]\n",
    "uniform_profit /= num_loops\n",
    "uniform_profit_cr = uniform_profit/optimal_profit\n",
    "uniform_profit_cr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "uniform_fairness_measure_params = []\n",
    "for i in range(num_loops):\n",
    "    uniform_fairness_measure_params.append([all_requests, uniform_results[i][0], requests])\n",
    "\n",
    "with Pool(multiprocessing.cpu_count()) as p:\n",
    "    uniform_edges_count_results = p.starmap(measure_fairness_edges_count, uniform_fairness_measure_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "uniform_fairness_cr = calculate_fairness_from_array(uniform_edges_count_results, \n",
    "                                                    num_loops, requests)/optimal_fairness\n",
    "uniform_fairness_cr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 216x216 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "all_x_vals = [fairness_crs , [uniform_fairness_cr], [greedy_fairness_cr]]\n",
    "all_y_vals = [profit_crs, [uniform_profit_cr], [greedy_profit_cr]]\n",
    "labels = [r'$NAdap (\\alpha, \\beta)$', 'Uniform', 'Greedy']\n",
    "annotations = ['({:.1f}, {:.1f})'.format(alphas[i], 1-alphas[i]) if i == np.argmin(fairness_crs) or \\\n",
    "               i == np.argmax(fairness_crs) or i == np.argmin(profit_crs) or \\\n",
    "               i == np.argmax(profit_crs) else '' for i in range(len(alphas))] + ['', '']\n",
    "annotation_positions = [(fairness_crs[i]/2 + 4*np.ptp(fairness_crs) if alphas[i] == 0.1 else fairness_crs[i]/2, \n",
    "                         profit_crs[i] - np.ptp(profit_crs) if alphas[i] == 0.1 else\\\n",
    "                         profit_crs[i] - np.ptp(profit_crs)/2) for i in range(len(alphas))]\n",
    "colors = ['blue', 'orange', 'red']\n",
    "shapes = ['o', 'X', 'D']\n",
    "plot_scatter(all_x_vals, all_y_vals, colors, shapes, annotations, annotation_positions,\n",
    "             r'$\\Delta = {}$; Synthetic Data'.format(driver_quota), \n",
    "             'Fairness CR', 'Profit CR', 'plots', 'fairness_vs_profit_cr_scatter_{}_new_params'.format(filename_append),\n",
    "            labels=labels, fmt='png', separate_legend=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For all other alpha, beta where alpha + beta < 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "remaining_algorithm_params = []\n",
    "coordinate_to_offset = {}\n",
    "offset = 0\n",
    "for alpha_i in range(len(alphas)):\n",
    "    for beta_j in range(len(betas)):\n",
    "        if alphas[alpha_i] + betas[beta_j] <= 1:\n",
    "            coordinate_to_offset[(alpha_i, beta_j)] = offset\n",
    "            offset += 1\n",
    "            for i in range(num_loops):\n",
    "                remaining_algorithm_params.append([all_requests, [copy.deepcopy(d) for d in drivers],\n",
    "                                                   probability_matrix, x_f, x_fair, \n",
    "                                                   alphas[alpha_i], betas[beta_j]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with Pool(multiprocessing.cpu_count()) as p:\n",
    "    remaining_matching_results = p.starmap(run_algorithm, remaining_algorithm_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "remaining_fairness_measure_params = []\n",
    "for alpha_i in range(len(alphas)):\n",
    "    for beta_j in range(len(betas)):\n",
    "        if alphas[alpha_i] + betas[beta_j] <= 1:\n",
    "            for i in range(num_loops):\n",
    "                remaining_fairness_measure_params.append([all_requests, \n",
    "                            remaining_matching_results[coordinate_to_offset[(alpha_i, beta_j)] + i][2], requests])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with Pool(multiprocessing.cpu_count()) as p:\n",
    "    remaining_edges_count_results = p.starmap(measure_fairness_edges_count, remaining_fairness_measure_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expected_fairness_map, expected_profit_map = np.full((len(alphas), len(betas)), np.nan), \\\n",
    "                                                np.full((len(alphas), len(betas)), np.nan)\n",
    "for alpha_i in range(len(alphas)):\n",
    "    for beta_j in range(len(betas)):\n",
    "        if alphas[alpha_i] + betas[beta_j] <= 1:\n",
    "            offset_index = coordinate_to_offset[(alpha_i, beta_j)]\n",
    "            assert offset_index*num_loops <= len(remaining_edges_count_results) - num_loops\n",
    "            \n",
    "            remaining_fairness_counts = remaining_edges_count_results[offset_index * num_loops:(offset_index+1)*num_loops]\n",
    "            print ((np.sum(remaining_fairness_counts, axis=0)/num_loops))\n",
    "            expected_fairness_map[len(alphas) - alpha_i - 1, beta_j] = \\\n",
    "                calculate_fairness_from_array(remaining_fairness_counts, num_loops, requests)/optimal_fairness\n",
    "            expected_profit = 0\n",
    "            for i in range(num_loops):\n",
    "                expected_profit += remaining_matching_results[offset_index + i][0]\n",
    "            expected_profit /= num_loops\n",
    "            expected_profit_map[len(alphas) - alpha_i - 1, beta_j] = expected_profit/optimal_profit\n",
    "#         elif alphas[alpha_i] + betas[beta_j] == 1:\n",
    "#             expected_fairness_map[len(alphas) - alpha_i - 1, beta_j] = fairness_crs[alpha_i]\n",
    "#             expected_profit_map[len(alphas) - alpha_i - 1, beta_j] = profit_crs[alpha_i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expected_fairness_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_heatmaps([expected_profit_map], x_labels=[str(\"{:.1f}\".format(x)) for x in betas], \n",
    "              y_labels=[str(\"{:.1f}\".format(x)) for x in alphas[::-1]], x_title='Beta', y_title='Alpha', \n",
    "              subplot_titles=['Expected Profit (Synthetic)'], subfolder='plots', \n",
    "              filename='heatmap_expected_profit_synthetic_{}_new_params'.format(filename_append))\n",
    "plot_heatmaps([expected_fairness_map], x_labels=[str(\"{:.1f}\".format(x)) for x in betas], \n",
    "              y_labels=[str(\"{:.1f}\".format(x)) for x in alphas[::-1]], x_title='Beta', y_title='Alpha', \n",
    "              subplot_titles=['Expected Fairness (Synthetic)'], subfolder='plots', \n",
    "              filename='heatmap_expected_fairness_synthetic_{}_new_params'.format(filename_append))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}