Uso di tabelle in Azure Machine Learning

SI APPLICA A:Estensione ML dell'interfaccia della riga di comando di Azure v2 (corrente)Python SDK azure-ai-ml v2 (corrente)

Azure Machine Learning supporta un tipo di tabella (mltable). Ciò consente la creazione di un progetto che definisce come caricare i file di dati in memoria come frame di dati Pandas o Spark. Contenuto dell'articolo:

Prerequisiti

• Una sottoscrizione di Azure. Se non hai ancora una sottoscrizione di Azure, crea un account gratuito prima di iniziare. Provare la versione gratuita o a pagamento di Azure Machine Learning

• Azure Machine Learning SDK per Python

• Un'area di lavoro di Azure Machine Learning

pip install -U mltable azureml-dataprep[pandas]

Clonare il repository degli esempi

I frammenti di codice in questo articolo sono basati su esempi compresi nel repository GitHub degli esempi di Azure Machine Learning. Per clonare il repository nell'ambiente di sviluppo, usare questo comando:

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

È possibile trovare esempi rilevanti per le tabelle di Azure Machine Learning in questa cartella del repository clonato:

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

Introduzione

Le tabelle di Azure Machine Learning (mltable) consentono di definire come caricare i file di dati in memoria, come frame di dati Pandas e/o Spark. Le tabelle hanno due funzionalità principali:

1. Un file MLTable. Un file basato su YAML che definisce il progetto di caricamento dei dati. Nel file MLTable è possibile specificare:
   • Il percorso o i percorsi di archiviazione dei dati - in locale, nel cloud o in un server http(s) pubblico.
   • Criteri GLOB sull'archiviazione nel cloud. Questi percorsi possono specificare set di nomi file, con caratteri jolly (*).
   • trasformazione di lettura, ad esempio il tipo di formato di file (testo delimitato, Parquet, Delta, json), delimitatori, intestazioni e così via.
   • Conversioni dei tipi di colonna (per applicare lo schema).
   • Creazione di una nuova colonna, utilizzando le informazioni sulla struttura di cartelle, ad esempio creazione di una colonna di anni e mesi, usando la struttura di cartelle {year}/{month}nel percorso.
   • Subset di dati da caricare, ad esempio filtra righe, mantieni/elimina colonne, accetta campioni casuali.
2. Un motore rapido ed efficiente per caricare i dati in un frame di dati Pandas o Spark, in base al progetto definito nel file MLTable. Il motore si basa su Rust per un'efficienza di memoria e velocità elevate.

Le tabelle di Azure Machine Learning sono utili in questi scenari:

• È necessario eseguire il GLOB delle posizioni di archiviazione.
• È necessario creare una tabella usando dati da posizioni di archiviazione differenti ( ad esempio contenitori BLOB diversi).
• Il percorso contiene informazioni pertinenti che si desidera acquisire nei dati (ad esempio data e ora).
• Lo schema dei dati cambia frequentemente.
• Si desidera una facile riproducibilità dei passaggi di caricamento dei dati.
• È necessario solo un subset di dati di grandi dimensioni.
• I dati contengono percorsi di archiviazione da trasmettere nella sessione Python. Ad esempio, si desidera eseguire lo streaming di path nella seguente struttura di righe JSON: [{"path": "abfss://fs@account.dfs.core.windows.net/my-images/cats/001.jpg", "label":"cat"}].
• Si desidera eseguire il training di modelli di ML usando Azure Machine Learning AutoML.

Avvio rapido sulle tabelle di Azure Machine Learning

In questo avvio rapido si crea una tabella (mltable) dei dati dei taxi verdi di New York da set di dati aperti di Azure. I dati hanno un formato parquet e coprono gli anni dal 2008 al 2021. In un account di archiviazione BLOB accessibile pubblicamente, i file di dati hanno la struttura di cartelle seguente:

/
└── 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

Con questi dati, è necessario caricare in un frame di dati Pandas:

• Solo i file parquet per gli anni 2015-19
• Un esempio casuale dei dati
• Solo le righe con una distanza RIP maggiore di 0
• Colonne pertinenti per l'apprendimento automatico
• Nuove colonne - anno e mese - usando le informazioni sull'itinerario (puYear=X/puMonth=Y)

Il codice Pandas gestisce questa operazione. Tuttavia, il raggiungimento della riproducibilità diventerebbe difficile perché è necessario:

