Tutoriel : Analyser les données de voyage à l’aide de Snap to Roads dans un notebook Microsoft Fabric

Snap to Roads est un service Azure Maps qui traite un ensemble de points GPS collectés le long d’un itinéraire et les aligne sur les routes les plus probables parcourues par le véhicule. Cette fonctionnalité est utile pour déterminer le chemin exact suivi par un véhicule, même lorsque les données GPS collectées sont légèrement imprécises.

Ce tutoriel explique comment utiliser l’API Snap to Roads Azure Maps avec Microsoft Fabric pour analyser les données GPS provenant de ressources mobiles, même lorsque ces données sont imprécises ou incomplètes en raison d’une perte de signal. Il vous guide tout au long des appels à l’API Snap to Roads d’Azure Maps à partir d’un notebook Microsoft Fabric afin d’aligner les points GPS sur la route la plus proche, de remplir les points manquants à l’aide de points de données interpolés, et de les améliorer avec des attributs supplémentaires tels que les noms des routes et les limites de vitesse.

Ce didacticiel présente les procédures suivantes :

Créer un lakehouse Microsoft Fabric et y importer les données GPS brutes d’un véhicule.
Créer un notebook Microsoft Fabric qui prend des données GPS brutes et retourne les informations de coordonnées alignées demandées à l’aide de l’API Snap to Roads d’Azure Maps.
Créer un eventhouse et une base de données KQL, et y importer les données GPS alignées.
Créer un tableau de bord en temps réel à l’aide des données GPS alignées dans la base de données Kusto.
Interroger les données KQL et afficher les données GPS alignées dans un visuel de carte.

Prérequis

Compte Azure Maps
Clé d’abonnement
Un compte Microsoft Fabric
Compréhension de base de Microsoft Fabric

Remarque

Pour plus d’informations sur l’authentification dans Azure Maps, voir Gérer l’authentification dans Azure Maps.

Créer un notebook et un lakehouse Microsoft Fabric

Effectuez ces étapes pour créer un notebook Microsoft Fabric :

Accédez à Mon espace de travail et sélectionnez Nouvel élément.
Lorsque l’écran Nouvel élément s’affiche, faites défiler vers le bas et sélectionnez Notebook.
Sur l’écran Explorateur du notebook, sélectionnez la flèche Lakehouses>.
Cliquez sur le bouton Ajouter.
Dans la boîte de dialogue Ajouter un lakehouse, sélectionnez Nouveau Lakehouse, puis le bouton Ajouter.
Dans la boîte de dialogue Nouveau lakehouse, entrez le nom «Azure_Maps_Data», puis sélectionnez le bouton Créer .

Ajouter un fichier de données au lakehouse

Snap to Roads prend des données de points GPS (lat, lon) et retourne une liste d’objets qui forment un itinéraire aligné sur les routes sur une carte. Un fichier de données contenant les données GPS requises peut être ajouté en tant que fichier au lakehouse, et référencé par le code Python dans votre notebook.

Télécharger le fichier de données

Téléchargez les exemples de données (mockData_20240919.csv) à partir de GitHub vers votre appareil de stockage local, afin de les charger dans le lakehouse dans la section suivante. Ce fichier contient un tableau de coordonnées GPS que le service Snap to Roads modifie selon les besoins pour s’assurer que chaque coordonnée pointe vers une route valide.

Ouvrez le fichier mockData_20240919.csv dans GitHub.
Sélectionnez le bouton Télécharger le fichier brut dans le coin supérieur droit de l’écran et enregistrez le fichier localement.

Charger le fichier de données dans le lakehouse

Les étapes suivantes expliquent comment ajouter une source de données au lakehouse.

Dans le dossier Fichiers du lakehouse, sélectionnez Charger > Charger des fichiers.
Affichez la boîte de dialogue d’ouverture de fichier en sélectionnant l’icône de dossier. Sélectionnez le fichier mockData_20240919.csv que vous avez téléchargé dans la section précédente, puis le bouton Ouvrir. Une fois que la boîte de dialogue d’ouverture de fichier s’est fermée et que le nom de fichier correct apparaît dans le contrôle Charger des fichiers, sélectionnez le bouton Charger pour charger le fichier dans le lakehouse.

Ajouter du code au notebook

Vous devez ajouter et exécuter quatre cellules de code dans votre notebook pour exécuter le scénario Snap to Roads. Les sections suivantes vous guident tout au long de ce processus.

Installer des packages

Vous devez d’abord charger les packages requis :

!pip install geopandas
!pip install geojson

Entrez les instructions pip install dans la première cellule de votre notebook, puis exécutez les instructions en sélectionnant la flèche d’exécution.

Charger les données

Ensuite, chargez les exemples de données que vous avez précédemment chargés dans votre lakehouse.

Placez le pointeur juste en dessous de la cellule utilisée pour installer les packages. Des options s’affichent pour ajouter du code ou du markdown. Sélectionnez Code pour ajouter une autre cellule de code à votre notebook.

Une fois la nouvelle cellule créée, ajoutez le code suivant.

import geopandas as gpd
import pandas as pd

