Visualiser des données d'analyse géospatiale à l'aide d'un notebook Colab

Créer un notebook Colab

Ce tutoriel crée un notebook Colab pour visualiser les données d'analyse géospatiale. Vous pouvez ouvrir une version prédéfinie du notebook dans Colab, Colab Enterprise ou BigQuery Studio en cliquant sur les liens en haut de la version GitHub du tutoriel : Visualisation géospatiale BigQuery dans Colab.

1. Ouvrez Colab.

   Ouvrir Colab

2. Dans la boîte de dialogue Ouvrir le notebook, cliquez sur Nouveau notebook.

3. Cliquez sur Untitled0.ipynb et remplacez le nom du notebook par bigquery-geo.ipynb.

4. Sélectionnez Fichier > Enregistrer.

S'authentifier avec Google Cloud et Google Maps

Ce tutoriel interroge des ensembles de données BigQuery et utilise l'API JavaScript de Google Maps. Pour utiliser ces ressources, vous devez authentifier l'environnement d'exécution Colab avec Google Cloud et l'API Google Maps.

S'authentifier avec Google Cloud

1. Pour insérer une cellule de code, cliquez sur add Code.

2. Pour vous authentifier auprès de votre projet, saisissez le code suivant :

   # 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)
   
   # Set GMP_API_KEY to none
   GMP_API_KEY = None

   Remplacez PROJECT_ID par l'ID du projet.

3. Cliquez sur play_circle_filled Exécuter la cellule.

4. Si vous y êtes invité, cliquez sur Autoriser pour autoriser Colab à accéder à vos identifiants, si vous êtes d'accord.

5. Sur la page Se connecter avec Google, sélectionnez votre compte.

6. Sur la page Se connecter au code du notebook créé par un tiers, cliquez sur Continuer.

7. Sur la page Sélectionnez ce à quoi le code de notebook créé par un tiers peut accéder, cliquez sur Tout sélectionner, puis sur Continuer.

   Une fois le flux d'autorisation terminé, aucune sortie n'est générée dans votre notebook Colab. La coche à côté de la cellule indique que le code a été exécuté correctement.

Facultatif : S'authentifier avec Google Maps

Si vous utilisez Google Maps Platform comme fournisseur de cartes de base, vous devez fournir une clé API Google Maps Platform. Le notebook récupère la clé de vos secrets Colab.

Cette étape n'est nécessaire que si vous utilisez l'API Google Maps. Si vous ne vous authentifiez pas auprès de Google Maps Platform, pydeck utilise la carte carto à la place.

1. Obtenez votre clé API Google Maps en suivant les instructions de la page Utiliser des clés API dans la documentation Google Maps.

2. Accédez à votre notebook Colab, puis cliquez sur vpn_key Secrets.

3. Cliquez sur Ajouter un secret.

4. Dans le champ Nom, saisissez GMP_API_KEY.

5. Dans le champ Valeur, saisissez la valeur de la clé API Google Maps que vous avez générée précédemment.

6. Fermez le panneau Secrets.

7. Pour insérer une cellule de code, cliquez sur add Code.

8. Pour vous authentifier auprès de lAPI Google Maps, saisissez le code suivant :

   # 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. Lorsque vous y êtes invité, cliquez sur Accorder l'accès pour autoriser le notebook à accéder à votre clé, si vous êtes d'accord.

10. Cliquez sur play_circle_filled Exécuter la cellule.

    Une fois le flux d'autorisation terminé, aucune sortie n'est générée dans votre notebook Colab. La coche à côté de la cellule indique que le code a été exécuté correctement.

Installer les packages Python et importer les bibliothèques de science des données

En plus des modules Python colabtools (google.colab), ce tutoriel utilise plusieurs autres packages Python et bibliothèques de science des données.

Dans cette section, vous allez installer les packages pydeck et h3. pydeck fournit un rendu spatial à grande échelle en Python, optimisé par deck.gl. h3-py fournit le système d'indexation géospatiale hiérarchique hexagonale H3 d'Uber en Python.

Vous importez ensuite les bibliothèques h3 et pydeck, ainsi que les bibliothèques géospatiales Python suivantes :

• geopandas pour étendre les types de données utilisés par pandas afin d'autoriser les opérations spatiales sur les types géométriques.
• shapely pour la manipulation et l'analyse d'objets géométriques planaires individuels.
• branca pour générer des cartes de couleurs HTML et JavaScript.
• geemap.deck pour la visualisation avec pydeck et earthengine-api.