• Condividere il codice, il che significa che se lo schema cambia (ad esempio, una modifica del nome di colonna) tutti gli utenti devono aggiornare il codice
• Scrivere una pipeline ETL, che ha un sovraccarico elevato

Le tabelle di Azure Machine Learning offrono un meccanismo leggero per serializzare (salvare) i passaggi di caricamento dei dati in un file MLTable. Successivamente, l'utente e i membri del team possono riprodurre il frame di dati Pandas. Se lo schema cambia, si aggiorna solo il file MLTable, anziché eseguire aggiornamenti in numerosi percorsi che includono il codice di caricamento dei dati Python.

Clonare il notebook di avvio rapido o creare un nuovo notebook/script

Se si usa un'istanza di ambiente di calcolo di Azure Machine Learning, Creare un nuovo notebook. Se si usa un IDE, è necessario creare un nuovo script Python.

Inoltre, il notebook di avvio rapido è disponibile nel repository GitHub degli esempi di Azure Machine Learning. Usare questo codice per clonare e accedere al notebook:

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

Installare l'SDK per Python mltable

Per caricare i dati dei taxi verdi di New York in una tabella di Azure Machine Learning, è necessario che mltablePython SDK e pandas siano installati nell'ambiente Python con questo comando:

pip install -U mltable azureml-dataprep[pandas]

Creare un file MLTable

Usare mltable Python SDK per creare un file MLTable per documentare il progetto di caricamento dei dati. A tale scopo, copiare e incollare il seguente codice nel notebook/script ed eseguire il codice:

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)

Facoltativamente, è possibile scegliere di caricare l'oggetto MLTable in Pandas usando:

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

Salvare i passaggi di caricamento dei dati

Successivamente, salvare tutti i passaggi di caricamento dei dati in un file MLTable. Il salvataggio dei passaggi di caricamento dei dati in un file MLTable consente di riprodurre il frame di dati Pandas in un secondo momento, senza dover ridefinire ogni volta il codice.

È possibile salvare il file YAML MLTable in una risorsa di archiviazione cloud oppure salvarlo nelle risorse del percorso locale.

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

Riprodurre i passaggi di caricamento dei dati

Ora che i passaggi di caricamento dei dati sono stati serializzati in un file, è possibile riprodurli in qualsiasi momento, con il metodo di caricamento(). In questo modo, non è necessario ridefinire i passaggi di caricamento dei dati nel codice ed è possibile condividere più facilmente il file.

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}")

Creare un asset di dati per facilitare la condivisione e la riproducibilità

Il file MLTable potrebbe essere attualmente salvato su disco, cosa che rende difficile la condivisione con i membri del team. Quando si crea un asset di dati in Azure Machine Learning, MLTable viene caricato nell'archiviazione cloud e "contrassegnato con un segnalibro". I membri del team possono quindi accedere a MLTable usando un nome descrittivo. Viene inoltre eseguito il controllo delle versioni dell'asset di dati.

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)

Leggere l'asset di dati in una sessione interattiva

Ora che MLTable è archiviato nel cloud, l'utente e i membri del team possono accedervi con un nome descrittivo in una sessione interattiva (ad esempio 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()

Leggere l'asset di dati in un processo

Se l'utente o un membro del team desidera accedere alla tabella in un processo, lo script di training Python conterrà:

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

Il processo richiede un file conda che include le dipendenze del pacchetto Python:

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

Si invierebbe il processo usando:

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

Creazione di file MLTable

Per creare direttamente il file MLTable, è consigliabile usare mltable Python SDK per creare i file MLTable, come illustrato in Avvio rapido sulle tabelle di Azure Machine Learning, anziché un editor di testo. In questa sezione vengono descritte le funzionalità di mltable Python SDK.

Tipi di file supportati

È possibile creare una tabella MLTable usando un intervallo di tipi di file differenti:

Per altre informazioni, vedere la risorsa di riferimento di MLTable

Definizione dei percorsi

Per testo delimitato, parquet, righe e percorsi JSON, definire un elenco di dizionari Python che stabilisca il percorso o i percorsi da cui leggere:

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 supporta questi tipi di percorso:

Nota sulla definizione dei percorsi per le tabelle Delta Lake

