Utilisation de tables dans Azure Machine Learning

S’APPLIQUE À :Extension Azure CLI v2 (actuelle)Kit de développement logiciel (SDK) Python azure-ai-ml v2 (version actuelle)

Azure Machine Learning prend en charge un type Table (mltable). Vous pouvez ainsi créer un blueprint qui définit comment charger des fichiers de données en mémoire en tant que dataframe Pandas ou Spark. Dans cet article, vous apprenez :

Prérequis

• Un abonnement Azure. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer. Essayer la version gratuite ou payante d’Azure Machine Learning

• Le kit de développement logiciel (SDK) Azure Machine Learning pour Python

• Un espace de travail Azure Machine Learning

pip install -U mltable azureml-dataprep[pandas]

Cloner le référentiel d’exemples

Les extraits de code de cet article sont basés sur des exemples dans le référentiel GitHub d’exemples Azure Machine Learning. Pour cloner le référentiel dans votre environnement de développement, utilisez la commande suivante :

git clone --depth 1 https://github.com/Azure/azureml-examples

Vous trouverez des exemples relatifs aux tables Azure Machine Learning dans ce dossier du dépôt cloné :

cd azureml-examples/sdk/python/using-mltable

Introduction

Les tables Azure Machine Learning (mltable) vous permettent de définir la façon dont vous souhaitez charger vos fichiers de données en mémoire, en tant que dataframe Pandas et/ou Spark. Les tables ont deux caractéristiques principales :

1. Le fichier MLTable. Un fichier YAML qui définit le blueprint de chargement de données. Dans le fichier MLTable, vous pouvez spécifier :
   • Le ou les emplacements de stockage des données : locaux, dans le cloud ou sur un serveur HTTP(S) public.
   • Des modèles d’utilisation de caractères génériques (globbing) sur le stockage cloud. Ces emplacements peuvent spécifier des ensembles de noms de fichiers avec des caractères génériques (*).
   • Transformation de lecture : par exemple, le type de format de fichier (texte délimité, Parquet, Delta, json), les délimiteurs, les en-têtes, etc.
   • Conversions de type de colonne (pour appliquer un schéma).
   • Création de nouvelles colonnes en utilisant des informations sur la structure de dossiers : par exemple, créez une colonne year et month en utilisant la structure de dossiers {year}/{month} dans le chemin.
   • Des sous-ensembles de données à charger : par exemple, filtrer des lignes, conserver/supprimer des colonnes, prendre des échantillons aléatoires.
2. Un moteur rapide et efficace pour charger les données dans un dataframe Pandas ou Spark, selon le blueprint défini dans le fichier MLTable. Le moteur s’appuie sur Rust pour une vitesse élevée et une efficacité de la mémoire.

Les tables Azure Machine Learning sont utiles dans ces scénarios :

• Vous devez utiliser des caractères génériques (glob) à des emplacements de stockage.
• Vous devez créer une table à l’aide de données provenant de différents emplacements de stockage (par exemple, différents conteneurs d’objets blob).
• Le chemin contient les informations pertinentes à capturer dans vos données (par exemple, la date et l’heure).
• Le schéma de données change fréquemment.
• Vous souhaitez une reproductibilité facile de vos étapes de chargement des données.
• Vous avez uniquement besoin d’un sous-ensemble de données volumineuses.
• Vos données contiennent des emplacements de stockage à transmettre en continu dans votre session Python. Par exemple, vous souhaitez transmettre en continu path dans la structure de lignes JSON suivante : [{"path": "abfss://fs@account.dfs.core.windows.net/my-images/cats/001.jpg", "label":"cat"}].
• Vous souhaitez entraîner des modèles ML à l’aide d’Azure Machine Learning AutoML.

Démarrage rapide des tables Azure Machine Learning

Dans ce guide de démarrage rapide, vous créez une table (mltable) des données de la compagnie NYC Green Taxi à partir d’Azure Open Datasets. Les données sont au format Parquet et couvrent la période 2008-2021. Sur un compte de stockage d’objets blob accessible au public, les fichiers de données ont cette structure de dossiers :

