Visualiza datos de estadísticas geoespaciales con un notebook de Colab

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Crea un notebook de Colab

En este instructivo, se compila un notebook de Colab para visualizar datos de análisis geoespaciales. Para abrir una versión precompilada del notebook en Colab, Colab Enterprise o BigQuery Studio, haz clic en los vínculos que se encuentran en la parte superior de la versión de GitHub del instructivo Visualización geoespacial de BigQuery en Colab.

1. Abre Colab.

   Abrir Colab

2. En el diálogo Abrir notebook, haz clic en Nuevo notebook.

3. Haz clic en Untitled0.ipynb y cambia el nombre del notebook a bigquery-geo.ipynb.

4. Selecciona File > Save.

Autentícate con Google Cloud y Google Maps

En este instructivo, se consultan conjuntos de datos de BigQuery y se usa la API de JavaScript de Google Maps. Para usar estos recursos, debes autenticar el tiempo de ejecución de Colab con Google Cloud y la API de Maps.

Autentícate con Google Cloud

1. Para insertar una celda de código, haz clic en add Código.

2. Para autenticar con tu proyecto, ingresa el siguiente código:

   # REQUIRED: Authenticate with your project.
   GCP_PROJECT_ID = "PROJECT_ID"  #@param {type:"string"}
   
   from google.colab import auth
   from google.colab import userdata
   
   auth.authenticate_user(project_id=GCP_PROJECT_ID)

   Reemplaza PROJECT_ID con el ID del proyecto.

3. Haz clic en play_circle_filled Ejecutar celda.

4. Cuando se te solicite, haz clic en Permitir para otorgarle a Colab acceso a tus credenciales, si estás de acuerdo.

5. En la página Acceder con Google, elige tu cuenta.

6. En la página Sign in to Third-party authored notebook code, haz clic en Continue.

7. En Seleccionar a qué código de notebook creado por terceros puede acceder, haz clic en Seleccionar todo y, luego, en Continuar.

   Después de completar el flujo de autorización, no se genera ningún resultado en tu notebook de Colab. La marca de verificación junto a la celda indica que el código se ejecutó correctamente.

Opcional: Realiza la autenticación con Google Maps

Si usas Google Maps Platform como proveedor de mapas para los mapas base, debes proporcionar una clave de API de Google Maps Platform. El notebook recupera la clave de tus secretos de Colab.

Este paso solo es necesario si usas la API de Maps. Si no te autenticas con Google Maps Platform, pydeck usará el mapa carto.

1. Para obtener tu clave de API de Google Maps, sigue las instrucciones que se indican en la página Cómo usar claves de API de la documentación de Google Maps.

2. Cambia a tu notebook de Colab y, luego, haz clic en vpn_key Secretos.

3. Haz clic en Agregar secreto nuevo.

4. En Nombre, ingresa GMP_API_KEY.

5. En Valor, ingresa el valor de la clave de API de Maps que generaste anteriormente.

6. Cierra el panel Secrets.

7. Para insertar una celda de código, haz clic en add Código.

8. Para autenticarte con la API de Maps, ingresa el siguiente código:

   # Authenticate with the Google Maps JavaScript API.
   GMP_API_SECRET_KEY_NAME = "GMP_API_KEY" #@param {type:"string"}
   
   if GMP_API_SECRET_KEY_NAME:
     GMP_API_KEY = userdata.get(GMP_API_SECRET_KEY_NAME) if GMP_API_SECRET_KEY_NAME else None
   else:
     GMP_API_KEY = None

9. Cuando se te solicite, haz clic en Otorgar acceso para darle al notebook acceso a tu clave, si estás de acuerdo.

10. Haz clic en play_circle_filled Ejecutar celda.

    Después de completar el flujo de autorización, no se genera ningún resultado en tu notebook de Colab. La marca de verificación junto a la celda indica que el código se ejecutó correctamente.

Instala paquetes de Python y, luego, importa bibliotecas de ciencia de datos