Après avoir importé les bibliothèques, vous activez les tableaux interactifs pour les DataFrames pandas dans Colab.

Installez les packages pydeck et h3.

1. Pour insérer une cellule de code, cliquez sur add Code.

2. Pour installer les packages pydeck et h3, saisissez le code suivant :

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

3. Cliquez sur play_circle_filled Exécuter la cellule.

   Une fois l'installation terminée, aucun résultat n'est généré dans votre notebook Colab. La coche à côté de la cellule indique que le code a été exécuté correctement.

Importer les bibliothèques Python

1. Pour insérer une cellule de code, cliquez sur add Code.

2. Pour importer les bibliothèques Python, saisissez le code suivant :

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

3. Cliquez sur play_circle_filled Exécuter la cellule.

   Une fois le code exécuté, aucune sortie n'est générée dans votre notebook Colab. La coche à côté de la cellule indique que le code s'est exécuté correctement.

Activer les tableaux interactifs pour les DataFrames pandas

1. Pour insérer une cellule de code, cliquez sur add Code.

2. Pour activer les DataFrames pandas, saisissez le code suivant :

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

3. Cliquez sur play_circle_filled Exécuter la cellule.

   Une fois le code exécuté, aucune sortie n'est générée dans votre notebook Colab. La coche à côté de la cellule indique que le code s'est exécuté correctement.

Créer une routine partagée

Dans cette section, vous allez créer une routine partagée qui affiche des calques sur une carte de base.

1. Pour insérer une cellule de code, cliquez sur add Code.

2. Pour créer une routine partagée pour afficher des calques sur une carte, saisissez le code suivant :

   # 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. Cliquez sur play_circle_filled Exécuter la cellule.

   Une fois le code exécuté, aucune sortie n'est générée dans votre notebook Colab. La coche à côté de la cellule indique que le code s'est exécuté correctement.

Créer un graphique à nuage de points

Dans cette section, vous allez créer un graphique en nuage de points de toutes les stations de vélos en libre-service de l'ensemble de données public San Francisco Ford GoBike Share en récupérant les données de la table bigquery-public-data.san_francisco_bikeshare.bikeshare_station_info. Le graphique en nuage de points est créé à l'aide d'un calque et d'un calque de nuage de points du framework deck.gl.

Les graphiques de dispersion sont utiles lorsque vous devez examiner un sous-ensemble de points individuels (également appelés vérification ponctuelle).

L'exemple suivant montre comment utiliser un calque et un calque de nuage de points pour afficher des points individuels sous forme de cercles.

1. Pour insérer une cellule de code, cliquez sur add Code.

2. Pour interroger l'ensemble de données public San Francisco Ford GoBike Share, saisissez le code suivant. Ce code utilise la fonction magique %%bigquery pour exécuter la requête et renvoyer les résultats dans 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 gdf_sf_bikestations --project {GCP_PROJECT_ID} --use_geodataframe station_geom
   
   SELECT
     station_id,
     name,
     short_name,
     station_geom
   FROM
     `bigquery-public-data.san_francisco_bikeshare.bikeshare_station_info`

3. Cliquez sur play_circle_filled Exécuter la cellule.

   Le résultat ressemble à ce qui suit :

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

4. Pour insérer une cellule de code, cliquez sur add Code.

5. Pour obtenir un récapitulatif du DataFrame, y compris les colonnes et les types de données, saisissez le code suivant :

   # Get a summary of the DataFrame
   gdf_sf_bikestations.info()

6. Cliquez sur play_circle_filled Exécuter la cellule.

   Le résultat doit se présenter sous la forme suivante :

   <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. Pour insérer une cellule de code, cliquez sur add Code.

8. Pour prévisualiser les cinq premières lignes du DataFrame, saisissez le code suivant :

   # Preview the first five rows
   gdf_sf_bikestations.head()

9. Cliquez sur play_circle_filled Exécuter la cellule.

   Le résultat ressemble à ce qui suit :

   

Pour afficher les points, vous devez extraire la longitude et la latitude sous forme de coordonnées x et y à partir de la colonne station_geom de l'ensemble de données sur les vélos en libre-service.

Étant donné que gdf_sf_bikestations est un geopandas.GeoDataFrame, les coordonnées sont accessibles directement à partir de sa colonne de géométrie station_geom. Vous pouvez récupérer la longitude à l'aide de l'attribut .x de la colonne et la latitude à l'aide de son attribut .y. Vous pouvez ensuite les stocker dans de nouvelles colonnes de longitude et de latitude.