/
└── green
    ├── puYear=2008
    │   ├── puMonth=1
    │   │   ├── _committed_2983805876188002631
    │   │   └── part-XXX.snappy.parquet
    │   ├── ...
    │   └── puMonth=12
    │       ├── _committed_2983805876188002631
    │       └── part-XXX.snappy.parquet
    ├── ...
    └── puYear=2021
        ├── puMonth=1
        │   ├── _committed_2983805876188002631
        │   └── part-XXX.snappy.parquet
        ├── ...
        └── puMonth=12
            ├── _committed_2983805876188002631
            └── part-XXX.snappy.parquet

Avec ces données, vous devez charger les éléments suivants dans un DataFrame Pandas :

• Uniquement les fichiers Parquet pour la période 2015-2019
• Un échantillon aléatoire des données
• Uniquement les lignes dont la distance d’extraction est supérieure à 0
• Les colonnes pertinentes pour Machine Learning
• Les nouvelles colonnes – année et mois – à l’aide des informations de chemin (puYear=X/puMonth=Y)

Le code Pandas gère ce chargement. Toutefois, la reproductibilité devient difficile, car vous devez :

• Partager du code, ce qui signifie que si le schéma change (par exemple, un changement de nom de colonne), tous les utilisateurs doivent mettre à jour leur code
• Écrire un pipeline ETL, qui a une surcharge importante

Les tables Azure Machine Learning fournissent un mécanisme léger pour sérialiser (enregistrer) les étapes de chargement des données dans un fichier MLTable. Ensuite, vous et les membres de votre équipe pouvez reproduire le DataFrame Pandas. Si le schéma change, vous mettez uniquement à jour le fichier MLTable, au lieu d’effectuer des mises à jour dans de nombreux endroits qui impliquent le code de chargement de données Python.

Cloner le notebook de démarrage rapide ou créer un notebook/script

Si vous utilisez une instance de calcul Azure Machine Learning, créez un notebook. Si vous utilisez un environnement de développement intégré (IDE), vous devez créer un script Python.

En outre, le notebook de démarrage rapide est disponible dans le référentiel GitHub d’exemples Azure Machine Learning. Utilisez le code ci-dessous pour cloner le notebook et y accéder :

git clone --depth 1 https://github.com/Azure/azureml-examples
cd azureml-examples/sdk/python/using-mltable/quickstart

Installer le Kit de développement logiciel (SDK) Python mltable

Pour charger les données de la compagnie NYC Green Taxi dans une table Azure Machine Learning, vous devez installer le Kit de développement logiciel (SDK) Python mltable et pandas dans votre environnement Python, à l’aide de la commande ci-dessous :

pip install -U mltable azureml-dataprep[pandas]

Créer un fichier MLTable

Utilisez le Kit de développement logiciel (SDK) Python mltable pour créer un fichier MLTable afin de documenter le blueprint de chargement des données. Pour cela, copiez-collez le code suivant dans votre notebook/script, puis exécutez ce code :

import mltable

# glob the parquet file paths for years 2015-19, all months.
paths = [
    {
        "pattern": "wasbs://nyctlc@azureopendatastorage.blob.core.windows.net/green/puYear=2015/puMonth=*/*.parquet"
    },
    {
        "pattern": "wasbs://nyctlc@azureopendatastorage.blob.core.windows.net/green/puYear=2016/puMonth=*/*.parquet"
    },
    {
        "pattern": "wasbs://nyctlc@azureopendatastorage.blob.core.windows.net/green/puYear=2017/puMonth=*/*.parquet"
    },
    {
        "pattern": "wasbs://nyctlc@azureopendatastorage.blob.core.windows.net/green/puYear=2018/puMonth=*/*.parquet"
    },
    {
        "pattern": "wasbs://nyctlc@azureopendatastorage.blob.core.windows.net/green/puYear=2019/puMonth=*/*.parquet"
    },
]

# create a table from the parquet paths
tbl = mltable.from_parquet_files(paths)

# table a random sample
tbl = tbl.take_random_sample(probability=0.001, seed=735)

# filter trips with a distance > 0
tbl = tbl.filter("col('tripDistance') > 0")

# Drop columns
tbl = tbl.drop_columns(["puLocationId", "doLocationId", "storeAndFwdFlag"])

# Create two new columns - year and month - where the values are taken from the path
tbl = tbl.extract_columns_from_partition_format("/puYear={year}/puMonth={month}")

# print the first 5 records of the table as a check
tbl.show(5)

Vous pouvez éventuellement choisir de charger l’objet MLTable dans Pandas, à l’aide du code ci-dessous :