Además de los módulos de Python colabtools (google.colab), en este instructivo se usan varios otros paquetes y bibliotecas de ciencia de datos de Python.

En esta sección, instalarás los paquetes pydeck y h3. pydeck proporciona renderización espacial de alta escala en Python, potenciada por deck.gl. h3-py proporciona el sistema de indexación geoespacial jerárquico hexagonal H3 de Uber en Python.

Luego, importa las bibliotecas h3 y pydeck, y las siguientes bibliotecas geoespaciales de Python:

• geopandas para extender los tipos de datos que usa pandas y permitir operaciones espaciales en tipos geométricos.
• shapely para la manipulación y el análisis de objetos geométricos planos individuales.
• branca para generar mapas de colores HTML y JavaScript.
• geemap.deck para la visualización con pydeck y earthengine-api.

Después de importar las bibliotecas, habilitas las tablas interactivas para los DataFrames de pandas en Colab.

Instala los paquetes pydeck y h3.

1. Para insertar una celda de código, haz clic en add Código.

2. Para instalar los paquetes pydeck y h3, ingresa el siguiente código:

   # Install pydeck and h3.
   !pip install pydeck>=0.9 h3>=4.2

3. Haz clic en play_circle_filled Ejecutar celda.

   Después de completar la instalación, no se genera ningún resultado en tu notebook de Colab. La marca de verificación junto a la celda indica que el código se ejecutó correctamente.

Importa las bibliotecas de Python

1. Para insertar una celda de código, haz clic en add Código.

2. Para importar las bibliotecas de Python, ingresa el siguiente código:

   # Import data science libraries.
   import branca
   import geemap.deck as gmdk
   import h3
   import pydeck as pdk
   import geopandas as gpd
   import shapely

3. Haz clic en play_circle_filled Ejecutar celda.

   Después de ejecutar el código, no se genera ningún resultado en tu notebook de Colab. La marca de verificación junto a la celda indica que el código se ejecutó correctamente.

Habilita tablas interactivas para DataFrames de pandas

1. Para insertar una celda de código, haz clic en add Código.

2. Para habilitar los DataFrames de pandas, ingresa el siguiente código:

   # Enable displaying pandas data frames as interactive tables by default.
   from google.colab import data_table
   data_table.enable_dataframe_formatter()

3. Haz clic en play_circle_filled Ejecutar celda.

   Después de ejecutar el código, no se genera ningún resultado en tu notebook de Colab. La marca de verificación junto a la celda indica que el código se ejecutó correctamente.

Crea rutinas compartidas

En esta sección, crearás dos rutinas compartidas: una que renderiza capas en un mapa base y una que convierte un DataFrame pandas en un DataFrame geopandas.

1. Para insertar una celda de código, haz clic en add Código.

2. Para crear una rutina compartida para renderizar capas en un mapa, ingresa el siguiente código:

   # Set Google Maps as the base map provider.
   MAP_PROVIDER_GOOGLE = pdk.bindings.base_map_provider.BaseMapProvider.GOOGLE_MAPS.value
   
   # Shared routine for rendering layers on a map using geemap.deck.
   def display_pydeck_map(layers, view_state, **kwargs):
     deck_kwargs = kwargs.copy()
   
     # Use Google Maps as the base map only if the API key is provided.
     if GMP_API_KEY:
       deck_kwargs.update({
         "map_provider": MAP_PROVIDER_GOOGLE,
         "map_style": pdk.bindings.map_styles.GOOGLE_ROAD,
         "api_keys": {MAP_PROVIDER_GOOGLE: GMP_API_KEY},
       })
   
     m = gmdk.Map(initial_view_state=view_state, ee_initialize=False, **deck_kwargs)
   
     for layer in layers:
       m.add_layer(layer)
     return m

3. Haz clic en play_circle_filled Ejecutar celda.

   Después de ejecutar el código, no se genera ningún resultado en tu notebook de Colab. La marca de verificación junto a la celda indica que el código se ejecutó correctamente.

