├── .gitignore ├── img ├── distance_comparison1.png ├── distance_comparison2.png ├── distance_comparison3.png ├── distance_comparison4.png └── distance_comparison5.png ├── README.md └── distance_comparison.ipynb /.gitignore: -------------------------------------------------------------------------------- 1 | *.csv 2 | *.shp 3 | -------------------------------------------------------------------------------- /img/distance_comparison1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caocscar/ms2/master/img/distance_comparison1.png -------------------------------------------------------------------------------- /img/distance_comparison2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caocscar/ms2/master/img/distance_comparison2.png -------------------------------------------------------------------------------- /img/distance_comparison3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caocscar/ms2/master/img/distance_comparison3.png -------------------------------------------------------------------------------- /img/distance_comparison4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caocscar/ms2/master/img/distance_comparison4.png -------------------------------------------------------------------------------- /img/distance_comparison5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caocscar/ms2/master/img/distance_comparison5.png -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Notes 2 | 3 | [distance_comparison.ipynb](distance_comparison.ipynb) is a python script that does a comparison between two distance metrics, Haversine and the Google Distance Matrix API, and tries to elucidate the differences between the two when applicable. 4 | -------------------------------------------------------------------------------- /distance_comparison.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Distance Comparison between Google Distance Matrix API and Haversine (as the crow flies)" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## Preprocessing Steps" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "Importing python modules and getting API key" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 1, 27 | "metadata": {}, 28 | "outputs": [], 29 | "source": [ 30 | "from sklearn.neighbors import NearestNeighbors\n", 31 | "import geopandas as gp\n", 32 | "import numpy as np\n", 33 | "import os\n", 34 | "import googlemaps\n", 35 | "import matplotlib.pyplot as plt\n", 36 | "\n", 37 | "gp.pd.options.display.max_rows = 10\n", 38 | "\n", 39 | "apikey = os.getenv('GOOGLE_MAP_API_KEY')\n", 40 | "gmaps = googlemaps.Client(apikey)" 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "metadata": {}, 46 | "source": [ 47 | "Read in shapefile" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": 2, 53 | "metadata": { 54 | "scrolled": true 55 | }, 56 | "outputs": [], 57 | "source": [ 58 | "wdir = r'X:\\MS2'\n", 59 | "ma = gp.read_file(os.path.join(wdir,'Mhd2017Export.shp'))" 60 | ] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "metadata": {}, 65 | "source": [ 66 | "Iterate through each geometry and choose an arbitrary point to represent the road segment. Here I chose the first point in the linestring." 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 3, 72 | "metadata": {}, 73 | "outputs": [], 74 | "source": [ 75 | "geom = []\n", 76 | "for row in ma.itertuples():\n", 77 | " if row.geometry.type == 'LineString':\n", 78 | " geom.append(row.geometry.coords[0])\n", 79 | " elif row.geometry.type == 'MultiLineString':\n", 80 | " for linestring in row.geometry:\n", 81 | " geom.append(linestring.coords[0])\n", 82 | " break\n", 83 | "ma['pt'] = geom" 84 | ] 85 | }, 86 | { 87 | "cell_type": "markdown", 88 | "metadata": {}, 89 | "source": [ 90 | "Choosing a subsample to compare. Here I choose based on county. I choose Berkshire county because it borders both the northern and southern boundary of Massachusetts." 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": 4, 96 | "metadata": {}, 97 | "outputs": [], 98 | "source": [ 99 | "county = ma[(ma['COUNTY'] == '3')]\n", 100 | "county.reset_index(drop=True, inplace=True)" 101 | ] 102 | }, 103 | { 104 | "cell_type": "markdown", 105 | "metadata": {}, 106 | "source": [ 107 | "Use the nearest neighbor algorithm to find the closest `k` neighbors for each road segment. It returns the neighbor id (row number) along with the corresponding haversine distance. We multiply it by Earth's radius to get it in the appropriate unit." 108 | ] 109 | }, 110 | { 111 | "cell_type": "code", 112 | "execution_count": 5, 113 | "metadata": {}, 114 | "outputs": [], 115 | "source": [ 116 | "XY = county['pt'].tolist()\n", 117 | "XY = [[pt[1],pt[0]] for pt in XY] # latitutde,longitude format \n", 118 | "xy = np.radians(XY)\n", 119 | "k = 20\n", 120 | "nbrs = NearestNeighbors(n_neighbors=k+1, algorithm='auto', leaf_size=30, metric='haversine')\n", 121 | "nbrs.fit(xy)\n", 122 | "distances, nid = nbrs.kneighbors(xy)\n", 123 | "R = 6371 # avg Earth radius in km\n", 124 | "distances *= R" 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": 6, 130 | "metadata": {}, 131 | "outputs": [ 132 | { 133 | "data": { 134 | "text/plain": [ 135 | "array([[ 0, 23, 24, ..., 2776, 927, 2608],\n", 136 | " [ 1, 926, 927, ..., 3141, 2820, 13],\n", 137 | " [ 2, 928, 927, ..., 2706, 2516, 2821],\n", 138 | " ..., \n", 139 | " [3220, 2936, 2927, ..., 143, 176, 177],\n", 140 | " [3221, 2928, 3222, ..., 2987, 2980, 3214],\n", 141 | " [3222, 2948, 2928, ..., 2987, 2980, 3214]], dtype=int64)" 142 | ] 143 | }, 144 | "execution_count": 6, 145 | "metadata": {}, 146 | "output_type": "execute_result" 147 | } 148 | ], 149 | "source": [ 150 | "nid" 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": 7, 156 | "metadata": {}, 157 | "outputs": [ 158 | { 159 | "data": { 160 | "text/plain": [ 161 | "array([[ 0. , 0.11624839, 0.14769209, ..., 0.79839008,\n", 162 | " 0.80492603, 0.8175712 ],\n", 163 | " [ 0. , 0.12335718, 0.16070397, ..., 0.59028603,\n", 164 | " 0.59220125, 0.59401006],\n", 165 | " [ 0. , 0.1044344 , 0.15796374, ..., 0.45832769,\n", 166 | " 0.4823994 , 0.4892717 ],\n", 167 | " ..., \n", 168 | " [ 0. , 0.08251677, 0.14064991, ..., 0.9275115 ,\n", 169 | " 0.93867396, 0.95895518],\n", 170 | " [ 0. , 0.02395408, 0.05064373, ..., 1.07913732,\n", 171 | " 1.39614578, 1.43711027],\n", 172 | " [ 0. , 0.00658318, 0.02681579, ..., 1.12675085,\n", 173 | " 1.34878615, 1.38973484]])" 174 | ] 175 | }, 176 | "execution_count": 7, 177 | "metadata": {}, 178 | "output_type": "execute_result" 179 | } 180 | ], 181 | "source": [ 182 | "distances" 183 | ] 184 | }, 185 | { 186 | "cell_type": "markdown", 187 | "metadata": {}, 188 | "source": [ 189 | "For each road segment, choose a random neighbor to construct an origin-destination (O-D) pair. Construct a dataframe from the O-D pairs and remove any duplicates. Set random seed for reproducibility." 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": 8, 195 | "metadata": {}, 196 | "outputs": [], 197 | "source": [ 198 | "count = 0\n", 199 | "np.random.seed(2018)\n", 200 | "OD = []\n", 201 | "for origin in range(county.shape[0]):\n", 202 | " choice = np.random.randint(1,k,1)[0]\n", 203 | " dest = nid[origin][choice]\n", 204 | " dist = distances[origin][choice] * 1000\n", 205 | " if origin < dest:\n", 206 | " OD.append((origin,dest,choice,dist))\n", 207 | " else:\n", 208 | " OD.append((dest,origin,choice,dist))\n", 209 | " if dist < 0.001:\n", 210 | " count += 1\n", 211 | " \n", 212 | "df = gp.pd.DataFrame(OD, columns=['origin','dest','n_neighbor','crow']).drop_duplicates(['origin','dest'])" 213 | ] 214 | }, 215 | { 216 | "cell_type": "markdown", 217 | "metadata": {}, 218 | "source": [ 219 | "Sample the dataframe so we are within the daily Google API rate limit of 2500 O-D pairs." 220 | ] 221 | }, 222 | { 223 | "cell_type": "code", 224 | "execution_count": 9, 225 | "metadata": {}, 226 | "outputs": [], 227 | "source": [ 228 | "sample = df.sample(n=2400).sort_values(['origin','dest']).reset_index(drop=True)" 229 | ] 230 | }, 231 | { 232 | "cell_type": "markdown", 233 | "metadata": {}, 234 | "source": [ 235 | "Iterate through the dataframe and make a request to the Google Distance Matrix API. Construct a dataframe from this data and save the data to a file for future reference. " 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": 10, 241 | "metadata": {}, 242 | "outputs": [], 243 | "source": [ 244 | "api_flag = False\n", 245 | "if api_flag:\n", 246 | " coords = []\n", 247 | " for row in sample.itertuples():\n", 248 | " origin = '{:.6f},{:.6f}'.format(XY[row.origin][0],XY[row.origin][1])\n", 249 | " dest = '{:.6f},{:.6f}'.format(XY[row.dest][0],XY[row.dest][1])\n", 250 | " R = gmaps.distance_matrix(origins=origin, destinations=dest)\n", 251 | " distance = R['rows'][0]['elements'][0]['distance']['value']\n", 252 | " coords.append((XY[row.origin],XY[row.dest],distance))\n", 253 | " driving = gp.pd.DataFrame(coords, columns=['origin','dest','goog'])\n", 254 | " driving.to_csv('google_distance_matrix.csv', index=False, sep='|')\n", 255 | "else:\n", 256 | " driving = gp.pd.read_csv('google_distance_matrix.csv', sep='|')" 257 | ] 258 | }, 259 | { 260 | "cell_type": "markdown", 261 | "metadata": {}, 262 | "source": [ 263 | "Combine the two datasets (haversine and google) and calculate the difference." 264 | ] 265 | }, 266 | { 267 | "cell_type": "code", 268 | "execution_count": 11, 269 | "metadata": {}, 270 | "outputs": [], 271 | "source": [ 272 | "sample['goog'] = driving['goog']\n", 273 | "sample['delta'] = sample['goog'] - sample['crow']\n", 274 | "sample.sort_values('delta', inplace=True)" 275 | ] 276 | }, 277 | { 278 | "cell_type": "markdown", 279 | "metadata": {}, 280 | "source": [ 281 | "## Descriptive Statistics" 282 | ] 283 | }, 284 | { 285 | "cell_type": "markdown", 286 | "metadata": {}, 287 | "source": [ 288 | "Here is the dataframe that contains the relevant sample data from Berkshire county.\n", 289 | "\n", 290 | "* origin, dest - contains row id of segment\n", 291 | "* n_neighbor - nth closest neighbor to origin segment\n", 292 | "* crow, goog - distance btw O-D pair for haversine and google API respectively\n", 293 | "* delta - difference between the two metrics\n", 294 | "\n", 295 | "Note: Distances are in meters for columns `crow`, `goog`, and `delta`." 296 | ] 297 | }, 298 | { 299 | "cell_type": "code", 300 | "execution_count": 12, 301 | "metadata": {}, 302 | "outputs": [ 303 | { 304 | "data": { 305 | "text/html": [ 306 | "
\n", 307 | "\n", 320 | "\n", 321 | " \n", 322 | " \n", 323 | " \n", 324 | " \n", 325 | " \n", 326 | " \n", 327 | " \n", 328 | " \n", 329 | " \n", 330 | " \n", 331 | " \n", 332 | " \n", 333 | " \n", 334 | " \n", 335 | " \n", 336 | " \n", 337 | " \n", 338 | " \n", 339 | " \n", 340 | " \n", 341 | " \n", 342 | " \n", 343 | " \n", 344 | " \n", 345 | " \n", 346 | " \n", 347 | " \n", 348 | " \n", 349 | " \n", 350 | " \n", 351 | " \n", 352 | " \n", 353 | " \n", 354 | " \n", 355 | " \n", 356 | " \n", 357 | " \n", 358 | " \n", 359 | " \n", 360 | " \n", 361 | " \n", 362 | " \n", 363 | " \n", 364 | " \n", 365 | " \n", 366 | " \n", 367 | " \n", 368 | " \n", 369 | " \n", 370 | " \n", 371 | " \n", 372 | " \n", 373 | " \n", 374 | " \n", 375 | " \n", 376 | " \n", 377 | " \n", 378 | " \n", 379 | " \n", 380 | " \n", 381 | " \n", 382 | " \n", 383 | " \n", 384 | " \n", 385 | " \n", 386 | " \n", 387 | " \n", 388 | " \n", 389 | " \n", 390 | " \n", 391 | " \n", 392 | " \n", 393 | " \n", 394 | " \n", 395 | " \n", 396 | " \n", 397 | " \n", 398 | " \n", 399 | " \n", 400 | " \n", 401 | " \n", 402 | " \n", 403 | " \n", 404 | " \n", 405 | " \n", 406 | " \n", 407 | " \n", 408 | " \n", 409 | " \n", 410 | " \n", 411 | " \n", 412 | " \n", 413 | " \n", 414 | " \n", 415 | " \n", 416 | " \n", 417 | " \n", 418 | " \n", 419 | " \n", 420 | " \n", 421 | " \n", 422 | " \n", 423 | " \n", 424 | " \n", 425 | " \n", 426 | " \n", 427 | " \n", 428 | " \n", 429 | " \n", 430 | " \n", 431 | " \n", 432 | " \n", 433 | "
origindestn_neighborcrowgoogdelta
14211621910672.525865668-4.525865
6395501553375.32517472-3.325174
1975228522868207.228675204-3.228675
71560119214209.212445206-3.212445
2712222493355.083549352-3.083549
.....................
227527573031172672.6847623101628343.315238
19692267249771741.4077973091229170.592203
208724992916151441.3168833247631034.683117
5144542491172861.2710573653633674.728943
123212032417132097.5806423879136693.419358
\n", 434 | "

2400 rows × 6 columns

\n", 435 | "
" 436 | ], 437 | "text/plain": [ 438 | " origin dest n_neighbor crow goog delta\n", 439 | "142 116 219 10 672.525865 668 -4.525865\n", 440 | "639 550 1553 3 75.325174 72 -3.325174\n", 441 | "1975 2285 2286 8 207.228675 204 -3.228675\n", 442 | "715 601 1921 4 209.212445 206 -3.212445\n", 443 | "271 222 249 3 355.083549 352 -3.083549\n", 444 | "... ... ... ... ... ... ...\n", 445 | "2275 2757 3031 17 2672.684762 31016 28343.315238\n", 446 | "1969 2267 2497 7 1741.407797 30912 29170.592203\n", 447 | "2087 2499 2916 15 1441.316883 32476 31034.683117\n", 448 | "514 454 2491 17 2861.271057 36536 33674.728943\n", 449 | "1232 1203 2417 13 2097.580642 38791 36693.419358\n", 450 | "\n", 451 | "[2400 rows x 6 columns]" 452 | ] 453 | }, 454 | "execution_count": 12, 455 | "metadata": {}, 456 | "output_type": "execute_result" 457 | } 458 | ], 459 | "source": [ 460 | "sample" 461 | ] 462 | }, 463 | { 464 | "cell_type": "code", 465 | "execution_count": 13, 466 | "metadata": {}, 467 | "outputs": [ 468 | { 469 | "data": { 470 | "text/plain": [ 471 | "count 2400.000000\n", 472 | "mean 706.100946\n", 473 | "std 2836.276653\n", 474 | "min -4.525865\n", 475 | "50% 71.719718\n", 476 | "75% 331.092314\n", 477 | "90% 1195.414122\n", 478 | "95% 2546.184654\n", 479 | "99% 17596.912272\n", 480 | "max 36693.419358\n", 481 | "Name: delta, dtype: float64" 482 | ] 483 | }, 484 | "execution_count": 13, 485 | "metadata": {}, 486 | "output_type": "execute_result" 487 | } 488 | ], 489 | "source": [ 490 | "sample['delta'].describe([0.75,0.9,0.95,0.99])" 491 | ] 492 | }, 493 | { 494 | "cell_type": "markdown", 495 | "metadata": {}, 496 | "source": [ 497 | "## Comparison between Google and Haversine" 498 | ] 499 | }, 500 | { 501 | "cell_type": "markdown", 502 | "metadata": {}, 503 | "source": [ 504 | "## Figure 1: Google vs Haversine" 505 | ] 506 | }, 507 | { 508 | "cell_type": "code", 509 | "execution_count": 14, 510 | "metadata": {}, 511 | "outputs": [ 512 | { 513 | "name": "stderr", 514 | "output_type": "stream", 515 | "text": [ 516 | "C:\\Users\\caoa\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\matplotlib\\cbook\\deprecation.py:106: 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", 517 | " warnings.warn(message, mplDeprecation, stacklevel=1)\n" 518 | ] 519 | }, 520 | { 521 | "data": { 522 | "text/plain": [ 523 | "Text(6,1,'y=x')" 524 | ] 525 | }, 526 | "execution_count": 14, 527 | "metadata": {}, 528 | "output_type": "execute_result" 529 | }, 530 | { 531 | "data": { 532 | "image/png": "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\n", 533 | "text/plain": [ 534 | "" 535 | ] 536 | }, 537 | "metadata": {}, 538 | "output_type": "display_data" 539 | } 540 | ], 541 | "source": [ 542 | "%matplotlib inline\n", 543 | "fig = plt.figure(figsize=(16,5))\n", 544 | "plt.scatter(sample['crow']/1000, sample['goog']/1000,alpha=0.1)\n", 545 | "plt.xlabel('Haversine Distance (km)')\n", 546 | "plt.ylabel('Google Driving Distance (km)')\n", 547 | "xy = [0,6.500]\n", 548 | "plt.plot(xy,xy,'k')\n", 549 | "ax = fig.add_subplot(111)\n", 550 | "plt.xlim([0, 7]); plt.ylim([0, 40])\n", 551 | "params = {'width':2,\n", 552 | " 'shrink': 0.05,\n", 553 | " 'facecolor':'black'}\n", 554 | "ax.annotate('y=x', xy=(5.8,5.8), xytext=(6,1), arrowprops=params)" 555 | ] 556 | }, 557 | { 558 | "cell_type": "markdown", 559 | "metadata": {}, 560 | "source": [ 561 | "Let's look at a couple of examples for the large deltas." 562 | ] 563 | }, 564 | { 565 | "cell_type": "code", 566 | "execution_count": 15, 567 | "metadata": {}, 568 | "outputs": [ 569 | { 570 | "data": { 571 | "text/html": [ 572 | "
\n", 573 | "\n", 586 | "\n", 587 | " \n", 588 | " \n", 589 | " \n", 590 | " \n", 591 | " \n", 592 | " \n", 593 | " \n", 594 | " \n", 595 | " \n", 596 | " \n", 597 | " \n", 598 | " \n", 599 | " \n", 600 | " \n", 601 | " \n", 602 | " \n", 603 | " \n", 604 | " \n", 605 | " \n", 606 | " \n", 607 | " \n", 608 | " \n", 609 | " \n", 610 | " \n", 611 | " \n", 612 | " \n", 613 | " \n", 614 | " \n", 615 | " \n", 616 | " \n", 617 | " \n", 618 | " \n", 619 | " \n", 620 | " \n", 621 | " \n", 622 | " \n", 623 | " \n", 624 | " \n", 625 | " \n", 626 | " \n", 627 | " \n", 628 | " \n", 629 | " \n", 630 | " \n", 631 | " \n", 632 | " \n", 633 | " \n", 634 | " \n", 635 | " \n", 636 | " \n", 637 | " \n", 638 | " \n", 639 | " \n", 640 | " \n", 641 | " \n", 642 | " \n", 643 | " \n", 644 | " \n", 645 | "
origindestn_neighborcrowgoogdelta
227527573031172672.6847623101628343.315238
19692267249771741.4077973091229170.592203
208724992916151441.3168833247631034.683117
5144542491172861.2710573653633674.728943
123212032417132097.5806423879136693.419358
\n", 646 | "
" 647 | ], 648 | "text/plain": [ 649 | " origin dest n_neighbor crow goog delta\n", 650 | "2275 2757 3031 17 2672.684762 31016 28343.315238\n", 651 | "1969 2267 2497 7 1741.407797 30912 29170.592203\n", 652 | "2087 2499 2916 15 1441.316883 32476 31034.683117\n", 653 | "514 454 2491 17 2861.271057 36536 33674.728943\n", 654 | "1232 1203 2417 13 2097.580642 38791 36693.419358" 655 | ] 656 | }, 657 | "execution_count": 15, 658 | "metadata": {}, 659 | "output_type": "execute_result" 660 | } 661 | ], 662 | "source": [ 663 | "sample.tail()" 664 | ] 665 | }, 666 | { 667 | "cell_type": "markdown", 668 | "metadata": {}, 669 | "source": [ 670 | "## Example 1: Freeway Segment" 671 | ] 672 | }, 673 | { 674 | "cell_type": "code", 675 | "execution_count": 16, 676 | "metadata": {}, 677 | "outputs": [ 678 | { 679 | "name": "stdout", 680 | "output_type": "stream", 681 | "text": [ 682 | "[42.25180422900007, -73.03956206299995] [42.23796716600003, -73.05688164999998]\n" 683 | ] 684 | } 685 | ], 686 | "source": [ 687 | "print(XY[1203], XY[2417])" 688 | ] 689 | }, 690 | { 691 | "cell_type": "markdown", 692 | "metadata": {}, 693 | "source": [ 694 | "Google Map Directions for this O-D pair. Issue is that the destination segment is eastbound so the directions has to find the nearest on-ramp in the EB direction." 695 | ] 696 | }, 697 | { 698 | "cell_type": "markdown", 699 | "metadata": {}, 700 | "source": [ 701 | "![gmaps1](img/distance_comparison1.png)" 702 | ] 703 | }, 704 | { 705 | "cell_type": "markdown", 706 | "metadata": {}, 707 | "source": [ 708 | "## Example 2: Another Freeway Segment" 709 | ] 710 | }, 711 | { 712 | "cell_type": "code", 713 | "execution_count": 17, 714 | "metadata": { 715 | "scrolled": true 716 | }, 717 | "outputs": [ 718 | { 719 | "name": "stdout", 720 | "output_type": "stream", 721 | "text": [ 722 | "[42.34144445000004, -73.39379061699998] [42.35252574200007, -73.38469198599995]\n" 723 | ] 724 | } 725 | ], 726 | "source": [ 727 | "print(XY[2499], XY[2916])" 728 | ] 729 | }, 730 | { 731 | "cell_type": "markdown", 732 | "metadata": {}, 733 | "source": [ 734 | "This time, there is no nearby off-ramp to the destination so a circuitous route is required." 735 | ] 736 | }, 737 | { 738 | "cell_type": "markdown", 739 | "metadata": {}, 740 | "source": [ 741 | "![gmaps2](img/distance_comparison2.png)" 742 | ] 743 | }, 744 | { 745 | "cell_type": "markdown", 746 | "metadata": {}, 747 | "source": [ 748 | "So the common theme appears to be is that if one of the OD pairs is a freeway segment, then you are likely to have considerable longer driving distances than haversine. Also, of note, is that reverse directions would also give a substantially different answer also." 749 | ] 750 | }, 751 | { 752 | "cell_type": "markdown", 753 | "metadata": {}, 754 | "source": [ 755 | "What if we removed the road segments with FCC value of 1 and 2 from the dataset?" 756 | ] 757 | }, 758 | { 759 | "cell_type": "code", 760 | "execution_count": 18, 761 | "metadata": {}, 762 | "outputs": [], 763 | "source": [ 764 | "freeways = county[county['FUNCCODE'].isin(['1','2'])]\n", 765 | "idx = set(freeways.index)\n", 766 | "tf = (sample['origin'].isin(idx)) | (sample['dest'].isin(idx))\n", 767 | "F36 = sample[~tf]" 768 | ] 769 | }, 770 | { 771 | "cell_type": "markdown", 772 | "metadata": {}, 773 | "source": [ 774 | "All of our numbers have decreased as expected." 775 | ] 776 | }, 777 | { 778 | "cell_type": "code", 779 | "execution_count": 20, 780 | "metadata": {}, 781 | "outputs": [ 782 | { 783 | "data": { 784 | "text/plain": [ 785 | "count 2247.000000\n", 786 | "mean 419.908335\n", 787 | "std 1477.425090\n", 788 | "min -4.525865\n", 789 | "50% 67.556762\n", 790 | "75% 301.162028\n", 791 | "90% 972.725745\n", 792 | "95% 1881.109268\n", 793 | "99% 5113.434584\n", 794 | "max 26723.747754\n", 795 | "Name: delta, dtype: float64" 796 | ] 797 | }, 798 | "execution_count": 20, 799 | "metadata": {}, 800 | "output_type": "execute_result" 801 | } 802 | ], 803 | "source": [ 804 | "F36['delta'].describe([0.75,0.9,0.95,0.99])" 805 | ] 806 | }, 807 | { 808 | "cell_type": "markdown", 809 | "metadata": {}, 810 | "source": [ 811 | "## Figure 2: Google vs Haversine excluding FCC codes 1 and 2" 812 | ] 813 | }, 814 | { 815 | "cell_type": "code", 816 | "execution_count": 19, 817 | "metadata": { 818 | "scrolled": false 819 | }, 820 | "outputs": [ 821 | { 822 | "name": "stderr", 823 | "output_type": "stream", 824 | "text": [ 825 | "C:\\Users\\caoa\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\matplotlib\\cbook\\deprecation.py:106: 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", 826 | " warnings.warn(message, mplDeprecation, stacklevel=1)\n" 827 | ] 828 | }, 829 | { 830 | "data": { 831 | "text/plain": [ 832 | "Text(6,1,'y=x')" 833 | ] 834 | }, 835 | "execution_count": 19, 836 | "metadata": {}, 837 | "output_type": "execute_result" 838 | }, 839 | { 840 | "data": { 841 | "image/png": "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\n", 842 | "text/plain": [ 843 | "" 844 | ] 845 | }, 846 | "metadata": {}, 847 | "output_type": "display_data" 848 | } 849 | ], 850 | "source": [ 851 | "fig = plt.figure(figsize=(16,5))\n", 852 | "plt.scatter(F36['crow']/1000, F36['goog']/1000,alpha=0.1)\n", 853 | "plt.xlabel('Haversine Distance (km)')\n", 854 | "plt.ylabel('Google Driving Distance (km)')\n", 855 | "xy = [0,6.500]\n", 856 | "plt.plot(xy,xy,'k')\n", 857 | "ax = fig.add_subplot(111)\n", 858 | "plt.xlim([0, 7]); plt.ylim([0, 40])\n", 859 | "params = {'width':2,\n", 860 | " 'shrink': 0.05,\n", 861 | " 'facecolor':'black'}\n", 862 | "ax.annotate('y=x', xy=(5.8,5.8), xytext=(6,1), arrowprops=params)" 863 | ] 864 | }, 865 | { 866 | "cell_type": "markdown", 867 | "metadata": {}, 868 | "source": [ 869 | "Let's see what's going on with our worst offenders again. There seems to be two class of discrepancies based on the figure and the columns `delta` and `n_neighbor`. The bottom five fall into one class and the next 5 fall into a different class of problems." 870 | ] 871 | }, 872 | { 873 | "cell_type": "code", 874 | "execution_count": 21, 875 | "metadata": {}, 876 | "outputs": [ 877 | { 878 | "data": { 879 | "text/html": [ 880 | "
\n", 881 | "\n", 894 | "\n", 895 | " \n", 896 | " \n", 897 | " \n", 898 | " \n", 899 | " \n", 900 | " \n", 901 | " \n", 902 | " \n", 903 | " \n", 904 | " \n", 905 | " \n", 906 | " \n", 907 | " \n", 908 | " \n", 909 | " \n", 910 | " \n", 911 | " \n", 912 | " \n", 913 | " \n", 914 | " \n", 915 | " \n", 916 | " \n", 917 | " \n", 918 | " \n", 919 | " \n", 920 | " \n", 921 | " \n", 922 | " \n", 923 | " \n", 924 | " \n", 925 | " \n", 926 | " \n", 927 | " \n", 928 | " \n", 929 | " \n", 930 | " \n", 931 | " \n", 932 | " \n", 933 | " \n", 934 | " \n", 935 | " \n", 936 | " \n", 937 | " \n", 938 | " \n", 939 | " \n", 940 | " \n", 941 | " \n", 942 | " \n", 943 | " \n", 944 | " \n", 945 | " \n", 946 | " \n", 947 | " \n", 948 | " \n", 949 | " \n", 950 | " \n", 951 | " \n", 952 | " \n", 953 | " \n", 954 | " \n", 955 | " \n", 956 | " \n", 957 | " \n", 958 | " \n", 959 | " \n", 960 | " \n", 961 | " \n", 962 | " \n", 963 | " \n", 964 | " \n", 965 | " \n", 966 | " \n", 967 | " \n", 968 | " \n", 969 | " \n", 970 | " \n", 971 | " \n", 972 | " \n", 973 | " \n", 974 | " \n", 975 | " \n", 976 | " \n", 977 | " \n", 978 | " \n", 979 | " \n", 980 | " \n", 981 | " \n", 982 | " \n", 983 | " \n", 984 | " \n", 985 | " \n", 986 | " \n", 987 | " \n", 988 | " \n", 989 | " \n", 990 | " \n", 991 | " \n", 992 | " \n", 993 | " \n", 994 | " \n", 995 | " \n", 996 | " \n", 997 | " \n", 998 | "
origindestn_neighborcrowgoogdelta
122611902760195331.533066146959363.466934
3933362593185696.0874991582910132.912501
4884392592165637.5096961592210284.490304
753628814146041.0231571728511243.976843
754629814145988.3361241735811369.663876
18962127312482834.7821512600123166.217849
18161961281192296.4157402667324376.584260
18972128265272035.0373852660424568.962615
1332134631717300.5417662657726276.458234
444631712161.2522462688526723.747754
\n", 999 | "
" 1000 | ], 1001 | "text/plain": [ 1002 | " origin dest n_neighbor crow goog delta\n", 1003 | "1226 1190 2760 19 5331.533066 14695 9363.466934\n", 1004 | "393 336 2593 18 5696.087499 15829 10132.912501\n", 1005 | "488 439 2592 16 5637.509696 15922 10284.490304\n", 1006 | "753 628 814 14 6041.023157 17285 11243.976843\n", 1007 | "754 629 814 14 5988.336124 17358 11369.663876\n", 1008 | "1896 2127 3124 8 2834.782151 26001 23166.217849\n", 1009 | "1816 1961 2811 9 2296.415740 26673 24376.584260\n", 1010 | "1897 2128 2652 7 2035.037385 26604 24568.962615\n", 1011 | "1332 1346 3171 7 300.541766 26577 26276.458234\n", 1012 | "44 46 3171 2 161.252246 26885 26723.747754" 1013 | ] 1014 | }, 1015 | "execution_count": 21, 1016 | "metadata": {}, 1017 | "output_type": "execute_result" 1018 | } 1019 | ], 1020 | "source": [ 1021 | "F36.tail(10)" 1022 | ] 1023 | }, 1024 | { 1025 | "cell_type": "markdown", 1026 | "metadata": {}, 1027 | "source": [ 1028 | "## Example 3: Freeway Segment" 1029 | ] 1030 | }, 1031 | { 1032 | "cell_type": "code", 1033 | "execution_count": 22, 1034 | "metadata": {}, 1035 | "outputs": [ 1036 | { 1037 | "name": "stdout", 1038 | "output_type": "stream", 1039 | "text": [ 1040 | "[42.328109753000035, -73.36298205699995] [42.32730243800006, -73.36461153199997]\n" 1041 | ] 1042 | } 1043 | ], 1044 | "source": [ 1045 | "print(XY[46], XY[3171])" 1046 | ] 1047 | }, 1048 | { 1049 | "cell_type": "markdown", 1050 | "metadata": {}, 1051 | "source": [ 1052 | "The problem is that the destination is still on a freeway segment and heading westbound but before the on-ramp to the highway." 1053 | ] 1054 | }, 1055 | { 1056 | "cell_type": "markdown", 1057 | "metadata": {}, 1058 | "source": [ 1059 | "![gmaps3](img/distance_comparison3.png)" 1060 | ] 1061 | }, 1062 | { 1063 | "cell_type": "markdown", 1064 | "metadata": {}, 1065 | "source": [ 1066 | "Let's look at its FUNCCODE of the destination to make sure we're not hallucinating. It has code 5. " 1067 | ] 1068 | }, 1069 | { 1070 | "cell_type": "code", 1071 | "execution_count": 23, 1072 | "metadata": {}, 1073 | "outputs": [ 1074 | { 1075 | "data": { 1076 | "text/plain": [ 1077 | "FUNCCODE 5\n", 1078 | "pt (-73.36461153199997, 42.32730243800006)\n", 1079 | "Name: 3171, dtype: object" 1080 | ] 1081 | }, 1082 | "execution_count": 23, 1083 | "metadata": {}, 1084 | "output_type": "execute_result" 1085 | } 1086 | ], 1087 | "source": [ 1088 | "county.loc[3171,['FUNCCODE','pt'] ]" 1089 | ] 1090 | }, 1091 | { 1092 | "cell_type": "markdown", 1093 | "metadata": {}, 1094 | "source": [ 1095 | "Not sure if we can do anything to avoid this situation. If we reverse directions, then the distance would definitely be a lot shorter." 1096 | ] 1097 | }, 1098 | { 1099 | "cell_type": "markdown", 1100 | "metadata": {}, 1101 | "source": [ 1102 | "## Example 4: Shortest Time Route" 1103 | ] 1104 | }, 1105 | { 1106 | "cell_type": "code", 1107 | "execution_count": 24, 1108 | "metadata": {}, 1109 | "outputs": [ 1110 | { 1111 | "name": "stdout", 1112 | "output_type": "stream", 1113 | "text": [ 1114 | "[42.11620711100005, -73.49637794099993] [42.154813696000076, -73.44574458599999]\n" 1115 | ] 1116 | } 1117 | ], 1118 | "source": [ 1119 | "print(XY[629], XY[814])" 1120 | ] 1121 | }, 1122 | { 1123 | "cell_type": "markdown", 1124 | "metadata": {}, 1125 | "source": [ 1126 | "This seems to be a function of the road network but also google's preference for shortest time. There is a shorter distance route that it could have given. Unfortunately, there is no way to specify this constraint in the call to the API." 1127 | ] 1128 | }, 1129 | { 1130 | "cell_type": "markdown", 1131 | "metadata": {}, 1132 | "source": [ 1133 | "![gmaps4](img/distance_comparison4.png)" 1134 | ] 1135 | }, 1136 | { 1137 | "cell_type": "markdown", 1138 | "metadata": {}, 1139 | "source": [ 1140 | "## Example 5: Another Shortest Time Route" 1141 | ] 1142 | }, 1143 | { 1144 | "cell_type": "code", 1145 | "execution_count": 25, 1146 | "metadata": { 1147 | "scrolled": true 1148 | }, 1149 | "outputs": [ 1150 | { 1151 | "name": "stdout", 1152 | "output_type": "stream", 1153 | "text": [ 1154 | "[42.048620276000065, -73.12225781699993] [42.08375019500005, -73.07301614799997]\n" 1155 | ] 1156 | } 1157 | ], 1158 | "source": [ 1159 | "print(XY[439], XY[2592])" 1160 | ] 1161 | }, 1162 | { 1163 | "cell_type": "markdown", 1164 | "metadata": {}, 1165 | "source": [ 1166 | "Same problem here. Google chose the shortest time path instead of the shortest distance path. " 1167 | ] 1168 | }, 1169 | { 1170 | "cell_type": "markdown", 1171 | "metadata": {}, 1172 | "source": [ 1173 | "![gmaps5](img/distance_comparison5.png)" 1174 | ] 1175 | }, 1176 | { 1177 | "cell_type": "markdown", 1178 | "metadata": {}, 1179 | "source": [ 1180 | "# Summary\n", 1181 | "\n", 1182 | "Differences in distance are attributable to the following factors:\n", 1183 | "1. O-D pair contains a freeway segment.\n", 1184 | "2. Google API chooses the shortest time path by default rather than the shortest distance path." 1185 | ] 1186 | }, 1187 | { 1188 | "cell_type": "code", 1189 | "execution_count": null, 1190 | "metadata": {}, 1191 | "outputs": [], 1192 | "source": [] 1193 | } 1194 | ], 1195 | "metadata": { 1196 | "kernelspec": { 1197 | "display_name": "Python 3", 1198 | "language": "python", 1199 | "name": "python3" 1200 | }, 1201 | "language_info": { 1202 | "codemirror_mode": { 1203 | "name": "ipython", 1204 | "version": 3 1205 | }, 1206 | "file_extension": ".py", 1207 | "mimetype": "text/x-python", 1208 | "name": "python", 1209 | "nbconvert_exporter": "python", 1210 | "pygments_lexer": "ipython3", 1211 | "version": "3.6.4" 1212 | } 1213 | }, 1214 | "nbformat": 4, 1215 | "nbformat_minor": 2 1216 | } 1217 | --------------------------------------------------------------------------------