{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Prediction error for last bus-stop" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "'''\n", "Import libraries\n", "'''\n", "from pymongo import MongoClient\n", "import math\n", "import pprint\n", "#import geocoder\n", "import pprint\n", "import matplotlib.pyplot as plt\n", "\n", "from pydoc import help\n", "from scipy.stats.stats import pearsonr\n", "import os\n", "import numpy as np" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def PredictionErrorAtIDSouth (id_value,TripStartTime,Bound, NpPathDir, ResultPathDir_Np, UseMongoDB):\n", " '''\n", " input: the id of the bus-stop, trip start time and bound value\n", " output: the prediction for the provided bus-stop id for the trips with the trip start time \n", " and direction of the bound value\n", " function: it computes the prediction for the provided bus-stop id for the trips with the trip start time \n", " and direction of the bound value\n", " '''\n", " if UseMongoDB==True:\n", " PredictionErrorLists = [rec for rec in \n", " con[RouteName]['PredictionErrorForSubStopsV2.'+TripStartTime+'.'+Bound].find()]\n", "\n", " BusStopRecords = [rec for rec in \n", " con[RouteName]['BusStops.SouthBound'].find()]\n", " \n", " else:\n", " \n", " PredictionErrorLists = np.load(f'{ResultPathDir_Np}/{RouteName}/PredictionErrorForSubStopsV2.{TripStartTime}.{Bound}.npy',\n", " allow_pickle=True)\n", "\n", " BusStopRecords = np.load(f'{NpPathDir}/{RouteName}/BusStops.SouthBound.npy',allow_pickle=True)\n", "\n", " \n", " PredictionErrorList = [rec for rec in PredictionErrorLists if rec['id']==id_value]\n", " BusStopRecord = [rec for rec in BusStopRecords if rec['id']==id_value]\n", " \n", " if len(BusStopRecord) != 0:\n", " #StopDistFromOrigin=BusStopRecord[0]['normalizedDistanceFromOrigin']\n", " StopDistFromOrigin=BusStopRecord[0]['distanceFromOrigin']\n", "\n", " if len(PredictionErrorList)!=0:\n", " PredictionErrorList=PredictionErrorList[0]\n", " PredictionErrorMeanList = []\n", " PredictionErrorSTDList = []\n", " NormalizedDistForStopList = []\n", " PredictionByIndexList = []\n", " #pprint.pprint(PredictionErrorList)\n", "\n", " \n", " for PredictionByIndex in PredictionErrorList['PredictionByIndexList']:\n", "\n", " #BusStopRecord = [rec for rec in con[RouteName]['BusStops.SouthBound'].find({'id':PredictionByIndex+1}).limit(1)]\n", " BusStopRecord = [rec for rec in BusStopRecords if rec['id'] == PredictionByIndex+1]\n", " #For NorthBound\n", " #BusStopRecord = [rec for rec in con[RouteName]['BusStops.SouthBound'].find({'id':PredictionByIndex-1}).limit(1)]\n", "\n", " if len(BusStopRecord) != 0:\n", " #NormalizedDistForStopList.append(abs(BusStopRecord[0]['normalizedDistanceFromOrigin']-StopDistFromOrigin))\n", " NormalizedDistForStopList.append(abs(BusStopRecord[0]['distanceFromOrigin']-StopDistFromOrigin)/1000)\n", " #For NorthBound\n", " #PredictionByIndex.append(PredictionByIndex-1)\n", " PredictionByIndexList.append(PredictionByIndex+1)\n", "\n", " PredictionErrorMeanList.append(PredictionErrorList[str(PredictionByIndex)][0]/1000)\n", " PredictionErrorSTDList.append(PredictionErrorList[str(PredictionByIndex)][1]/1000)\n", "\n", " return(NormalizedDistForStopList,PredictionErrorMeanList,PredictionErrorSTDList,PredictionByIndexList)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def PredictionErrorAtIDNorth (id_value,TripStartTime,Bound, NpPathDir, ResultPathDir_Np, UseMongoDB):\n", " '''\n", " input: the id of the bus-stop, trip start time and bound value\n", " output: the prediction for the provided bus-stop id for the trips with the trip start time \n", " and direction of the bound value\n", " function: it computes the prediction for the provided bus-stop id for the trips with the trip start time \n", " and direction of the bound value\n", " '''\n", " if UseMongoDB==True:\n", " PredictionErrorLists = [rec for rec in \n", " con[RouteName]['PredictionErrorForSubStopsV2.'+TripStartTime+'.'+Bound].find()]\n", "\n", " BusStopRecords = [rec for rec in \n", " con[RouteName][f'BusStops.{Bound}Bound'].find()]\n", " \n", " else:\n", " \n", " PredictionErrorLists = np.load(f'{ResultPathDir_Np}/{RouteName}/PredictionErrorForSubStopsV2.{TripStartTime}.{Bound}.npy',\n", " allow_pickle=True)\n", "\n", " BusStopRecords = np.load(f'{NpPathDir}/{RouteName}/BusStops.{Bound}Bound.npy',allow_pickle=True)\n", " \n", " PredictionErrorList = [rec for rec in PredictionErrorLists if rec['id']==id_value]\n", " BusStopRecord = [rec for rec in BusStopRecords if rec['id']==id_value] \n", " \n", " if len(BusStopRecord) != 0:\n", " #StopDistFromOrigin=BusStopRecord[0]['normalizedDistanceFromOrigin']\n", " StopDistFromOrigin=BusStopRecord[0]['distanceFromOrigin']\n", "\n", " if len(PredictionErrorList)!=0:\n", " PredictionErrorList=PredictionErrorList[0]\n", " PredictionErrorMeanList = []\n", " PredictionErrorSTDList = []\n", " NormalizedDistForStopList = []\n", " PredictionByIndexList = []\n", " #pprint.pprint(PredictionErrorList)\n", "\n", " \n", " for PredictionByIndex in PredictionErrorList['PredictionByIndexList']:\n", "\n", " #BusStopRecord = [rec for rec in con[RouteName]['BusStops.SouthBound'].find({'id':PredictionByIndex+1}).limit(1)]\n", " #For NorthBound\n", " #BusStopRecord = [rec for rec in con[RouteName][f'BusStops.{Bound}Bound'].find({'id':PredictionByIndex-1}).limit(1)]\n", " BusStopRecord = [rec for rec in BusStopRecords if rec['id'] == PredictionByIndex-1]\n", "\n", " if len(BusStopRecord) != 0:\n", " #NormalizedDistForStopList.append(abs(BusStopRecord[0]['normalizedDistanceFromOrigin']-StopDistFromOrigin))\n", " NormalizedDistForStopList.append(abs(BusStopRecord[0]['distanceFromOrigin']-StopDistFromOrigin)/1000)\n", " #For NorthBound\n", " PredictionByIndexList.append(PredictionByIndex-1)\n", " #PredictionByIndexList.append(PredictionByIndex+1)\n", "\n", " PredictionErrorMeanList.append(PredictionErrorList[str(PredictionByIndex)][0]/1000)\n", " PredictionErrorSTDList.append(PredictionErrorList[str(PredictionByIndex)][1]/1000)\n", "\n", " return(NormalizedDistForStopList,PredictionErrorMeanList,PredictionErrorSTDList,PredictionByIndexList)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "def Extract_and_Plot_PredictionError_SouthBound(TripStartTimeAggregate, ResultPathDir, NpPathDir, ResultPathDir_Np, UseMongoDB):\n", " '''\n", " input: Trip start time\n", " output: None\n", " function: It extracts the prediction records from the MongoDB database and computes the prediction error\n", " for the farthest bus-stop of the route on the south bound direction.\n", " '''\n", " \n", " #TActualList =[0, 234, 506, 793, 1052, 1367, 1665, 2273, 2415, 2692, 3263, 3454, 3521, 3653, 3970]\n", " TActualList =[234, 506, 793, 1052, 1367, 1665, 2273, 2415, 2692, 3263, 3454, 3521, 3653, 3970]\n", "\n", " \n", " \n", " NormalizedDistForStopList,PredictionErrorMeanList,PredictionErrorSTDList,PredictionByIndexList = PredictionErrorAtIDSouth (0,TripStartTimeAggregate[0][1][0],TripStartTimeAggregate[0][1][1],\n", " NpPathDir, ResultPathDir_Np, UseMongoDB\n", " )\n", " # 18 South \n", "\n", " print(len(NormalizedDistForStopList),len(PredictionErrorMeanList))\n", "\n", " PearsonrCorrelationCoefficeintMean,PValueMean = pearsonr(NormalizedDistForStopList,PredictionErrorMeanList)\n", " PearsonrCorrelationCoefficeintSTD,PValueSTD = pearsonr(NormalizedDistForStopList,PredictionErrorSTDList)\n", "\n", " PearsonrCorrelationCoefficeintMeanTActual,PValueMeanTActual = pearsonr(TActualList,PredictionErrorMeanList)\n", " PearsonrCorrelationCoefficeintSTDTActual,PValueSTDTActual = pearsonr(TActualList,PredictionErrorSTDList)\n", "\n", " print(\"PearsonrCorrelationCoefficeintMean: \")\n", " print(PearsonrCorrelationCoefficeintMean)\n", "\n", " print(\"PearsonrCorrelationCoefficeintSTD: \")\n", " print(PearsonrCorrelationCoefficeintSTD)\n", "\n", " print(\"PearsonrCorrelationCoefficeintMeanTActual: \")\n", " print(PearsonrCorrelationCoefficeintMeanTActual)\n", "\n", " print(\"PearsonrCorrelationCoefficeintSTDTActual: \")\n", " print(PearsonrCorrelationCoefficeintSTDTActual)\n", "\n", " ax1 = plt.subplot(1,1,1)\n", " ax1.errorbar(NormalizedDistForStopList,PredictionErrorMeanList,PredictionErrorSTDList,marker='o',linestyle='--',label='SouthBound',markerfacecolor='None',color='k',capsize=2)\n", "\n", " XLimitDistance = ax1.get_xlim()\n", " \n", " global yLimit\n", " yLimit = ax1.get_ylim()\n", " global xLimit\n", " xLimit = ax1.get_xlim()\n", " plt.xlabel('Distance (km) from bus stop',fontsize=12)\n", " plt.ylabel('Prediction error (seconds)',fontsize=12)\n", " #plt.title('Prediction error v/s Distance from bus stop')\n", " plt.tick_params(axis='both', which='major', labelsize=10)\n", " plt.tick_params(axis='both', which='minor', labelsize=10)\n", " #PearsonrCorrelationCoefficeintMean\n", " #plt.text(2,570,'Correlation between distance and mean error: '+\"%.4f\" %round(PearsonrCorrelationCoefficeintMean,4)+'\\nCorrelation between distance and variation in error: '+\"%.4f\" %round(PearsonrCorrelationCoefficeintSTD,4),va='center', size=11 )\n", " \n", " ax2= ax1.twiny()\n", "\n", " ax2.set_xticks([NormalizedDistForStopList[i] for i in range(len(NormalizedDistForStopList)) if i not in [1,2,4,6]])\n", " ax2.set_xticklabels([TActualList[i] for i in range(len(TActualList)) if i not in [1,2,4,6]])\n", " ax2.set_xlim(xLimit)\n", " ax2.set_xlabel(r\"Travel time (seconds) from bus stop\",size=11)\n", "\n", "\n", " plt.tight_layout()\n", " plt.savefig(f'{ResultPathDir}EndStopPredictionError_SouthBound.png',format='png',dpi=600)\n", "\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "def Extract_and_Plot_PredictionError_NorthBound(TripStartTimeAggregate, ResultPathDir, NpPathDir, ResultPathDir_Np, UseMongoDB):\n", " '''\n", " input: Trip start time\n", " output: None\n", " function: It extracts the prediction records from the MongoDB database and computes the prediction error\n", " for the farthest bus-stop of the route on the north bound direction.\n", " '''\n", " TActualList = [2605, 2598, 2452, 2392, 2301, 2111, 1925, 1791, 1453,1194, 974, 728, 494, 292] #, 0]\n", " NormalizedDistForStopList,PredictionErrorMeanList,PredictionErrorSTDList,PredictionByIndexList = PredictionErrorAtIDNorth (14,TripStartTimeAggregate[0][0][0],TripStartTimeAggregate[0][0][1],\n", " NpPathDir, ResultPathDir_Np, UseMongoDB\n", " )\n", "\n", " print(len(NormalizedDistForStopList),len(PredictionErrorMeanList))\n", " print(len(TActualList),len(PredictionErrorMeanList))\n", "\n", " PearsonrCorrelationCoefficeintMean,PValueMean = pearsonr(NormalizedDistForStopList,PredictionErrorMeanList)\n", " PearsonrCorrelationCoefficeintSTD,PValueSTD = pearsonr(NormalizedDistForStopList,PredictionErrorSTDList)\n", "\n", " PearsonrCorrelationCoefficeintMeanTActual,PValueMeanTActual = pearsonr(TActualList,PredictionErrorMeanList)\n", " PearsonrCorrelationCoefficeintSTDTActual,PValueSTDTActual = pearsonr(TActualList,PredictionErrorSTDList)\n", "\n", " print(\"PearsonrCorrelationCoefficeintMean: \")\n", " print(PearsonrCorrelationCoefficeintMean)\n", "\n", " print(\"PearsonrCorrelationCoefficeintSTD: \")\n", " print(PearsonrCorrelationCoefficeintSTD)\n", "\n", " print(\"PearsonrCorrelationCoefficeintMeanTActual: \")\n", " print(PearsonrCorrelationCoefficeintMeanTActual)\n", "\n", " print(\"PearsonrCorrelationCoefficeintSTDTActual: \")\n", " print(PearsonrCorrelationCoefficeintSTDTActual)\n", "\n", " plt.cla()\n", " ax1 = plt.subplot(1,1,1)\n", " ax1.set_ylim(yLimit)\n", " ax1.set_xlim(xLimit)\n", " ax1.errorbar(NormalizedDistForStopList,PredictionErrorMeanList,PredictionErrorSTDList,marker='o',linestyle='--',label='NorthBound: '+str(PearsonrCorrelationCoefficeintMean)+', '+str(PearsonrCorrelationCoefficeintSTD),markerfacecolor='None',color='k',capsize=2)\n", "\n", " print(ax1.get_xlim())\n", " plt.xlabel('Distance (km) from bus stop',fontsize=12)\n", " plt.ylabel('Prediction error (seconds)',fontsize=12)\n", "\n", " plt.tick_params(axis='both', which='major', labelsize=10)\n", " plt.tick_params(axis='both', which='minor', labelsize=10)\n", "\n", " ax2= ax1.twiny()\n", "\n", " ax2.set_xlim(xLimit)\n", " ax2.set_xticks([NormalizedDistForStopList[i] for i in range(len(NormalizedDistForStopList)) if i not in [1,2,3,5]])\n", " ax2.set_xticklabels([TActualList[i] for i in range(len(TActualList)) if i not in [1,2,3,5]])\n", " ax2.set_xlabel(r\"Travel time (seconds) from bus stop\",size=11)\n", "\n", " plt.tight_layout()\n", " plt.savefig(f'{ResultPathDir}EndStopPredictionError_NorthBound.png',format='png',dpi=600)\n", " plt.show() " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Execution of code" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "from pathlib import Path\n", "'''For directory management'''\n", "path = Path(os.getcwd())\n", "\n", "OneLevelUpPath = path.parents[0]\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "'''Limits for plots'''\n", "xLimit = 0\n", "yLimit = 0" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "con = MongoClient()\n", "\n", "RouteName='Git_ISCON_PDPU'\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','')\n", "\n", "NpPathDir = os.path.join(str(OneLevelUpPath), 'data','NpData')" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'\\nProjectDataUsed = True\\nUsedPreTrained = True\\nUseMongoDB = False\\n'" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "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": 10, "metadata": {}, "outputs": [], "source": [ "if UseMongoDB==True:\n", " TripStartTimeAggregate= [Tr['TripStartTimeBound'] for Tr in \n", " con [RouteName]['TripStartTimeAggregate'].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", " " ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "14 14\n", "PearsonrCorrelationCoefficeintMean: \n", "0.918975223361703\n", "PearsonrCorrelationCoefficeintSTD: \n", "0.39390106016603077\n", "PearsonrCorrelationCoefficeintMeanTActual: \n", "0.9772182984737138\n", "PearsonrCorrelationCoefficeintSTDTActual: \n", "0.5501624254277958\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "14 14\n", "14 14\n", "PearsonrCorrelationCoefficeintMean: \n", "0.9289620609194672\n", "PearsonrCorrelationCoefficeintSTD: \n", "0.7119881075563027\n", "PearsonrCorrelationCoefficeintMeanTActual: \n", "0.9303267279052778\n", "PearsonrCorrelationCoefficeintSTDTActual: \n", "0.7155176551269204\n", "(-0.2530742780170834, 33.24133377279121)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:35: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "Extract_and_Plot_PredictionError_SouthBound(TripStartTimeAggregate, ResultPathDir, NpPathDir, ResultPathDir_Np, UseMongoDB)\n", "Extract_and_Plot_PredictionError_NorthBound(TripStartTimeAggregate, ResultPathDir, NpPathDir, ResultPathDir_Np, UseMongoDB)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## MongoDB Save/Load" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "def LoadInMongoFromNp(RouteName, NpPathDir):\n", " \n", " '''\n", " input: The route name and numpy directory path\n", " output: The MongoDB database collections from the Numpy files\n", " function: It creates the MongoDB database from the Numpy files.\n", " ''' \n", " \n", " CollectionNames = os.listdir(f'{NpPathDir}/{RouteName}')\n", " #print(CollectionNames)\n", " \n", " CollectionNames_1 = [rec for rec in CollectionNames if '\\'.' not in rec] # To address the error\n", " \n", " #print('Saving data in mongoDB')\n", " for Collection in CollectionNames_1:\n", " RecordsList = np.load(f'{NpPathDir}/{RouteName}/{Collection}', allow_pickle=True)\n", " #print(Collection)\n", " #pprint.pprint(RecordsList[0:3])\n", " \n", " CollectionName = Collection[0:-4]\n", " \n", " print(RouteName, CollectionName)\n", " con[RouteName][CollectionName].insert_many(RecordsList.tolist())\n", " \n", " \n", " \n", "def SaveInNp(RouteName, NpPathDir):\n", " \n", " '''\n", " input: The route name and numpy directory path\n", " output: Numpy files of the MongoDB database\n", " function: It stores the Numpy files for the MongoDB database in the specified directory path\n", " '''\n", " \n", " \n", " CollectionNames = [Collection for Collection in \n", " con[RouteName].list_collection_names() if Collection!='system.indexes']\n", "\n", " CollectionNames_1 = [Collection for Collection in \n", " con[RouteName].list_collection_names() if 'Prediction' not in Collection]\n", " \n", " for CollectionName in CollectionNames_1:\n", " print('CollectionName', CollectionName)\n", " RecordsList = [rec for rec in con[RouteName][CollectionName].find().sort([('_id',1)])]\n", "\n", " for RecordDict in RecordsList:\n", " del[RecordDict['_id']]\n", "\n", " if os.path.exists(os.path.join(NpPathDir, RouteName)) == False:\n", " os.mkdir(os.path.join(NpPathDir, RouteName))\n", "\n", " \n", " #np.save(f'{Path}/{Database}/{CollectionName}.npy', RecordsList)\n", " np.save(os.path.join(NpPathDir, RouteName,f'{CollectionName}.npy'), RecordsList)\n", " \n", " print('Unsaved collection')\n", " print([Collection for Collection in \n", " con[RouteName].list_collection_names() if 'Prediction' in Collection])\n", " " ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CollectionName 14_02_2018__18_30_22.BusStopsRecord\n", "CollectionName 02_02_2018__07_38_50.Filtered\n", "CollectionName H.18.South.21_02_2018__18_28_29\n", "CollectionName 20_03_2018__07_28_45.Filtered\n", "CollectionName 03_04_2018__07_38_31.RawRecords\n", "CollectionName TripStartTimeAggregate\n", "CollectionName H.07.North.08_01_2018__07_41_43\n", "CollectionName 19_02_2018__07_46_19.RawRecords\n", "CollectionName 14_02_2018__07_41_04.Filtered\n", "CollectionName H.18.South.20_02_2018__18_31_07\n", "CollectionName 01_02_2018__07_39_12.RawRecords\n", "CollectionName 30_01_2018__07_42_30.BusStopsRecord\n", "CollectionName 15_02_2018__16_08_22.RawRecords\n", "CollectionName H.18.South.22_12_2017__07_38_21\n", "CollectionName 20_02_2018__18_31_07.Filtered\n", "CollectionName 21_02_2018__07_42_42.BusStopsRecord\n", "CollectionName 21_02_2018__07_42_42.RawRecords\n", "CollectionName H.07.North.28_03_2018__18_30_02\n", "CollectionName 13_03_2018__07_29_52.RawRecords\n", "CollectionName H.07.North.21_02_2018__18_28_29\n", "CollectionName 14_03_2018__07_35_46.Filtered\n", "CollectionName 18_01_2018__07_38_10.RawRecords\n", "CollectionName 29_01_2018__07_39_47.RawRecords\n", "CollectionName 26_12_2017__07_32_35.Filtered\n", "CollectionName 22_02_2018__07_42_45.RawRecords\n", "CollectionName 20_03_2018__07_28_45.RawRecords\n", "CollectionName 21_02_2018__18_28_29.RawRecords\n", "CollectionName 03_04_2018__07_38_31.Filtered\n", "CollectionName BusStops.SouthBound\n", "CollectionName H.07.North.19_01_2018__07_38_47\n", "CollectionName H.18.South.02_02_2018__07_38_50\n", "CollectionName 14_02_2018__18_30_22.RawRecords\n", "CollectionName 21_02_2018__07_42_42.Filtered\n", "CollectionName H.07.North.20_02_2018__18_31_07\n", "CollectionName 13_03_2018__07_29_52.Filtered\n", "CollectionName 21_12_2017__07_52_59.Filtered\n", "CollectionName H.07.North.15_02_2018__18_33_19\n", "CollectionName H.07.North.20_12_2017__07_38_14\n", "CollectionName 19_01_2018__07_38_47.BusStopsRecord\n", "CollectionName 22_01_2018__07_41_04.BusStopsRecord\n", "CollectionName 03_04_2018__18_32_45.Filtered\n", "CollectionName 20_02_2018__07_41_48.Filtered\n", "CollectionName 15_02_2018__07_45_52.Filtered\n", "CollectionName 30_01_2018__07_42_30.Filtered\n", "CollectionName 29_01_2018__07_39_47.BusStopsRecord\n", "CollectionName 08_01_2018__18_37_49.BusStopsRecord\n", "CollectionName 08_01_2018__07_41_43.Filtered\n", "CollectionName 15_02_2018__18_33_19.BusStopsRecord\n", "CollectionName 22_01_2018__07_41_04.RawRecords\n", "CollectionName H.18.South.22_02_2018__07_42_45\n", "CollectionName H.18.South.08_01_2018__07_41_43\n", "CollectionName H.18.South.29_12_2017__07_37_27\n", "CollectionName 28_03_2018__18_30_02.RawRecords\n", "CollectionName 28_03_2018__18_30_02.BusStopsRecord\n", "CollectionName H.07.North.14_02_2018__07_41_04\n", "CollectionName 22_01_2018__07_41_04.Filtered\n", "CollectionName 27_12_2017__07_55_48.RawRecords\n", "CollectionName 20_12_2017__18_31_19.LocationRecordsWithDistanceFromOrigin\n", "CollectionName 22_12_2017__07_38_21.BusStopsRecord\n", "CollectionName 27_12_2017__07_55_48.Filtered\n", "CollectionName 29_12_2017__07_37_27.BusStopsRecord\n", "CollectionName 15_02_2018__18_33_19.Filtered\n", "CollectionName 18_01_2018__07_38_10.LocationRecordsWithDistanceFromOrigin\n", "CollectionName H.07.North.18_01_2018__07_38_10\n", "CollectionName H.07.North.20_12_2017__18_31_19\n", "CollectionName H.18.South.29_01_2018__07_39_47\n", "CollectionName H.18.South.20_12_2017__07_38_14\n", "CollectionName 15_02_2018__18_33_19.RawRecords\n", "CollectionName 22_12_2017__07_38_21.Filtered\n", "CollectionName 15_02_2018__07_45_52.BusStopsRecord\n", "CollectionName 01_01_2018__07_38_27.BusStopsRecord\n", "CollectionName 21_02_2018__18_28_29.BusStopsRecord\n", "CollectionName 21_03_2018__18_32_40.Filtered\n", "CollectionName 20_12_2017__07_38_14.BusStopsRecord\n", "CollectionName 15_02_2018__16_08_22.Filtered\n", "CollectionName H.18.South.19_01_2018__07_38_47\n", "CollectionName 04_04_2018__18_34_54.BusStopsRecord\n", "CollectionName 09_01_2018__07_40_01.RawRecords\n", "CollectionName 21_03_2018__07_32_39.Filtered\n", "CollectionName H.07.North.30_01_2018__07_42_30\n", "CollectionName 20_12_2017__18_31_19.Filtered\n", "CollectionName 20_02_2018__18_31_07.BusStopsRecord\n", "CollectionName 19_02_2018__07_46_19.Filtered\n", "CollectionName H.18.South.28_03_2018__18_30_02\n", "CollectionName 08_01_2018__18_37_49.Filtered\n", "CollectionName 09_01_2018__07_40_01.Filtered\n", "CollectionName 01_01_2018__07_38_27.Filtered\n", "CollectionName 02_02_2018__07_38_50.RawRecords\n", "CollectionName H.07.North.16_02_2018__07_45_41\n", "CollectionName 19_12_2017__18_41_16.BusStopsRecord\n", "CollectionName 18_01_2018__07_38_10.Filtered\n", "CollectionName H.18.South.04_04_2018__18_34_54\n", "CollectionName 22_02_2018__07_42_45.BusStopsRecord\n", "CollectionName H.18.South.18_01_2018__07_38_10\n", "CollectionName 14_02_2018__07_41_04.RawRecords\n", "CollectionName 12_02_2018__07_40_14.BusStopsRecord\n", "CollectionName 14_02_2018__07_41_04.BusStopsRecord\n", "CollectionName 05_04_2018__07_38_07.RawRecords\n", "CollectionName H.07.North.29_01_2018__07_39_47\n", "CollectionName 14_02_2018__18_30_22.Filtered\n", "CollectionName 30_01_2018__07_42_30.RawRecords\n", "CollectionName 26_12_2017__07_32_35.BusStopsRecord\n", "CollectionName 05_04_2018__07_38_07.BusStopsRecord\n", "CollectionName H.18.South.20_12_2017__18_31_19\n", "CollectionName 19_01_2018__07_38_47.RawRecords\n", "CollectionName 19_12_2017__18_41_16.Filtered\n", "CollectionName 14_03_2018__07_35_46.BusStopsRecord\n", "CollectionName 22_03_2018__07_38_43.Filtered\n", "CollectionName H.18.South.09_01_2018__07_40_01\n", "CollectionName 14_03_2018__07_35_46.RawRecords\n", "CollectionName 18_01_2018__07_38_10.BusStopsRecord\n", "CollectionName 08_01_2018__18_37_49.RawRecords\n", "CollectionName H.18.South.16_02_2018__07_45_41\n", "CollectionName H.18.South.15_02_2018__18_33_19\n", "CollectionName 16_02_2018__07_45_41.BusStopsRecord\n", "CollectionName H.07.North.22_12_2017__18_38_34\n", "CollectionName 20_12_2017__18_31_19.BusStopsRecord\n", "CollectionName 01_01_2018__07_38_27.RawRecords\n", "CollectionName 02_02_2018__07_38_50.BusStopsRecord\n", "CollectionName 19_01_2018__07_38_47.Filtered\n", "CollectionName 28_03_2018__18_30_02.Filtered\n", "CollectionName 12_02_2018__07_40_14.RawRecords\n", "CollectionName 21_12_2017__07_52_59.RawRecords\n", "CollectionName 13_03_2018__07_29_52.BusStopsRecord\n", "CollectionName H.18.South.22_12_2017__18_38_34\n", "CollectionName 04_04_2018__18_34_54.Filtered\n", "CollectionName H.07.North.14_02_2018__18_30_22\n", "CollectionName 08_01_2018__07_41_43.BusStopsRecord\n", "CollectionName 03_04_2018__18_32_45.RawRecords\n", "CollectionName 22_12_2017__07_38_21.RawRecords\n", "CollectionName 01_02_2018__07_39_12.Filtered\n", "CollectionName 19_12_2017__18_41_16.RawRecords\n", "CollectionName 20_12_2017__18_31_19.RawRecords\n", "CollectionName H.18.South.08_01_2018__18_37_49\n", "CollectionName 22_02_2018__07_42_45.Filtered\n", "CollectionName 16_02_2018__07_45_41.Filtered\n", "CollectionName H.07.North.08_01_2018__18_37_49\n", "CollectionName 22_03_2018__07_38_43.RawRecords\n", "CollectionName H.07.North.22_12_2017__07_38_21\n", "CollectionName TripInfo\n", "CollectionName 22_12_2017__18_38_34.BusStopsRecord\n", "CollectionName 12_02_2018__07_40_14.Filtered\n", "CollectionName 29_12_2017__07_37_27.Filtered\n", "CollectionName H.07.North.09_01_2018__07_40_01\n", "CollectionName H.07.North.29_12_2017__07_37_27\n", "CollectionName 26_12_2017__07_32_35.RawRecords\n", "CollectionName H.18.South.14_02_2018__18_30_22\n", "CollectionName 29_01_2018__07_39_47.Filtered\n", "CollectionName 08_01_2018__07_41_43.RawRecords\n", "CollectionName 20_02_2018__18_31_07.RawRecords\n", "CollectionName 22_12_2017__18_38_34.RawRecords\n", "CollectionName 21_03_2018__18_32_40.RawRecords\n", "CollectionName 16_02_2018__07_45_41.RawRecords\n", "CollectionName H.18.South.14_02_2018__07_41_04\n", "CollectionName 21_03_2018__07_32_39.RawRecords\n", "CollectionName 29_12_2017__07_37_27.RawRecords\n", "CollectionName BusStops.NorthBound\n", "CollectionName 21_03_2018__07_32_39.BusStopsRecord\n", "CollectionName 15_02_2018__07_45_52.RawRecords\n", "CollectionName 22_12_2017__18_38_34.Filtered\n", "CollectionName H.07.North.02_02_2018__07_38_50\n", "CollectionName 20_02_2018__07_41_48.RawRecords\n", "CollectionName 20_03_2018__07_28_45.BusStopsRecord\n", "CollectionName 03_04_2018__07_38_31.BusStopsRecord\n", "CollectionName 21_02_2018__18_28_29.Filtered\n", "CollectionName H.07.North.22_02_2018__07_42_45\n", "CollectionName H.07.North.12_02_2018__07_40_14\n", "CollectionName 09_01_2018__07_40_01.BusStopsRecord\n", "CollectionName 20_12_2017__07_38_14.RawRecords\n", "CollectionName H.18.South.30_01_2018__07_42_30\n", "CollectionName 04_04_2018__18_34_54.RawRecords\n", "CollectionName H.07.North.04_04_2018__18_34_54\n", "CollectionName 05_04_2018__07_38_07.Filtered\n", "CollectionName H.18.South.12_02_2018__07_40_14\n", "CollectionName 03_04_2018__18_32_45.BusStopsRecord\n", "CollectionName 20_12_2017__07_38_14.Filtered\n", "Unsaved collection\n", "['21_02_2018__18_28_29.PredictionResult_Dist_th_50', '14_02_2018__07_41_04.PredictionResult_Dist_th_50', '22_12_2017__07_38_21.PredictionResult_Dist_th_50', '16_02_2018__07_45_41.PredictionResult_Dist_th_50', '30_01_2018__07_42_30.PredictionResult_Dist_th_50', '22_02_2018__07_42_45.PredictionResult_Dist_th_50', '28_03_2018__18_30_02.PredictionResult_Dist_th_50', '09_01_2018__07_40_01.PredictionResult_Dist_th_50', '15_02_2018__18_33_19.PredictionResult_Dist_th_50', '20_02_2018__18_31_07.PredictionResult_Dist_th_50', '20_12_2017__07_38_14.PredictionResult_Dist_th_50', '29_01_2018__07_39_47.PredictionResult_Dist_th_50', '19_01_2018__07_38_47.PredictionResult_Dist_th_50', '20_12_2017__18_31_19.PredictionResult_Dist_th_50', '18_01_2018__07_38_10.PredictionResult_Dist_th_50', '02_02_2018__07_38_50.PredictionResult_Dist_th_50', '14_02_2018__18_30_22.PredictionResult_Dist_th_50', '08_01_2018__07_41_43.PredictionResult_Dist_th_50', 'PredictionErrorForSubStopsV2.07.North', '08_01_2018__18_37_49.PredictionResult_Dist_th_50', '12_02_2018__07_40_14.PredictionResult_Dist_th_50', '22_12_2017__18_38_34.PredictionResult_Dist_th_50', 'PredictionErrorForSubStopsV2.18.South', '04_04_2018__18_34_54.PredictionResult_Dist_th_50', '29_12_2017__07_37_27.PredictionResult_Dist_th_50']\n" ] } ], "source": [ "if UsedPreTrained == False:\n", " SaveInNp(RouteName, NpPathDir)\n", " \n", "elif UseMongoDB==True:\n", " \n", " RouteNamesList = con.list_database_names()\n", " if RouteName not in RouteNamesList:\n", " '''Load the data for RouteName, if RouteName is not in RouteNamesList'''\n", " print('Loading MongoData from Np files')\n", " LoadInMongoFromNp(RouteName, NpPathDir)" ] } ], "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 }