4. Para insertar una celda de código, haz clic en add Código.

5. Para crear una rutina compartida que convierta un DataFrame pandas en un DataFrame geopandas, ingresa el siguiente código:

   # Shared routine for converting a pandas dataframe to a GeoPandas dataframe.
   def pandas_to_geopandas(df, geometry_column='geometry'):
   
     # Use shapely library to parse WKT strings into shapely Geometry based
     # objects
     df[geometry_column] = df[geometry_column].dropna().apply(shapely.from_wkt)
   
     # Convert to a geopandas Dataframe
     return gpd.GeoDataFrame(df, geometry=geometry_column, crs='EPSG:4326')
     

6. Haz clic en play_circle_filled Ejecutar celda.

   Después de ejecutar el código, no se genera ningún resultado en tu notebook de Colab. La marca de verificación junto a la celda indica que el código se ejecutó correctamente.

Crea un diagrama de dispersión

En esta sección, crearás un diagrama de dispersión de todas las estaciones de bicicletas compartidas del conjunto de datos públicos de Ford GoBike Share de San Francisco recuperando datos de la tabla bigquery-public-data.san_francisco_bikeshare.bikeshare_station_info. El diagrama de dispersión se crea con una capa y una capa de diagrama de dispersión del framework deck.gl.

Los diagramas de dispersión son útiles cuando necesitas revisar un subconjunto de puntos individuales (también conocido como verificación puntual).

En el siguiente ejemplo, se muestra cómo usar una capa y una capa de diagrama de dispersión para renderizar puntos individuales como círculos. Para renderizar los puntos, debes extraer la longitud y la latitud como coordenadas x e y de la columna station_geom en el conjunto de datos de bicicletas compartidas.

Para extraer las coordenadas, se convierten los datos en un DataFrame geopandas, que convierte cada elemento de la columna station_geom en un objeto shapely. shapely proporciona métodos y propiedades de Python que te permiten extraer componentes como x e y.

1. Para insertar una celda de código, haz clic en add Código.

2. Para consultar el conjunto de datos públicos de Ford GoBike Share de San Francisco, ingresa el siguiente código. Este código usa la función mágica %%bigquery para ejecutar la consulta y mostrar los resultados en un DataFrame:

   # Query the station ID, station name, station short name, and station
   # geometry from the bike share dataset.
   # NOTE: In this tutorial, the denormalized 'lat' and 'lon' columns are
   # ignored. They are decomposed components of the geometry.
   %%bigquery df_sanfrancisco_bike_stations --project {GCP_PROJECT_ID}
   
   SELECT
     station_id,
     name,
     short_name,
     station_geom
   FROM
     `bigquery-public-data.san_francisco_bikeshare.bikeshare_station_info`

3. Haz clic en play_circle_filled Ejecutar celda.

   El resultado es similar a este:

   Job ID 12345-1234-5678-1234-123456789 successfully executed: 100%

4. Para insertar una celda de código, haz clic en add Código.

5. Para convertir los datos en un DataFrame de geopandas, ingresa el siguiente código:

   # Convert the data to a geopandas.GeoDataFrame.
   gdf_sf_bikestations = pandas_to_geopandas(df_sanfrancisco_bike_stations, geometry_column='station_geom')
   gdf_sf_bikestations.info()

6. Haz clic en play_circle_filled Ejecutar celda.

   El resultado debe verse de la siguiente manera:

   <class 'geopandas.geodataframe.GeoDataFrame'>
   RangeIndex: 472 entries, 0 to 471
   Data columns (total 4 columns):
   #   Column        Non-Null Count  Dtype
   ---  ------        --------------  -----
   0   station_id    472 non-null    object
   1   name          472 non-null    object
   2   short_name    472 non-null    object
   3   station_geom  472 non-null    geometry
   dtypes: geometry(1), object(3)
   memory usage: 14.9+ KB
   

7. Para insertar una celda de código, haz clic en add Código.

