{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Prediction error for different bus-stops\n", "\n", "In this module, the plot of error in prediction is obtained for the north bound as well as the south bound direction. " ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from pymongo import MongoClient\n", "import math\n", "import pprint\n", "#import geocoder\n", "import pprint\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import os" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def PredictionError_NorthBound(BusStopsCount, TripStartTime, Bound, ResultPathDir, ResultPathDir_Np, UseMongoDB):\n", " '''\n", " input: The bus-stop count, trip start time, direction, and directory path of result folder\n", " output: None\n", " function: It extracts the prediction records from the MongoDB database and computes the \n", " prediction error for different bus-stops of the route on the north bound direction.\n", " '''\n", " PredictionErrorAggAtIDListMean =[]\n", " PredictionErrorAggAtIDListSTD =[]\n", " PredictionErrorAggAtIDListMax =[]\n", "\n", " PredictionIndexList =[]\n", " \n", " if UseMongoDB==True:\n", " PredictionErrorLists = [record for record in \n", " con[RouteName]['PredictionErrorForSubStopsV2.'+TripStartTime+'.'+Bound].find()]\n", " \n", " else:\n", " PredictionErrorLists = np.load(f'{ResultPathDir_Np}/{RouteName}/PredictionErrorForSubStopsV2.{TripStartTime}.{Bound}.npy',\n", " allow_pickle=True)\n", " \n", " for BusStopIndex in range(BusStopsCount):\n", " PredictionErrorList = [rec for rec in PredictionErrorLists if rec['id']==BusStopIndex]\n", "\n", " if len(PredictionErrorList)!=0:\n", " if(PredictionErrorList[0]['PredictionAvailable']==True):\n", " #MeanPredictionErrorMean,STDPredictionErrorMean,MaxPredictionErrorMean=PredictionErrorAtIDNorth(BusStopIndex,TripStartTime,Bound)\n", "\n", " PredictionErrorAggAtIDListMean.append(PredictionErrorList[0]['PredictionErrorAggregateMean']/1000)\n", " PredictionErrorAggAtIDListSTD.append(PredictionErrorList[0]['PredictionErrorAggregateSTD']/1000)\n", " #PredictionErrorAggAtIDListMax.append(PredictionErrorList[0]['PredictionErrorAggregateMax']/1000)\n", " PredictionErrorAggAtIDListMax.append(PredictionErrorList[0]['PredictionErrorAggregateNinetyPercentileValue']/1000)\n", " PredictionIndexList.append(BusStopIndex)\n", "\n", "\n", " # In[18]:\n", "\n", "\n", " yticksList = [0,100,200,300,400,500,600,700]\n", " xticksList = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]\n", " xticksLabel = ['B1','B2','B3','B4','B5','B6','B7','M1','M2','M3','M4','M5','M6','M7','B8']\n", " xLimit=(-0.8,15)\n", "\n", " # In[20]:\n", "\n", " ax1 = plt.subplot(1,1,1)\n", " ax1.set_xlim(xLimit)\n", "\n", " ax1.bar(PredictionIndexList,PredictionErrorAggAtIDListMean,1/(2*2),yerr = [np.zeros(BusStopsCount-1),PredictionErrorAggAtIDListSTD],hatch='oooo',label='Mean error',edgecolor='k',facecolor='None',capsize=2)\n", " PredictionIndexList[:]=[x+1/4 for x in PredictionIndexList]\n", " ax1.bar(PredictionIndexList,PredictionErrorAggAtIDListMax,1/(2*2),hatch='xxxx',label='Ninety percentile error',edgecolor='k',facecolor='None')\n", " plt.legend(fontsize=11)\n", " plt.yticks(yticksList)\n", " plt.xticks(xticksList,xticksLabel)\n", " plt.xlabel('Bus stops',fontsize=12)\n", " plt.ylabel('Prediction error (seconds)',fontsize=12)\n", " #plt.title('Prediction error v/s bus stop')\n", "\n", "\n", " plt.tick_params(axis='both', which='major', labelsize=10)\n", " plt.tick_params(axis='both', which='minor', labelsize=10)\n", "\n", " plt.tight_layout()\n", "\n", " plt.savefig(f'{ResultPathDir}PredictionError_NorthBound.png',format='png',dpi=600)\n", " plt.show()\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def PredictionError_SouthBound(BusStopsCount, TripStartTime, Bound, ResultPathDir, ResultPathDir_Np, UseMongoDB):\n", " '''\n", " input: The bus-stop count, trip start time, direction, and directory path of result folder\n", " output: None\n", " function: It extracts the prediction records from the MongoDB database and computes the \n", " prediction error for different bus-stops of the route on the south bound direction.\n", " '''\n", " PredictionErrorAggAtIDListMean =[]\n", " PredictionErrorAggAtIDListSTD =[]\n", " PredictionErrorAggAtIDListMax =[]\n", "\n", " PredictionIndexList =[]\n", " \n", " if UseMongoDB==True:\n", " PredictionErrorLists = [record for record in \n", " con[RouteName]['PredictionErrorForSubStopsV2.'+TripStartTime+'.'+Bound].find()]\n", " \n", " else:\n", " PredictionErrorLists = np.load(f'{ResultPathDir_Np}/{RouteName}/PredictionErrorForSubStopsV2.{TripStartTime}.{Bound}.npy',\n", " allow_pickle=True) \n", "\n", " for BusStopIndex in range(BusStopsCount):\n", " PredictionErrorList = [rec for rec in PredictionErrorLists if rec['id']==BusStopIndex]\n", " \n", " \n", " if len(PredictionErrorList)!=0:\n", " if(PredictionErrorList[0]['PredictionAvailable']==True):\n", " #MeanPredictionErrorMean,STDPredictionErrorMean,MaxPredictionErrorMean=PredictionErrorAtIDNorth(BusStopIndex,TripStartTime,Bound)\n", "\n", " PredictionErrorAggAtIDListMean.append(PredictionErrorList[0]['PredictionErrorAggregateMean']/1000)\n", " PredictionErrorAggAtIDListSTD.append(PredictionErrorList[0]['PredictionErrorAggregateSTD']/1000)\n", " #PredictionErrorAggAtIDListMax.append(PredictionErrorList[0]['PredictionErrorAggregateMax']/1000)\n", " PredictionErrorAggAtIDListMax.append(PredictionErrorList[0]['PredictionErrorAggregateNinetyPercentileValue']/1000)\n", " PredictionIndexList.append(BusStopIndex)\n", "\n", " yticksList = [0,100,200,300,400,500,600,700]\n", " xticksList = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]\n", " xticksLabel = ['B1','B2','B3','B4','B5','B6','B7','M1','M2','M3','M4','M5','M6','M7','B8']\n", " xLimit=(-0.8,15)\n", " \n", " # In[23]:\n", "\n", " ax1=plt.subplot(1,1,1)\n", " ax1.set_xlim(xLimit)\n", "\n", " plt.bar(PredictionIndexList,PredictionErrorAggAtIDListMean,1/(2*2),yerr = [(0,0,0,0,0,0,0,0,0,0,0,0,0,0),PredictionErrorAggAtIDListSTD],hatch='oooo',label='Mean error',edgecolor='k',facecolor='None',capsize=2)\n", " PredictionIndexList[:]=[x+1/4 for x in PredictionIndexList]\n", " plt.bar(PredictionIndexList,PredictionErrorAggAtIDListMax,1/(2*2),hatch='xxxx',label='Ninety percentile error',edgecolor='k',facecolor='None')\n", " plt.legend(fontsize=11)\n", " plt.yticks(yticksList)\n", " plt.xticks(xticksList,xticksLabel)\n", " plt.xlabel('Bus stops',fontsize=12)\n", " plt.ylabel('Prediction error (seconds)',fontsize=12)\n", " #plt.title('Prediction error v/s bus stop')\n", "\n", " plt.tick_params(axis='both', which='major', labelsize=10)\n", " plt.tick_params(axis='both', which='minor', labelsize=10)\n", "\n", " plt.tight_layout()\n", "\n", " plt.savefig(f'{ResultPathDir}PredictionError_SouthBound.png',format='png',dpi=600)\n", " plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Execution of the code" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "from pathlib import Path\n", "\n", "'''For directory management'''\n", "path = Path(os.getcwd())\n", "\n", "OneLevelUpPath = path.parents[0]\n", "\n", "RouteName='Git_ISCON_PDPU'\n", "\n", "NpPathDir = os.path.join(str(OneLevelUpPath), 'data','NpData')\n", "\n", "#ResultPathDir = os.path.join(os.getcwd(), 'Result','PredictionError','')\n", "ResultPathDir = os.path.join(str(OneLevelUpPath), 'results','PredictionError','')\n", "\n", "ResultPathDir_Np = os.path.join(str(OneLevelUpPath), 'results','NpData','')" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "'''\n", "ProjectDataUsed = True\n", "UsedPreTrained = False\n", "UseMongoDB = True\n", "'''\n", "#'''\n", "ProjectDataUsed = True\n", "UsedPreTrained = True\n", "UseMongoDB = False\n", "#'''" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "con = MongoClient()" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Bound, BusStopsCount North 15\n" ] } ], "source": [ "if UseMongoDB==True:\n", " TripStartTimeAggregate= [Tr['TripStartTimeBound'] for Tr in \n", " con [RouteName]['TripStartTimeAggregate'].find()]\n", " \n", " Bound = TripStartTimeAggregate[0][0][1]\n", " BusStopRecords = [rec for rec in con[RouteName][f'BusStops.{Bound}Bound'].find()]\n", " \n", "else:\n", " TripStartTimeAggregate_Record = np.load(f'{NpPathDir}/{RouteName}/TripStartTimeAggregate.npy',\n", " allow_pickle=True)\n", " \n", " TripStartTimeAggregate = [rec['TripStartTimeBound'] for rec in TripStartTimeAggregate_Record]\n", " \n", " Bound = TripStartTimeAggregate[0][0][1]\n", " \n", " BusStopRecords = np.load(f'{NpPathDir}/{RouteName}/BusStops.{Bound}Bound.npy',\n", " allow_pickle=True)\n", " \n", "BusStopsCount = len(BusStopRecords) \n", "print('Bound, BusStopsCount', Bound, len (BusStopRecords))" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "TripStartTime = TripStartTimeAggregate[0][0][0]\n", "Bound = TripStartTimeAggregate[0][0][1]\n", "\n", "PredictionError_NorthBound(BusStopsCount, TripStartTime, Bound, ResultPathDir, ResultPathDir_Np, UseMongoDB)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "StartHour, Bound, BusStopsCount 18 South 15\n" ] } ], "source": [ "TripStartTime = TripStartTimeAggregate[0][1][0]\n", "Bound = TripStartTimeAggregate[0][1][1]\n", "\n", "if UseMongoDB==True:\n", " BusStopRecords = [rec for rec in con[RouteName][f'BusStops.{Bound}Bound'].find()]\n", " \n", "else:\n", " BusStopRecords = np.load(f'{NpPathDir}/{RouteName}/BusStops.{Bound}Bound.npy',\n", " allow_pickle=True)\n", " \n", "BusStopsCount = len(BusStopRecords) \n", "print('StartHour, Bound, BusStopsCount', TripStartTime, Bound, len (BusStopRecords))" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "PredictionError_SouthBound(BusStopsCount, TripStartTime, Bound, ResultPathDir, ResultPathDir_Np, UseMongoDB)" ] } ], "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.9" } }, "nbformat": 4, "nbformat_minor": 5 }