lakehouseFilePath = "/lakehouse/default/Files/"

mockdata_df = gpd.read_file(lakehouseFilePath + "mockData_20240919.csv")
mockdata_df = gpd.GeoDataFrame(
    mockdata_df, geometry=gpd.points_from_xy(mockdata_df.longitude, mockdata_df.latitude), crs="EPSG:4326"
)

mockdata_df.head()

mockdata_df.tripID.unique()

Exécutez le code en sélectionnant la flèche d’exécution. Cela charge vos exemples de données.

Améliorer avec Snap to Roads

Le code de cette cellule de notebook lit les données GPS brutes du fichier de données dans le lakehouse, et les transmet à l’API Snap to Roads d’Azure Maps. Avec l’interpolation activée, l’API ajoute des points entre les localisations GPS pour compléter l’itinéraire le long de la route. Elle fournit également des attributs tels que les noms de routes et les limites de vitesse lorsqu’ils sont disponibles.

Placez le pointeur juste en dessous de la cellule utilisée pour installer les packages à l’étape précédente. Des options s’affichent pour ajouter du code ou du markdown. Sélectionnez Code pour ajouter une autre cellule de code à votre notebook.

Une fois la nouvelle cellule créée, ajoutez le code suivant. Veillez à ajouter votre clé d’abonnement.

import requests
import json

az_maps_subkey = ""
az_maps_snaproads_url = "https://atlas.microsoft.com/route/snapToRoads?api-version=2025-01-01&subscription-key=" + az_maps_subkey

# Function to process snap to road for each given trip
def process_route(df, outputFilePath):
    # List to store successful responses
    successful_responses = []

    # Function to send a chunk of features
    def send_chunk_snaproads(chunk):
        geojson_data = chunk.to_json()
        # Convert the JSON string to a Python dictionary
        geojson_dict = json.loads(geojson_data)

        # Add the new fields at the end of the dictionary
        geojson_dict['includeSpeedLimit'] = True
        geojson_dict['interpolate'] = True
        geojson_dict['travelMode'] = "driving"

        # Convert the dictionary back to a JSON string
        updated_geojson_data = json.dumps(geojson_dict)

        response = requests.post(
        az_maps_snaproads_url, 
        headers={'Content-Type': 'application/json'}, 
        data=updated_geojson_data
        )

        if response.status_code == 200:
            print('Chunk request was successful...')
            successful_responses.append(response.json())
        else:
            print(f'Failed to send request. Status code: {response.status_code}')
            print('Response body:', response.text)

    # Loop over the GeoDataFrame in chunks of 100
    chunk_size = 100
    for start in range(0, len(df), chunk_size):
        end = start + chunk_size
        chunk = df.iloc[start:end]
        send_chunk_snaproads(chunk)

    # Extract features with geometry from successful responses
    features_with_geometry = []
    for response in successful_responses:
        if 'features' in response:
            for feature in response['features']:
                if 'geometry' in feature:
                    longitude = feature['geometry']['coordinates'][0]
                    latitude = feature['geometry']['coordinates'][1]
                    feature['properties']['latitude'] = latitude
                    feature['properties']['longitude'] = longitude
                    features_with_geometry.append(feature)

    # Convert the list of features with geometry to a GeoDataFrame
    if features_with_geometry:
        responses_gdf = gpd.GeoDataFrame.from_features(features_with_geometry)

        # Write successful responses to a cvs file
        #responses_gdf.to_file(outputFilePath, driver='GeoJSON')
        responses_gdf.to_csv(outputFilePath, encoding='utf-8', index=False)

        print(f'Successful responses written to {outputFilePath}')
    else:
        print('No valid features with geometry found in the responses.')

Exécutez le code en sélectionnant la flèche d’exécution.

Créer un fichier avec des données améliorées

Le code suivant prend la sortie créée dans la cellule de code précédente et crée un fichier CSV dans le lakehouse nommé SnapRoadResponses.csv. Ce nouveau fichier de données contient des coordonnées GPS mises à jour qui sont alignées avec la route appropriée. Il inclut également les noms de rues et les limites de vitesse lorsqu’ils sont disponibles. SnapRoadResponses.csv sera importé dans un eventhouse et utilisé pour créer un visuel de carte plus loin dans ce tutoriel.

Placez le pointeur juste en dessous de la cellule utilisée pour améliorer avec Snap to Roads à l’étape précédente. Des options s’affichent pour ajouter du code ou du markdown. Sélectionnez Code pour ajouter une autre cellule de code à votre notebook.

Une fois la nouvelle cellule créée, ajoutez le code suivant.

lakehouseFilePath = "/lakehouse/default/Files/"
#execute snap to road
outputFilePath = lakehouseFilePath + "SnapRoadResponses" + ".csv"
df = mockdata_df.sort_values(by='timeStamp').reset_index(drop=True)
process_route(df, outputFilePath)

Exécutez le code en sélectionnant la flèche d’exécution. Cela enregistre SnapRoadResponses.csv avec les coordonnées GPS mises à jour dans le lakehouse.

Conseil