1. Pour insérer une cellule de code, cliquez sur add Code.

2. Pour extraire les valeurs de longitude et de latitude de la colonne station_geom, saisissez le code suivant :

   # 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

3. Cliquez sur play_circle_filled Exécuter la cellule.

   Une fois le code exécuté, aucune sortie n'est générée dans votre notebook Colab. La coche à côté de la cellule indique que le code s'est exécuté correctement.

4. Pour insérer une cellule de code, cliquez sur add Code.

5. Pour afficher le graphique en nuage de points des stations de vélos en libre-service en fonction des valeurs de longitude et de latitude que vous avez extraites précédemment, saisissez le code suivant :

   # 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)

6. Cliquez sur play_circle_filled Exécuter la cellule.

   Le résultat ressemble à ce qui suit :

   

Visualiser des polygones

Les analyses géospatiales vous permettent d'analyser et de visualiser des données géospatiales dans BigQuery en utilisant des types de données GEOGRAPHY et des fonctions de géographie GoogleSQL.

Dans l'analyse géospatiale, le type de données GEOGRAPHY est un ensemble de points, de polylignes et de polygones, représenté sous la forme d'un jeu de points ou d'un sous-ensemble de la surface de la Terre. Un type GEOGRAPHY peut contenir des objets tels que les suivants :

• Points
• Lignes
• Polygones
• Multipolygones

Pour obtenir la liste de tous les objets acceptés, consultez la documentation sur le type GEOGRAPHY.

Si vous recevez des données géospatiales sans connaître les formes attendues, vous pouvez les visualiser pour les découvrir. Vous pouvez visualiser des formes en convertissant les données géographiques au format GeoJSON. Vous pouvez ensuite visualiser les données GeoJSON à l'aide d'une couche GeoJSON du framework deck.gl.

Dans cette section, vous allez interroger des données géographiques dans l'ensemble de données "Quartiers de San Francisco", puis visualiser les polygones.

1. Pour insérer une cellule de code, cliquez sur add Code.

2. Pour interroger les données géographiques de la table bigquery-public-data.san_francisco_neighborhoods.boundaries dans l'ensemble de données "Quartiers de San Francisco", saisissez le code suivant. Ce code utilise la fonction magique %%bigquery pour exécuter la requête et renvoyer les résultats dans un DataFrame :

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

3. Cliquez sur play_circle_filled Exécuter la cellule.

   Le résultat ressemble à ce qui suit :

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

4. Pour insérer une cellule de code, cliquez sur add Code.

5. Pour obtenir un récapitulatif de DataFrame, saisissez le code suivant :

   # Get a summary of the DataFrame
   gdf_sanfrancisco_neighborhoods.info()

6. Cliquez sur play_circle_filled Exécuter la cellule.

   Les résultats doivent se présenter sous la forme suivante :

   <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. Pour prévisualiser la première ligne du DataFrame, saisissez le code suivant :

   # Preview the first row
   gdf_sanfrancisco_neighborhoods.head(1)

8. Cliquez sur play_circle_filled Exécuter la cellule.

   Le résultat ressemble à ce qui suit :

   

   Dans les résultats, notez que les données sont un polygone.

9. Pour insérer une cellule de code, cliquez sur add Code.

10. Pour visualiser les polygones, saisissez le code suivant. pydeck est utilisé pour convertir chaque instance d'objet shapely de la colonne de géométrie au format 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. Cliquez sur play_circle_filled Exécuter la cellule.

    Le résultat ressemble à ce qui suit :

    

Créer une carte choroplèthe

Si vous explorez des données avec des polygones difficiles à convertir au format GeoJSON, vous pouvez utiliser une couche de polygones du framework deck.gl à la place. Une couche de polygones peut traiter des données d'entrée de types spécifiques, comme un tableau de points.

Dans cette section, vous allez utiliser un calque de polygones pour afficher un tableau de points et utiliser les résultats pour afficher une carte choroplèthe. La carte choroplèthe montre la densité des stations de vélos en libre-service par quartier en associant les données de l'ensemble de données "San Francisco Neighborhoods" à celles de l'ensemble de données "San Francisco Ford GoBike Share".

1. Pour insérer une cellule de code, cliquez sur add Code.

