04a_Intro_to_networks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "so1sQtDiIP9c"
   },
   "source": [
    "# Intro to Networks\n",
    "The study of networks investigates the relationship between discrete objects using [graphs](https://en.wikipedia.org/wiki/Graph_(discrete_mathematics))\n",
    "\n",
    "![network_diagram](https://upload.wikimedia.org/wikipedia/commons/2/2f/Small_Network.png)\n",
    "\n",
    "Graphs are a mathematical structure which represent a set of objects (called nodes or vertices) as well as their symmetric or asymmetric relationships (called links or edges).\n",
    "\n",
    "They can be used to represent both physical systems (roads, pipelines, electrical grid) and abstract systems (social, collaboration, genetics).\n",
    "\n",
    "For this course, we'll be using the python `networkx` package, which provides many useful classes and functions for representing and doing computations with networks. \n",
    "\n",
    "In addition, we'll be using the `osmnx` package, which will download openstreetmap road networks as `networkx` objects. There are a ton of useful examples in the [examples repo](https://github.com/gboeing/osmnx-examples).\n",
    "\n",
    "This lecture is based off of the [osmnx-examples](https://github.com/gboeing/osmnx-examples) code and the [Automating GIS Processes](https://automating-gis-processes.github.io/2018/notebooks/L6/retrieve_osm_data.html) course."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "uyEYFnMO8RM7"
   },
   "outputs": [],
   "source": [
    "import networkx as nx # need networkx >= 2.5\n",
    "import osmnx as ox\n",
    "import contextily as ctx \n",
    "from matplotlib import pyplot as plt\n",
    "from shapely.geometry import Polygon\n",
    "import folium\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qRkpwHw89i-w"
   },
   "outputs": [],
   "source": [
    "# Specify the name that is used to seach for the data\n",
    "place_name = \"Cambridge, MA, USA\"\n",
    "\n",
    "# Fetch OSM street network from the location\n",
    "# this will take a while because there's a lot of streets\n",
    "graph = ox.graph_from_place(place_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# metadata about the graph object\n",
    "graph.graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can save the graph to a file so that we don't have to\n",
    "# wait for it to download again next time\n",
    "ox.io.save_graphml(graph, 'cambridge_osmnx.graphml')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loading graph from a file\n",
    "graph = ox.io.load_graphml('cambridge_osmnx.graphml')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 357
    },
    "colab_type": "code",
    "id": "E8C4u1Cq8R2h",
    "outputId": "881ea8bf-82ef-4d1f-fa6a-fc60df9e9882"
   },
   "outputs": [],
   "source": [
    "# Let's take a look at the graph\n",
    "fig, ax = ox.plot_graph(graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "cDik6heH-jzq",
    "outputId": "4f85b1e7-7fe7-4255-c317-82b858b43592"
   },
   "outputs": [],
   "source": [
    "# we can project the graph into epsg:3857 so that units are in meters\n",
    "# using the .project_graph() function; \n",
    "# by default, osmnx graphs are created in WGS84, (epsg:4326)\n",
    "graph_proj = ox.project_graph(graph, to_crs='epsg:3857')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can then convert the projected graph to a geodataframe\n",
    "graph_nodes_gdf, graph_edges_gdf = ox.graph_to_gdfs(graph_proj)\n",
    "graph_nodes_gdf.crs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "graph_nodes_gdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "graph_edges_gdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 170
    },
    "colab_type": "code",
    "id": "d6pjn3VPRtQY",
    "outputId": "512a1c18-5457-4e0c-a54b-31e0c6a5c770"
   },
   "outputs": [],
   "source": [
    "# we can also get a gdf for the footprint of the place\n",
    "place_footprint = ox.geocode_to_gdf(place_name)\n",
    "graph_area = place_footprint.to_crs('epsg:3857')\n",
    "graph_area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph_area.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "H96qB6LdSggm"
   },
   "source": [
    "## Exercises\n",
    "What is the total area of cambridge in sq meters?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6-4FwvAxSeVr"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many street segments in Cambridge are longer than 100 meters?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HnAHrTJeUGqy"
   },
   "source": [
    "## Road network statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 642
    },
    "colab_type": "code",
    "id": "jsY1RXD7-06A",
    "outputId": "2cc4cb47-6312-411f-a506-3daeb788cb23"
   },
   "outputs": [],
   "source": [
    "# we can get basic stats about the network:\n",
    "ox.stats.basic_stats(graph_proj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ghw38pdfXSw5"
   },
   "source": [
    "Circuity is the ratio of network distance (distance traveled along roads) to euclidean distance (straight line). Higher circuity means greater inefficiency in traveling along the roads.\n",
    "\n",
    "Check the [documentation](https://osmnx.readthedocs.io/en/stable/osmnx.html#module-osmnx.stats) for more info about each statistic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 729
    },
    "colab_type": "code",
    "id": "3atCRzMqSEqq",
    "outputId": "48650ef9-7983-4ec0-cfad-c0226f6967c8"
   },
   "outputs": [],
   "source": [
    "# if you pass in the area, you can get density info\n",
    "area_cambridge_sqm = graph_area['geometry'].area\n",
    "ox.basic_stats(graph_proj, area=area_cambridge_sqm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "i7D1Ye81DRjZ"
   },
   "source": [
    "## Getting data other ways\n",
    "In the above example, we used the name of a place to get the data that we wanted.\n",
    "\n",
    "However, there are other ways to specify locations which may be more convenient.\n",
    "\n",
    "For example, you can get [graphs from address](https://osmnx.readthedocs.io/en/stable/osmnx.html?highlight=poly#osmnx.core.graph_from_address), [bounding box](https://osmnx.readthedocs.io/en/stable/osmnx.html?highlight=poly#osmnx.core.graph_from_bbox), [points](https://osmnx.readthedocs.io/en/stable/osmnx.html?highlight=poly#osmnx.core.graph_from_bbox), or [shapely polygon object](https://osmnx.readthedocs.io/en/stable/osmnx.html?highlight=poly#osmnx.core.graph_from_polygon)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JkXzm2OoMBPF"
   },
   "source": [
    "The types of networks you can get are:\n",
    "\n",
    "-    `drive` - get drivable public streets (but not service roads)\n",
    "-    `drive_service` - get drivable streets, including service roads\n",
    "-    `walk` - get all streets and paths that pedestrians can use (this network type ignores one-way directionality)\n",
    "-    `bike` - get all streets and paths that cyclists can use\n",
    "-    `all` - download all non-private OSM streets and paths\n",
    "-    `all_private` - download all OSM streets and paths, including private-access ones\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "YfDBCndbcG0o",
    "outputId": "1ad2432f-05af-4ccf-c069-c2b04236a014"
   },
   "outputs": [],
   "source": [
    "# Coordinates of the MIT main campus in Decimal Degrees\n",
    "coordinates = [(-71.092562, 42.357602), (-71.080155, 42.361553),\n",
    "               (-71.089817, 42.362584), (-71.094688, 42.360198)]\n",
    "\n",
    "# Create a Shapely polygon from the coordinate-tuple list\n",
    "poly = Polygon(coordinates)\n",
    "\n",
    "# convert to meters from latlong by projecting to epsg:3857\n",
    "poly_m, poly_crs_m = ox.projection.project_geometry(poly, to_crs='epsg:3857')\n",
    "\n",
    "# put a buffer of 1 mile (1609.34 m) to get everything w/in 1 mile\n",
    "poly_with_buffer_m = poly_m.buffer(1609.34)\n",
    "\n",
    "# convert back to lat-long\n",
    "poly_with_buffer_ll, poly_crs_ll = ox.projection.project_geometry(poly_with_buffer_m, \n",
    "                                                        crs=poly_crs_m, \n",
    "                                                        to_crs='epsg:4326', \n",
    "                                                        to_latlong=True)\n",
    "\n",
    "# get all walkable roads within poly\n",
    "walkable_roads_near_mit = ox.graph_from_polygon(poly_with_buffer_ll, \n",
    "                                       network_type='walk',\n",
    "                                       clean_periphery=True)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 466
    },
    "colab_type": "code",
    "id": "Aj6GGgH0LeMC",
    "outputId": "7934d158-5de0-4cc4-ab0c-29a0041b450c"
   },
   "outputs": [],
   "source": [
    "# let's plot it\n",
    "fig, ax = ox.plot_graph(walkable_roads_near_mit, figsize=(8,10), node_size=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# example of a road\n",
    "all_edges_list = list(walkable_roads_near_mit.edges) # put the id for each edge in a list\n",
    "print(all_edges_list[0]) # id of first edge\n",
    "print(walkable_roads_near_mit.edges[all_edges_list[0]]) # get details for first edge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# get attribute for all edges\n",
    "walkable_roads_near_mit.edges(data='name')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "voDE2c4-fbUd",
    "outputId": "765cdb0d-4998-464b-c895-820f5acacfc6"
   },
   "outputs": [],
   "source": [
    "# example of a node (intersection)\n",
    "all_nodes_list = list(walkable_roads_near_mit.nodes)\n",
    "print(all_nodes_list[0]) # id of first node\n",
    "print(walkable_roads_near_mit.nodes[all_nodes_list[0]]) # details for first node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# get attribute for all nodes\n",
    "walkable_roads_near_mit.nodes(data='street_count')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n",
    "How many walkable roads near MIT are longer than 100 meters?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3ZwnblcYd0UH"
   },
   "source": [
    "## Routing\n",
    "We can get the node closest to a point using the `ox.distance.nearest_node` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 412
    },
    "colab_type": "code",
    "id": "HEaCknQPdaOr",
    "outputId": "895788c3-0df0-44e3-ea27-b32aaca44050"
   },
   "outputs": [],
   "source": [
    "orig_node = ox.distance.nearest_nodes(walkable_roads_near_mit, -71.092562, 42.357602)\n",
    "\n",
    "# let's calculate the route to a random destination node\n",
    "rand_node = np.random.choice(walkable_roads_near_mit.nodes)\n",
    "print(walkable_roads_near_mit[rand_node])\n",
    "route = ox.distance.shortest_path(walkable_roads_near_mit, \n",
    "                         orig_node, rand_node, \n",
    "                         weight='length')\n",
    "fig, ax = ox.plot_graph_route(walkable_roads_near_mit, route, node_size=0)\n",
    "shortest_path_length = nx.shortest_path_length(walkable_roads_near_mit, orig_node, \n",
    "                              rand_node, weight='length')\n",
    "print(f'length of shortest walkable path from node {orig_node} to {rand_node} is {shortest_path_length:.2f}m') # the {:.2f} syntax means round off to 2 digits after decimal pt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `shortest_path` function in networkx uses [Dijkstra's algorithm](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm) to efficiently calculate the shortest path between two nodes. The networkx library also provides many other useful functions on graphs; for instance, the [Floyd-Warshall algorithm](https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm), which efficiently computes the shortest paths between all pairs of nodes, and the [A* (A-star) algorithm](https://en.wikipedia.org/wiki/A*_search_algorithm), which is similar to Dijkstra's algorithm, except it runs faster by taking advantage of a distance \"approximation\" that can be calculated between two nodes without knowing the shortest path outright. Check out these links if you want to learn more about these algorithms, and check out the [networkx documentation](https://networkx.github.io/documentation/networkx-2.4/index.html) if you want to learn more about all the methods networkx provides."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WynjOpLWdacF"
   },
   "source": [
    "## Building outlines\n",
    "We can get the footprint of objects such as buildings as geodataframes with `osmnx`. Here we'll get the building footprints near MIT."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "IiqszgpxDRCS",
    "outputId": "89e3a205-54ce-4083-f37b-0f9f24c2ab6a"
   },
   "outputs": [],
   "source": [
    "# we can get the footprints of objects within this poly\n",
    "building_footprints = ox.geometries.geometries_from_polygon(poly_with_buffer_ll, tags={'building':True})\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can perform any query using OSM tags: https://wiki.openstreetmap.org/wiki/Map_features\n",
    "\n",
    "Note that if you include multiple tags, it gets the **union** of the results, not the intersection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "road_footprints = ox.geometries.geometries_from_polygon(poly_with_buffer_ll, tags={'highway':True}) # get roads with geometry\n",
    "# note that most roads do not have footprint information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "7piM1WMoac9Y",
    "outputId": "530be765-db52-4c87-c8a6-ed28f4ded3ef"
   },
   "outputs": [],
   "source": [
    "# project into UTM for info in meters\n",
    "building_footprints_proj = ox.projection.project_gdf(building_footprints)\n",
    "road_footprints_proj = ox.projection.project_gdf(road_footprints)\n",
    "building_footprints_proj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# column names\n",
    "building_footprints_proj.columns.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6785pAjwZwvK"
   },
   "outputs": [],
   "source": [
    "# drop rows where there's no shape info\n",
    "building_footprints_proj = building_footprints_proj.dropna(subset=['geometry'])\n",
    "road_footprints = road_footprints.dropna(subset=['geometry'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 262
    },
    "colab_type": "code",
    "id": "D1TFDKZZM0Eg",
    "outputId": "ba400f83-cb03-4a3f-e4d4-3fd6633b8ca7"
   },
   "outputs": [],
   "source": [
    "fig, ax = ox.plot_footprints(building_footprints_proj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot roads with footprints\n",
    "fig, ax = ox.plot_footprints(road_footprints_proj) # note that this is only a small subset of all roads"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1Y_JvqmXZhEY"
   },
   "outputs": [],
   "source": [
    "# save the geodataframe to a file to persist\n",
    "# can choose to write only a subset of columns if you want\n",
    "building_footprints_proj[['description', 'operator', 'railway', 'geometry', 'attribution',\n",
    "       'source', 'addr:city', 'addr:housenumber', 'addr:postcode',\n",
    "       'addr:state', 'addr:street', 'amenity']].to_file('buildings_around_mit.geojson', driver='GeoJSON')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FWZpnbIHbs41"
   },
   "source": [
    "## Exercises\n",
    "Plot the walkable roads and buildings in the area near MIT in the same figure. The `osmnx` plotting features use matplotlib on the backend. Check [the documentation](https://osmnx.readthedocs.io/en/stable/osmnx.html#osmnx.plot.plot_graph) for more formatting options for plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "H__6Pkrca23i"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, go back to one of the previous exercises and plot all the nodes on the periphery of Cambridge and the roads in Cambridge in the same figure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7sDrc2wzcoIA"
   },
   "source": [
    "## Interactive graph with folium\n",
    "Folium is a library which creates interactive web maps. This can be used to visualize and explore the data. However, it is slower to load and cannot scale to as large networks as the standard matplotlib plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 371
    },
    "colab_type": "code",
    "id": "MH8wPQt5cnNL",
    "outputId": "b41b5cb8-acb9-4b08-b445-e62b8ff8a94c"
   },
   "outputs": [],
   "source": [
    "folium_graph = ox.plot_graph_folium(walkable_roads_near_mit)\n",
    "folium_graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 371
    },
    "colab_type": "code",
    "id": "jA-JyWRfcuil",
    "outputId": "d0c22e3a-8ca5-402b-a4e0-23ec7a95638c"
   },
   "outputs": [],
   "source": [
    "ox.plot_route_folium(walkable_roads_near_mit, route, route_map = folium_graph, color='#ff0000')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "byQI4mwpkGe4"
   },
   "source": [
    "## Get places of interest\n",
    "OSM can also give places of interest, like restaurants, pharmacies, hospitals, and toilets. The full list is available [here](https://wiki.openstreetmap.org/wiki/Key:amenity).\n",
    "\n",
    "Let's look at the POIs near MIT."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "SesUaN4qjzmq",
    "outputId": "b605698c-a8b0-4895-8cdd-9030dcffa88b",
    "tags": []
   },
   "outputs": [],
   "source": [
    "fast_food = ox.geometries.geometries_from_polygon(poly_with_buffer_ll, tags={'amenity': 'fast_food'})\n",
    "fast_food"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PYNXpI3snJn3"
   },
   "outputs": [],
   "source": [
    "walkable_nodes, walkable_edges = ox.graph_to_gdfs(walkable_roads_near_mit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 781
    },
    "colab_type": "code",
    "id": "EhFovfU7k9Yk",
    "outputId": "b0b1f850-7fe1-4171-8983-3df720a9cc29"
   },
   "outputs": [],
   "source": [
    "# plot roads, buildings, and fast_food\n",
    "fig, ax = plt.subplots(1,1, figsize=[20,20])\n",
    "building_footprints.plot(ax=ax)\n",
    "walkable_edges.plot(ax=ax, color='black')\n",
    "fast_food.plot(ax=ax, color='#FF0099', markersize=50)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tcNVMmwpog-P"
   },
   "source": [
    "# Exercise\n",
    "In groups, pick a location, ask an interesting question, do an analysis to answer that question.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KQR1P_NrpFJl"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "H96qB6LdSggm"
   ],
   "include_colab_link": true,
   "name": "04_Intro_to_networks.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}