8. Para obtener una vista previa de las primeras cinco filas del DataFrame, ingresa el siguiente código:

   # Preview the first five rows
   gdf_sf_bikestations.head()

9. Haz clic en play_circle_filled Ejecutar celda.

   El resultado es similar a este:

   

10. Para insertar una celda de código, haz clic en add Código.

11. Para extraer los valores de longitud y latitud de la columna station_geom, ingresa el siguiente código:

    # Extract the longitude (x) and latitude (y) from station_geom.
    gdf_sf_bikestations["longitude"] = gdf_sf_bikestations["station_geom"].x
    gdf_sf_bikestations["latitude"] = gdf_sf_bikestations["station_geom"].y

12. Haz clic en play_circle_filled Ejecutar celda.

    Después de ejecutar el código, no se genera ningún resultado en tu notebook de Colab. La marca de verificación junto a la celda indica que el código se ejecutó correctamente.

13. Para insertar una celda de código, haz clic en add Código.

14. Para renderizar el diagrama de dispersión de las estaciones de bicicletas compartidas según los valores de longitud y latitud que extrajiste anteriormente, ingresa el siguiente código:

    # Render a scatter plot using pydeck with the extracted longitude and
    # latitude columns in the gdf_sf_bikestations geopandas.GeoDataFrame.
    scatterplot_layer = pdk.Layer(
      "ScatterplotLayer",
      id="bike_stations_scatterplot",
      data=gdf_sf_bikestations,
      get_position=['longitude', 'latitude'],
      get_radius=100,
      get_fill_color=[255, 0, 0, 140],  # Adjust color as desired
      pickable=True,
    )
    
    view_state = pdk.ViewState(latitude=37.77613, longitude=-122.42284, zoom=12)
    display_pydeck_map([scatterplot_layer], view_state)

15. Haz clic en play_circle_filled Ejecutar celda.

    El resultado es similar a este:

    

Visualiza polígonos

Las estadísticas geoespaciales te permiten analizar y visualizar datos geoespaciales en BigQuery mediante tipos de datos GEOGRAPHY y funciones geográficas de GoogleSQL.

El tipo de datos GEOGRAPHY en el análisis geoespacial es una colección de puntos, linestrings y polígonos que se representa como un conjunto de puntos o un subconjunto de la superficie de la Tierra. Un tipo GEOGRAPHY puede contener objetos como los siguientes:

• Puntos
• Líneas
• Polígonos
• Multipolígonos

Para obtener una lista de todos los objetos compatibles, consulta la documentación del tipo GEOGRAPHY.

Si se te proporcionan datos geoespaciales sin conocer las formas esperadas, puedes visualizar los datos para descubrirlas. Para visualizar formas, puedes convertir los datos geográficos al formato GeoJSON. Luego, puedes visualizar los datos de GeoJSON con una capa GeoJSON del framework deck.gl.

En esta sección, consultarás datos geográficos en el conjunto de datos de San Francisco Neighborhoods y, luego, visualizarás los polígonos.

1. Para insertar una celda de código, haz clic en add Código.

2. Para consultar los datos geográficos de la tabla bigquery-public-data.san_francisco_neighborhoods.boundaries en el conjunto de datos de vecindarios de San Francisco, ingresa el siguiente código. Este código usa la función mágica %%bigquery para ejecutar la consulta y mostrar los resultados en un DataFrame:

   # Query the neighborhood name and geometry from the San Francisco
   # neighborhoods dataset.
   %%bigquery df_sanfrancisco_neighborhoods --project {GCP_PROJECT_ID}
   
   SELECT
     neighborhood,
     neighborhood_geom AS geometry
   FROM
     `bigquery-public-data.san_francisco_neighborhoods.boundaries`

3. Haz clic en play_circle_filled Ejecutar celda.

   El resultado es similar a este:

   Job ID 12345-1234-5678-1234-123456789 successfully executed: 100%

4. Para insertar una celda de código, haz clic en add Código.