# You can load the table into a pandas dataframe
# NOTE: The data is in East US region and the data is large, so this will take several minutes (~7mins)
# to load if you are in a different region.

# df = tbl.to_pandas_dataframe()

Enregistrer les étapes de chargement des données

Ensuite, enregistrez toutes les étapes de chargement des données dans un fichier MLTable. L’enregistrement de vos étapes de chargement de données dans un fichier MLTable vous permet de reproduire votre DataFrame Pandas ultérieurement sans avoir à redéfinir le code à chaque fois.

Vous pouvez enregistrer le fichier yaml MLTable dans une ressource de stockage cloud, ou l’enregistrer dans des ressources ayant un chemin d’accès local.

# save the data loading steps in an MLTable file to a cloud storage resource
# NOTE: the tbl object was defined in the previous snippet.
tbl.save(path="azureml://subscriptions/<subid>/resourcegroups/<rgname>/workspaces/<wsname>/datastores/<name>/paths/titanic", colocated=True, show_progress=True, overwrite=True)

# save the data loading steps in an MLTable file to a local resource
# NOTE: the tbl object was defined in the previous snippet.
tbl.save("./titanic")

Reproduire les étapes de chargement des données

Maintenant que vous avez sérialisé les étapes de chargement des données dans un fichier, vous pouvez les reproduire à tout moment à l’aide de la méthode load(). De cette façon, vous n’avez pas besoin de redéfinir vos étapes de chargement de données dans le code et vous pouvez partager plus facilement le fichier.

import mltable

# load the previously saved MLTable file
tbl = mltable.load("./nyc_taxi/")
tbl.show(5)

# You can load the table into a pandas dataframe
# NOTE: The data is in East US region and the data is large, so this will take several minutes (~7mins)
# to load if you are in a different region.

# load the table into pandas
# df = tbl.to_pandas_dataframe()

# print the head of the data frame
# df.head()
# print the shape and column types of the data frame
# print(f"Shape: {df.shape}")
# print(f"Columns:\n{df.dtypes}")

Créer une ressource de données pour faciliter le partage et la reproductibilité

Votre fichier MLTable est peut-être actuellement enregistré sur disque, ce qui le rend difficile à partager avec les membres de l’équipe. Quand vous créez une ressource de données dans Azure Machine Learning, votre fichier MLTable est chargé dans le stockage cloud et « marqué d’un signet ». Les membres de votre équipe peuvent alors accéder au fichier MLTable à l’aide d’un nom convivial. En outre, la ressource de données est versionnée.

az ml data create --name green-quickstart --version 1 --path ./nyc_taxi --type mltable

subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace = "<AML_WORKSPACE_NAME>"

from azure.ai.ml import MLClient
from azure.ai.ml.entities import Data
from azure.ai.ml.constants import AssetTypes
from azure.identity import DefaultAzureCredential

# set VERSION variable
VERSION="1"

# connect to the AzureML workspace
# NOTE: the subscription_id, resource_group, workspace variables are set
# in the previous code snippet.
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

my_data = Data(
    path="./nyc_taxi",
    type=AssetTypes.MLTABLE,
    description="A random sample of NYC Green Taxi Data between 2015-19.",
    name="green-quickstart",
    version=VERSION,
)

ml_client.data.create_or_update(my_data)

Lire la ressource de données dans une session interactive

Maintenant que votre fichier MLTable est stocké dans le cloud, vous et les membres de votre équipe pouvez y accéder à l’aide d’un nom convivial dans une session interactive (par exemple, un notebook) :

import mltable
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

# connect to the AzureML workspace
# NOTE: the subscription_id, resource_group, workspace variables are set
# in a previous code snippet.
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

# get the latest version of the data asset
# Note: The version was set in the previous snippet. If you changed the version
# number, update the VERSION variable below.
VERSION="1"
data_asset = ml_client.data.get(name="green-quickstart", version=VERSION)

# create a table
tbl = mltable.load(f"azureml:/{data_asset.id}")
tbl.show(5)

# load into pandas
# NOTE: The data is in East US region and the data is large, so this will take several minutes (~7mins) to load if you are in a different region.
df = tbl.to_pandas_dataframe()

Lire la ressource de données dans un travail

Si vous ou un membre de votre équipe souhaitez accéder à la table dans un travail, votre script d’apprentissage Python doit contenir :