Si le nouveau fichier n’apparaît pas après l’exécution du code du notebook, vous devrez peut-être actualiser votre navigateur.

Copier le chemin d’accès au fichier

Le chemin d’accès ABFS à SnapRoadResponses.csv est requis plus loin dans ce tutoriel lorsque vous créez l’eventhouse. Pour obtenir le chemin d’accès ABFS à ce fichier, sélectionnez les points de suspension (...) en regard du fichier puis, dans le menu contextuel, sélectionnez Copier le chemin d’accès ABFS. Une fois le chemin d’accès copié, enregistrez-le pour une utilisation ultérieure.

Créer un eventhouse et établir un lien vers des données dans le lakehouse

Créez un eventhouse pour gérer les données de télémétrie de votre flotte ou déplacer des ressources. Une base de données KQL est créée automatiquement par défaut. Dans ce tutoriel, vous allez importer les données alignées du lakehouse dans la base de données KQL. Pour l’analytique en temps réel, ajoutez des données de streaming. Une fois les données chargées, vous pouvez interroger vos données à l’aide du langage de requête Kusto dans un ensemble de requêtes KQL.

Accédez à Mon espace de travail et sélectionnez Nouvel élément.
Lorsque l’écran Nouvel élément s’affiche, faites défiler vers le bas et sélectionnez Eventhouse.
Sur l’écran Nouvel eventhouse, entrez un nom pour votre nouvel eventhouse, tel que SnapToRoadDemo.

Ensuite, liez le lakehouse que vous avez créé à votre nouvel eventhouse.
Sélectionnez les points de suspension en regard de votre nouvel eventhouse, puis Obtenir des données > OneLake dans le menu contextuel.
Sélectionnez Nouvelle table, nommez-la GPSData, puis sélectionnez Suivant.
Entrez le chemin d’accès ABFS au fichier de données Lakehouse (SnapRoadResponses.csv) dans le contrôle Fichier OneLake que vous avez enregistré précédemment, puis sélectionnez le signe plus (+) pour l’ajouter à la liste.
Cliquez sur Suivant.
Après avoir vérifié les données sur l’écran Inspecter les données, sélectionnez Terminer.
Sélectionnez Fermer pour fermer la page Résumé.

L’eventhouse doit maintenant être créé et contenir les données GPS.

Créer un tableau de bord en temps réel

Vous pouvez créer un tableau de bord en temps réel pour vous connecter à votre jeu de données dans l’eventhouse. L’entrée de ce tutoriel est constituée de données statiques, et non d’un flux en temps réel, mais les vignettes du tableau de bord, telles que Visuel Azure Maps, peuvent être utilisées pour la représentation visuelle et l’analytique.

Ajouter une source de données

Accédez à Mon espace de travail et sélectionnez Nouvel élément.
Lorsque l’écran Nouvel élément s’affiche, recherchez ou faites défiler vers le bas et sélectionnez Tableau de bord en temps réel.
Sur l’écran Nouveau tableau de bord en temps réel, entrez le nom SnapToRoadDashboard, puis sélectionnez Créer.
Sur l’écran Nouveau tableau de bord en temps réel, sélectionnez Nouvelle source de données.
Sélectionnez le bouton Ajouter, puis Hub de données OneLake.
Sélectionnez votre source de données, puis Se connecter.
Entrez un Nom d’affichage, puis sélectionnez Ajouter.
Fermez le panneau Sources de données.

Maintenant que vous avez ajouté la source de données pour votre tableau de bord en temps réel, vous pouvez ajouter une requête et un visuel cartographique.

Ajouter une requête et un visuel de carte

Sélectionnez Ajouter une vignette.
Entrez GPSData dans la requête, puis sélectionnez Exécuter. Une fois que vous avez vérifié que la requête fonctionne, sélectionnez Ajouter un visuel.
Dans le panneau Mise en forme visuelle, sélectionnez Carte dans la liste déroulante Type de visuel.
Ensuite, définissez vos valeurs dans la section Données :

Paramètre de données valeur

Définir par localisation Latitude et longitude

Colonne de latitude Latitude (réelle)

Colonne de longitude Longitude (réelle)
Mettez à jour la carte d’informations cartographiques en sélectionnant une valeur dans la liste déroulante Colonne d’étiquette. Sélectionnez SpeedLimitInKilometersPerHour.
Sélectionnez Appliquer les changements

Paramètre de données	valeur
Définir par localisation	Latitude et longitude
Colonne de latitude	Latitude (réelle)
Colonne de longitude	Longitude (réelle)

Votre visuel de carte s’affiche. Vous pouvez sélectionner n’importe quel point sur la carte pour obtenir les coordonnées et la limite de vitesse en kilomètres par heure pour cette localisation.

Étapes suivantes

Pour en savoir plus sur les notebooks Microsoft Fabric :

Utilisation des notebooks Microsoft Fabric

Ce tutoriel a créé un tableau de bord pour l’analyse des itinéraires post-trajet. Pour obtenir un guide pas à pas expliquant comment créer des tableaux de bord en temps réel dans Microsoft Fabric :

Real-Time Intelligence

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2024-11-20