5. Para convertir los resultados al formato geopandas, ingresa el siguiente código:

   # Convert the query results to geopandas format.
   gdf_sanfrancisco_neighborhoods = pandas_to_geopandas(df_sanfrancisco_neighborhoods)
   gdf_sanfrancisco_neighborhoods.info()

6. Haz clic en play_circle_filled Ejecutar celda.

   Los resultados deberían verse así:

   <class 'geopandas.geodataframe.GeoDataFrame'>
   RangeIndex: 117 entries, 0 to 116
   Data columns (total 2 columns):
   #   Column        Non-Null Count  Dtype
   ---  ------        --------------  -----
   0   neighborhood  117 non-null    object
   1   geometry      117 non-null    geometry
   dtypes: geometry(1), object(1)
   memory usage: 2.0+ KB
   

7. Para obtener una vista previa de la primera fila del DataFrame, ingresa el siguiente código:

   # Preview the first row
   gdf_sanfrancisco_neighborhoods.head(1)

8. Haz clic en play_circle_filled Ejecutar celda.

   El resultado es similar a este:

   

   En los resultados, observa que los datos son un polígono.

9. Para insertar una celda de código, haz clic en add Código.

10. Para visualizar los polígonos, ingresa el siguiente código. pydeck se usa para convertir cada instancia de objeto shapely en la columna de geometría en formato GeoJSON:

    # Visualize the polygons.
    geojson_layer = pdk.Layer(
        'GeoJsonLayer',
        id="sf_neighborhoods",
        data=gdf_sanfrancisco_neighborhoods,
        get_line_color=[127, 0, 127, 255],
        get_fill_color=[60, 60, 60, 50],
        get_line_width=100,
        pickable=True,
        stroked=True,
        filled=True,
      )
    view_state = pdk.ViewState(latitude=37.77613, longitude=-122.42284, zoom=12)
    display_pydeck_map([geojson_layer], view_state)

11. Haz clic en play_circle_filled Ejecutar celda.

    El resultado es similar a este:

    

Crea un mapa de coropletas

Si exploras datos con polígonos que son difíciles de convertir al formato GeoJSON, puedes usar una capa de polígono del framework deck.gl. Una capa de polígonos puede procesar datos de entrada de tipos específicos, como un array de puntos.

En esta sección, usarás una capa de polígonos para renderizar un array de puntos y usar los resultados para renderizar un mapa de coropletas. El mapa coroplético muestra la densidad de las estaciones de bicicletas de uso compartido por vecindario uniendo los datos del conjunto de datos de vecindarios de San Francisco con el conjunto de datos de Ford GoBike Share de San Francisco.

1. Para insertar una celda de código, haz clic en add Código.

2. Para agregar y contar la cantidad de estaciones por vecindario y crear una columna polygon que contenga un array de puntos, ingresa el siguiente código:

   # Aggregate and count the number of stations per neighborhood.
   gdf_count_stations = gdf_sanfrancisco_neighborhoods.sjoin(gdf_sf_bikestations, how='left', predicate='contains')
   gdf_count_stations = gdf_count_stations.groupby(by='neighborhood')['station_id'].count().rename('num_stations')
   gdf_stations_x_neighborhood = gdf_sanfrancisco_neighborhoods.join(gdf_count_stations, on='neighborhood', how='inner')
   
   # To simulate non-GeoJSON input data, create a polygon column that contains
   # an array of points by using the pandas.Series.map method.
   gdf_stations_x_neighborhood['polygon'] = gdf_stations_x_neighborhood['geometry'].map(lambda g: list(g.exterior.coords))

3. Haz clic en play_circle_filled Ejecutar celda.

   Después de ejecutar el código, no se genera ningún resultado en tu notebook de Colab. La marca de verificación junto a la celda indica que el código se ejecutó correctamente.

4. Para insertar una celda de código, haz clic en add Código.