# ./src/train.py
import argparse
import mltable

# parse arguments
parser = argparse.ArgumentParser()
parser.add_argument('--input', help='mltable to read')
args = parser.parse_args()

# load mltable
tbl = mltable.load(args.input)

# load into pandas
df = tbl.to_pandas_dataframe()

Votre travail a besoin d’un fichier Conda qui inclut les dépendances de package Python :

# ./conda_dependencies.yml
dependencies:
  - python=3.10
  - pip=21.2.4
  - pip:
      - mltable
      - azureml-dataprep[pandas]

Vous envoyez le travail à l’aide du code suivant :

# mltable-job.yml
$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json

code: ./src

command: python train.py --input ${{inputs.green}}
inputs:
    green:
      type: mltable
      path: azureml:green-quickstart:1

compute: cpu-cluster

environment:
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04
  conda_file: conda_dependencies.yml

az ml job create -f mltable-job.yml

from azure.ai.ml import MLClient, command, Input
from azure.ai.ml.entities import Environment
from azure.identity import DefaultAzureCredential

# connect to the AzureML workspace
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

# get the latest version of the data asset
# Note: the VERSION was set in a previous cell.
data_asset = ml_client.data.get(name="green-quickstart", version=VERSION)

job = command(
    command="python train.py --input ${{inputs.green}}",
    inputs={"green": Input(type="mltable", path=data_asset.id)},
    compute="cpu-cluster",
    environment=Environment(
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04",
        conda_file="./job-env/conda_dependencies.yml",
    ),
    code="./src",
)

ml_client.jobs.create_or_update(job)

Création de fichiers MLTable

Pour créer directement le fichier MLTable, nous vous suggérons d’utiliser le Kit de développement logiciel (SDK) Python mltable, comme indiqué dans le guide de démarrage rapide sur les tables Azure Machine Learning, plutôt qu’un éditeur de texte. Dans cette section, nous décrivons les fonctionnalités du Kit de développement logiciel (SDK) Python mltable.

Types de fichiers pris en charge

Vous pouvez créer un fichier MLTable avec différents types de fichiers :

Pour plus d’informations, consultez la ressource de référence relative à MLTable.

Définition de chemins

Pour les types de fichiers Texte délimité, Parquet, Lignes JSON et Chemins, définissez une liste de dictionnaires Python qui définit le ou les chemins d’origine de la lecture :

import mltable

# A List of paths to read into the table. The paths are a python dict that define if the path is
# a file, folder, or (glob) pattern.
paths = [
    {
        "file": "<supported_path>"
    }
]

tbl = mltable.from_delimited_files(paths=paths)

# alternatively
# tbl = mltable.from_parquet_files(paths=paths)
# tbl = mltable.from_json_lines_files(paths=paths)
# tbl = mltable.from_paths(paths=paths)

MLTable prend en charge ces types de chemins :

Remarque sur la définition des chemins pour les tables Delta Lake

La définition de chemins pour lire des tables Delta Lake diffère par rapport aux autres types de fichiers. Pour les tables Delta Lake, le chemin d’accès pointe vers un dossier unique (généralement sur ADLS Gen2) qui contient le dossier « _delta_log » et des fichiers de données. Le voyage dans le temps est pris en charge. Le code suivant montre comment définir un chemin pour une table Delta Lake :

import mltable

# define the cloud path containing the delta table (where the _delta_log file is stored)
delta_table = "abfss://<file_system>@<account_name>.dfs.core.windows.net/<path_to_delta_table>"

# create an MLTable. Note the timestamp_as_of parameter for time travel.
tbl = mltable.from_delta_lake(
    delta_table_uri=delta_table,
    timestamp_as_of='2022-08-26T00:00:00Z'
)

Pour obtenir la version la plus récente des données Delta Lake, vous pouvez transmettre l’horodatage actuel dans timestamp_as_of.

import mltable

# define the relative path containing the delta table (where the _delta_log file is stored)
delta_table_path = "./working-directory/delta-sample-data"

# get the current timestamp in the required format
current_timestamp = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
print(current_timestamp)
tbl = mltable.from_delta_lake(delta_table_path, timestamp_as_of=current_timestamp)
df = tbl.to_pandas_dataframe()

Fichiers, dossiers et globs

Les tables Azure Machine Learning prennent en charge la lecture à partir des éléments suivants :