La definizione dei percorsi per la lettura delle tabelle Delta Lake è differente rispetto agli altri tipi di file. Per le tabelle Delta Lake, il percorso punta a una singola cartella (in genere in ADLS Gen2) che contiene la tabella e i file di dati "_delta_log". lo spostamento cronologico è supportato. Il codice seguente illustra come definire un percorso per una tabella 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'
)

Per ottenere la versione più recente dei dati Delta Lake, è possibile passare il timestamp corrente in 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()

File, cartelle e GLOB

Le tabelle di Azure Machine Learning supportano la lettura da:

• file, ad esempio: abfss://<file_system>@<account_name>.dfs.core.windows.net/my-csv.csv
• cartelle, ad esempio abfss://<file_system>@<account_name>.dfs.core.windows.net/my-folder/
• criteri GLOB, ad esempio abfss://<file_system>@<account_name>.dfs.core.windows.net/my-folder/*.csv
• una combinazione di file, cartelle e/o criteri GLOB

Trasformazioni di caricamento dei dati supportate

Informazioni dettagliate complete e aggiornate delle trasformazioni di caricamento dei dati supportate sono disponibili nella documentazione di riferimento di MLTable.

Esempi

Gli esempi compresi nel repository GitHub degli esempi di Azure Machine Learning sono diventati la base per i frammenti di codice in questo articolo. Per clonare il repository nell'ambiente di sviluppo, usare questo comando:

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

Questa cartella del repository clone ospita gli esempi rilevanti per le tabelle di Azure Machine Learning:

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

File delimitati

Prima di tutto, creare una tabella MLTable da un file CSV con questo codice:

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)

Salvare i passaggi di caricamento dei dati

Successivamente, salvare tutti i passaggi di caricamento dei dati in un file MLTable. Quando si salvano i passaggi di caricamento dei dati in un file MLTable, è possibile riprodurre il frame di dati Pandas in un secondo momento, senza dover ridefinire ogni volta il codice.

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

Riprodurre i passaggi di caricamento dei dati

Ora che i passaggi contiene i passaggi di caricamento dei dati serializzati, è possibile riprodurli in qualsiasi momento, con il metodo di caricamento load(). In questo modo, non è necessario ridefinire i passaggi di caricamento dei dati nel codice ed è possibile condividere più facilmente il file.

import mltable

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

Creare un asset di dati per facilitare la condivisione e la riproducibilità

Il file MLTable potrebbe essere attualmente salvato su disco, cosa che rende difficile la condivisione con i membri del team. Quando si crea un asset di dati in Azure Machine Learning, MLTable viene caricato nell'archiviazione cloud e "contrassegnato con un segnalibro". I membri del team possono quindi accedere a MLTable con un nome descrittivo. Viene inoltre eseguito il controllo delle versioni dell'asset di dati.

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)

Ora che MLTable è archiviato nel cloud, l'utente e i membri del team possono accedervi con un nome descrittivo in una sessione interattiva (ad esempio 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)

È anche possibile accedere facilmente all'asset di dati in un processo.

File Parquet

Avvio rapido sulle tabelle di Azure Machine Learning illustra come leggere i file parquet.

Percorsi: creare una tabella di file di immagine

È possibile creare una tabella contenente i percorsi nell'archiviazione cloud. Questo esempio include diverse immagini di cani e gatti che si trovano nell'archiviazione cloud, nella struttura di cartelle seguente:

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

mltable è in grado di costruire una tabella contenente i percorsi di archiviazione di queste immagini e i relativi nomi di cartella (etichette), che è possibile usare per trasmettere le immagini. Questo codice crea 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")

Il codice illustra come aprire la posizione di archiviazione nel frame di dati Pandas e tracciare le immagini:

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

Creare un asset di dati per facilitare la condivisione e la riproducibilità

Il file mltable potrebbe essere attualmente salvato su disco, cosa che rende difficile la condivisione con i membri del team. Quando si crea un asset di dati in Azure Machine Learning, mltable viene caricato nell'archiviazione cloud e "contrassegnato con un segnalibro". I membri del team possono accedere a mltable con un nome descrittivo. Viene inoltre eseguito il controllo delle versioni dell'asset di dati.

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)

Ora che mltable è archiviato nel cloud, l'utente e i membri del team possono accedervi con un nome descrittivo in una sessione interattiva (ad esempio 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()

È anche possibile caricare i dati nel processo.

Passaggi successivi

• Accedere ai dati in un processo
• Creare e gestire asset di dati
• Importare asset di dati (anteprima)
• Amministrazione dati