5. Para agregar una columna fill_color para cada uno de los polígonos, ingresa el siguiente código:

   # Create a color map gradient using the branch library, and add a fill_color
   # column for each of the polygons.
   colormap = branca.colormap.LinearColormap(
     colors=["lightblue", "darkred"],
     vmin=0,
     vmax=gdf_stations_x_neighborhood['num_stations'].max(),
   )
   gdf_stations_x_neighborhood['fill_color'] = gdf_stations_x_neighborhood['num_stations'] \
     .map(lambda c: list(colormap.rgba_bytes_tuple(c)[:3]) + [0.7 * 255])   # force opacity of 0.7

6. Haz clic en play_circle_filled Ejecutar celda.

   Después de ejecutar el código, no se genera ningún resultado en tu notebook de Colab. La marca de verificación junto a la celda indica que el código se ejecutó correctamente.

7. Para insertar una celda de código, haz clic en add Código.

8. Para renderizar la capa de polígonos, ingresa el siguiente código:

   # Render the polygon layer.
   polygon_layer = pdk.Layer(
     'PolygonLayer',
     id="bike_stations_choropleth",
     data=gdf_stations_x_neighborhood,
     get_polygon='polygon',
     get_fill_color='fill_color',
     get_line_color=[0, 0, 0, 255],
     get_line_width=50,
     pickable=True,
     stroked=True,
     filled=True,
   )
   view_state = pdk.ViewState(latitude=37.77613, longitude=-122.42284, zoom=12)
   display_pydeck_map([polygon_layer], view_state)

9. Haz clic en play_circle_filled Ejecutar celda.

   El resultado es similar a este:

   

Crea un mapa de calor

Los mapas coropléticos son útiles cuando tienes límites significativos que se conocen. Si tienes datos sin límites significativos conocidos, puedes usar una capa de mapa de calor para renderizar su densidad continua.

En el siguiente ejemplo, consultas datos en la tabla bigquery-public-data.san_francisco_sfpd_incidents.sfpd_incidents del conjunto de datos Informes del Departamento de Policía de San Francisco (SFPD). Los datos se usan para visualizar la distribución de incidentes en 2015.

En el caso de los mapas de calor, se recomienda que cuantices y agregues los datos antes de la renderización. En este ejemplo, los datos se cuantifican y se agregan con el índice espacial H3 de Carto. El mapa de calor se crea con una capa de mapa de calor del framework deck.gl.

En este ejemplo, la cuantificación se realiza con la biblioteca de Python h3 para agregar los puntos incidentes en hexágonos. La función h3.latlng_to_cell se usa para asignar la posición del incidente (latitud y longitud) a un índice de celda H3. Una resolución de H3 de nueve proporciona suficientes hexágonos agregados para el mapa de calor. La función h3.cell_to_latlng se usa para determinar el centro de cada hexagono.

1. Para insertar una celda de código, haz clic en add Código.

2. Para consultar los datos del conjunto de datos de informes del Departamento de Policía de San Francisco (SFPD), ingresa el siguiente código. En este código, se usa la función mágica %%bigquery para ejecutar la consulta y mostrar los resultados en un DataFrame:

   # Query the incident key and location  data from the SFPD reports dataset.
   %%bigquery df_sanfrancisco_incidents_2015  --project {GCP_PROJECT_ID}
   
   SELECT
     unique_key,
     location
   FROM (
     SELECT
       unique_key,
       location, # WKT string
       EXTRACT(YEAR FROM timestamp) AS year,
     FROM `bigquery-public-data.san_francisco_sfpd_incidents.sfpd_incidents` incidents
   )
   WHERE year = 2015

3. Haz clic en play_circle_filled Ejecutar celda.

   El resultado es similar a este:

   Job ID 12345-1234-5678-1234-123456789 successfully executed: 100%

4. Para insertar una celda de código, haz clic en add Código.

5. Para convertir los resultados en un DataFrame geopandas, ingresa el siguiente código:

   # Convert the results into a geopandas.GeoDataFrame.
   gdf_incidents = pandas_to_geopandas(df_sanfrancisco_incidents_2015, geometry_column='location')