• fichier(s), par exemple : abfss://<file_system>@<account_name>.dfs.core.windows.net/my-csv.csv
• dossier(s), par exemple abfss://<file_system>@<account_name>.dfs.core.windows.net/my-folder/
• modèle(s) Glob, par exemple abfss://<file_system>@<account_name>.dfs.core.windows.net/my-folder/*.csv
• Une combinaison de fichiers, de dossiers et de modèles Glob

Transformations de chargement de données prises en charge

Vous trouverez des informations complètes et à jour sur les transformations de chargement de données prises en charge dans la documentation de référence relative à MLTable.

Exemples

Les exemples dans le référentiel GitHub d’exemples Azure Machine Learning constituent la base des extraits de code figurant dans cet article. Utilisez la commande ci-dessous pour cloner le référentiel dans votre environnement de développement :

git clone --depth 1 https://github.com/Azure/azureml-examples

Ce dossier de référentiel clone héberge les exemples pertinents pour les tables Azure Machine Learning :

cd azureml-examples/sdk/python/using-mltable

Fichiers délimités

Commencez par créer un fichier MLTable à partir d’un fichier CSV avec le code suivant :

import mltable
from mltable import MLTableHeaders, MLTableFileEncoding, DataType

# create paths to the data files
paths = [{"file": "wasbs://data@azuremlexampledata.blob.core.windows.net/titanic.csv"}]

# create an MLTable from the data files
tbl = mltable.from_delimited_files(
    paths=paths,
    delimiter=",",
    header=MLTableHeaders.all_files_same_headers,
    infer_column_types=True,
    include_path_column=False,
    encoding=MLTableFileEncoding.utf8,
)

# filter out rows undefined ages
tbl = tbl.filter("col('Age') > 0")

# drop PassengerId
tbl = tbl.drop_columns(["PassengerId"])

# ensure survived column is treated as boolean
data_types = {
    "Survived": DataType.to_bool(
        true_values=["True", "true", "1"], false_values=["False", "false", "0"]
    )
}
tbl = tbl.convert_column_types(data_types)

# show the first 5 records
tbl.show(5)

# You can also load into pandas...
# df = tbl.to_pandas_dataframe()
# df.head(5)

Enregistrer les étapes de chargement des données

Ensuite, enregistrez toutes les étapes de chargement des données dans un fichier MLTable. Lorsque vous enregistrez vos étapes de chargement de données dans un fichier MLTable, vous pouvez reproduire votre DataFrame Pandas ultérieurement sans avoir à redéfinir le code à chaque fois.

# save the data loading steps in an MLTable file
# NOTE: the tbl object was defined in the previous snippet.
tbl.save("./titanic")

Reproduire les étapes de chargement des données

Maintenant que ce fichier comporte les étapes de chargement des données sérialisées, vous pouvez les reproduire à tout moment à l’aide de la méthode load(). De cette façon, vous n’avez pas besoin de redéfinir vos étapes de chargement de données dans le code et vous pouvez partager plus facilement le fichier.

import mltable

# load the previously saved MLTable file
tbl = mltable.load("./titanic/")

Créer une ressource de données pour faciliter le partage et la reproductibilité

Votre fichier MLTable est peut-être actuellement enregistré sur disque, ce qui le rend difficile à partager avec les membres de l’équipe. Quand vous créez une ressource de données dans Azure Machine Learning, votre fichier MLTable est chargé dans le stockage cloud et « marqué d’un signet ». Les membres de votre équipe peuvent alors accéder au fichier MLTable à l’aide d’un nom convivial. En outre, la ressource de données est versionnée.

import time
from azure.ai.ml import MLClient
from azure.ai.ml.entities import Data
from azure.ai.ml.constants import AssetTypes
from azure.identity import DefaultAzureCredential

# Update with your details...
subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace = "<AML_WORKSPACE_NAME>"

# set the version number of the data asset to the current UTC time
VERSION = time.strftime("%Y.%m.%d.%H%M%S", time.gmtime())

# connect to the AzureML workspace
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

my_data = Data(
    path="./titanic",
    type=AssetTypes.MLTABLE,
    description="The titanic dataset.",
    name="titanic-cloud-example",
    version=VERSION,
)

ml_client.data.create_or_update(my_data)

Maintenant que votre fichier MLTable est stocké dans le cloud, vous et les membres de votre équipe pouvez y accéder à l’aide d’un nom convivial dans une session interactive (par exemple, un notebook) :

import mltable
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

# connect to the AzureML workspace
# NOTE:  subscription_id, resource_group, workspace were set in a previous snippet.
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

# get the latest version of the data asset
# Note: The version was set in the previous code cell.
data_asset = ml_client.data.get(name="titanic-cloud-example", version=VERSION)

# create a table
tbl = mltable.load(f"azureml:/{data_asset.id}")

# load into pandas
df = tbl.to_pandas_dataframe()
df.head(5)

Vous pouvez également accéder facilement à la ressource de données dans un travail.

Fichiers Parquet

Le guide de démarrage rapide sur les tables Azure Machine Learning explique comment lire les fichiers Parquet.

Chemins : Créer une table de fichiers image

Vous pouvez créer une table contenant les chemins sur le stockage cloud. Cet exemple contient plusieurs images de chiens et de chats situées dans le stockage cloud, dans la structure de dossiers suivante :

/pet-images
  /cat
    0.jpeg
    1.jpeg
    ...
  /dog
    0.jpeg
    1.jpeg

mltable peut construire une table qui contient les chemins de stockage de ces images et leurs noms de dossier (étiquettes), qui peuvent être utilisés pour transmettre les images en continu. Ce code crée le MLTable :

import mltable

# create paths to the data files
paths = [{"pattern": "wasbs://data@azuremlexampledata.blob.core.windows.net/pet-images/**/*.jpg"}]

# create the mltable
tbl = mltable.from_paths(paths)

# extract useful information from the path
tbl = tbl.extract_columns_from_partition_format("{account}/{container}/{folder}/{label}")

tbl = tbl.drop_columns(["account", "container", "folder"])

df = tbl.to_pandas_dataframe()
print(df.head())

# save the data loading steps in an MLTable file
tbl.save("./pets")

Ce code montre comment ouvrir l’emplacement de stockage dans le DataFrame Pandas et tracer les images :

# plot images on a grid. Note this takes ~1min to execute.
import matplotlib.pyplot as plt
from PIL import Image

fig = plt.figure(figsize=(20, 20))
columns = 4
rows = 5
for i in range(1, columns*rows +1):
    with df.Path[i].open() as f:
        img = Image.open(f)
        fig.add_subplot(rows, columns, i)
        plt.imshow(img)
        plt.title(df.label[i])

Créer une ressource de données pour faciliter le partage et la reproductibilité

Votre fichier mltable est peut-être actuellement enregistré sur disque, ce qui le rend difficile à partager avec les membres de l’équipe. Quand vous créez une ressource de données dans Azure Machine Learning, le mltable est chargé dans le stockage cloud et « marqué d’un signet ». Les membres de votre équipe peuvent alors accéder au mltable à l’aide d’un nom convivial. En outre, la ressource de données est versionnée.

import time
from azure.ai.ml import MLClient
from azure.ai.ml.entities import Data
from azure.ai.ml.constants import AssetTypes
from azure.identity import DefaultAzureCredential

# set the version number of the data asset to the current UTC time
VERSION = time.strftime("%Y.%m.%d.%H%M%S", time.gmtime())

# connect to the AzureML workspace
# NOTE: subscription_id, resource_group, workspace were set in a previous snippet.
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

my_data = Data(
    path="./pets",
    type=AssetTypes.MLTABLE,
    description="A sample of cat and dog images",
    name="pets-mltable-example",
    version=VERSION,
)

ml_client.data.create_or_update(my_data)

Maintenant que le mltable est stocké dans le cloud, vous et les membres de votre équipe pouvez y accéder à l’aide d’un nom convivial dans une session interactive (par exemple, un notebook) :

import mltable
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

# connect to the AzureML workspace
# NOTE: subscription_id, resource_group, workspace were set in a previous snippet.
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

# get the latest version of the data asset
# Note: the variable VERSION is set in the previous code
data_asset = ml_client.data.get(name="pets-mltable-example", version=VERSION)

# the table from the data asset id
tbl = mltable.load(f"azureml:/{data_asset.id}")

# load into pandas
df = tbl.to_pandas_dataframe()
df.head()

Vous pouvez également charger les données dans votre travail.

Étapes suivantes

• Accéder aux données dans un travail
• Créer et gérer des ressources de données
• Importer des ressources de données (préversion)
• Administration des données