2. Pour agréger et comptabiliser le nombre de stations par quartier, et pour créer une colonne polygon contenant un tableau de points, saisissez le code suivant :

   # 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. Cliquez sur play_circle_filled Exécuter la cellule.

   Une fois le code exécuté, aucune sortie n'est générée dans votre notebook Colab. La coche à côté de la cellule indique que le code s'est exécuté correctement.

4. Pour insérer une cellule de code, cliquez sur add Code.

5. Pour ajouter une colonne fill_color pour chacun des polygones, saisissez le code suivant :

   # 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. Cliquez sur play_circle_filled Exécuter la cellule.

   Une fois le code exécuté, aucune sortie n'est générée dans votre notebook Colab. La coche à côté de la cellule indique que le code s'est exécuté correctement.

7. Pour insérer une cellule de code, cliquez sur add Code.

8. Pour afficher le calque de polygones, saisissez le code suivant :

   # 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. Cliquez sur play_circle_filled Exécuter la cellule.

   Le résultat ressemble à ce qui suit :

   

Créer une carte de densité

Les cartes choroplèthes sont utiles lorsque vous disposez de limites connues et pertinentes. Si vos données n'ont pas de limites significatives connues, vous pouvez utiliser un calque de carte de densité pour afficher leur densité continue.

Dans l'exemple suivant, vous interrogez les données de la table bigquery-public-data.san_francisco_sfpd_incidents.sfpd_incidents dans l'ensemble de données "San Francisco Police Department (SFPD) Reports" (Rapports du service de police de San Francisco). Les données sont utilisées pour visualiser la répartition des incidents en 2015.

Pour les cartes de densité, il est recommandé de quantifier et d'agréger les données avant le rendu. Dans cet exemple, les données sont quantifiées et agrégées à l'aide de l'indexation spatiale H3 de Carto. La carte de densité est créée à l'aide d'un calque de carte de densité du framework deck.gl.

Dans cet exemple, la quantification est effectuée à l'aide de la bibliothèque Python h3 pour agréger les points d'incident en hexagones. La fonction h3.latlng_to_cell est utilisée pour mapper la position (latitude et longitude) de l'incident à un index de cellule H3. Une résolution 9 de H3 fournit suffisamment d'hexagones agrégés pour la carte thermique. La fonction h3.cell_to_latlng permet de déterminer le centre de chaque hexagone.

1. Pour insérer une cellule de code, cliquez sur add Code.

2. Pour interroger les données de l'ensemble de données "Rapports du service de police de San Francisco (SFPD)", saisissez le code suivant. Ce code utilise la fonction magique %%bigquery pour exécuter la requête et renvoyer les résultats dans un DataFrame :

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

3. Cliquez sur play_circle_filled Exécuter la cellule.

   Le résultat ressemble à ce qui suit :

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

4. Pour insérer une cellule de code, cliquez sur add Code.

5. Pour calculer la cellule pour la latitude et la longitude de chaque incident, agrégez les incidents pour chaque cellule, construisez un DataFrame geopandas et ajoutez le centre de chaque hexagone pour la couche de carte de densité. Saisissez le code suivant :

   # Compute the cell for each incident's latitude and longitude.
   H3_RESOLUTION = 9
   gdf_incidents['h3_cell'] = gdf_incidents.geometry.apply(
       lambda geom: h3.latlng_to_cell(geom.y, geom.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()

6. Cliquez sur play_circle_filled Exécuter la cellule.

   Le résultat ressemble à ce qui suit :

   <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
   

7. Pour insérer une cellule de code, cliquez sur add Code.

8. Pour prévisualiser les cinq premières lignes du DataFrame, saisissez le code suivant :

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

9. Cliquez sur play_circle_filled Exécuter la cellule.

   Le résultat ressemble à ce qui suit :

   

10. Pour insérer une cellule de code, cliquez sur add Code.

11. Pour convertir les données au format JSON utilisable par HeatmapLayer, saisissez le code suivant :

    # 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()

12. Cliquez sur play_circle_filled Exécuter la cellule.

    Une fois le code exécuté, aucune sortie n'est générée dans votre notebook Colab. La coche à côté de la cellule indique que le code s'est exécuté correctement.

13. Pour insérer une cellule de code, cliquez sur add Code.

14. Pour afficher la carte de densité, saisissez le code suivant :

    # 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)

15. Cliquez sur play_circle_filled Exécuter la cellule.

    Le résultat ressemble à ce qui suit :