6. Haz clic en play_circle_filled Ejecutar celda.

   Después de ejecutar el código, no se genera ningún resultado en tu notebook de Colab. La marca de verificación junto a la celda indica que el código se ejecutó correctamente.

7. Para insertar una celda de código, haz clic en add Código.

8. Para calcular la celda de la latitud y la longitud de cada incidente, agrega los incidentes de cada celda, construye un DataFrame geopandas y agrega el centro de cada hexágono para la capa del mapa de calor, ingresa el siguiente código:

   # Compute the cell for each incident's latitude and longitude.
   H3_RESOLUTION = 9
   gdf_incidents['h3_cell'] = df_sanfrancisco_incidents_2015['location'].apply(
       lambda location: h3.latlng_to_cell(location.y, location.x, H3_RESOLUTION)
   )
   
   # Aggregate the incidents for each hexagon cell.
   count_incidents = gdf_incidents.groupby(by='h3_cell')['unique_key'].count().rename('num_incidents')
   
   # Construct a new geopandas.GeoDataFrame with the aggregate results.
   # Add the center of each hexagon for the HeatmapLayer to render.
   gdf_incidents_x_cell = gpd.GeoDataFrame(data=count_incidents).reset_index()
   gdf_incidents_x_cell['h3_center'] = gdf_incidents_x_cell['h3_cell'].apply(h3.cell_to_latlng)
   gdf_incidents_x_cell.info()

9. Haz clic en play_circle_filled Ejecutar celda.

   El resultado es similar a este:

   <class 'geopandas.geodataframe.GeoDataFrame'>
   RangeIndex: 969 entries, 0 to 968
   Data columns (total 3 columns):
   #   Column         Non-Null Count  Dtype
   --  ------         --------------  -----
   0   h3_cell        969 non-null    object
   1   num_incidents  969 non-null    Int64
   2   h3_center      969 non-null    object
   dtypes: Int64(1), object(2)
   memory usage: 23.8+ KB
   

10. Para insertar una celda de código, haz clic en add Código.

11. Para obtener una vista previa de las primeras cinco filas del DataFrame, ingresa el siguiente código:

    # Preview the first five rows.
    gdf_incidents_x_cell.head()

12. Haz clic en play_circle_filled Ejecutar celda.

    El resultado es similar a este:

    

13. Para insertar una celda de código, haz clic en add Código.

14. Para convertir los datos en un formato JSON que pueda usar HeatmapLayer, introduce el siguiente código:

    # Convert to a JSON format recognized by the HeatmapLayer.
    def _make_heatmap_datum(row) -> dict:
      return {
          "latitude": row['h3_center'][0],
          "longitude": row['h3_center'][1],
          "weight": float(row['num_incidents']),
      }
    
    heatmap_data = gdf_incidents_x_cell.apply(_make_heatmap_datum, axis='columns').values.tolist()

15. Haz clic en play_circle_filled Ejecutar celda.

    Después de ejecutar el código, no se genera ningún resultado en tu notebook de Colab. La marca de verificación junto a la celda indica que el código se ejecutó correctamente.

16. Para insertar una celda de código, haz clic en add Código.

17. Para renderizar el mapa de calor, ingresa el siguiente código:

    # Render the heatmap.
    heatmap_layer = pdk.Layer(
      "HeatmapLayer",
      id="sfpd_heatmap",
      data=heatmap_data,
      get_position=['longitude', 'latitude'],
      get_weight='weight',
      opacity=0.7,
      radius_pixels=99,  # this limitation can introduce artifacts (see above)
      aggregation='MEAN',
    )
    view_state = pdk.ViewState(latitude=37.77613, longitude=-122.42284, zoom=12)
    display_pydeck_map([heatmap_layer], view_state)

18. Haz clic en play_circle_filled Ejecutar celda.

    El resultado es similar a este: