Praca z tabelami w usłudze Azure Machine Learning

DOTYCZY:Rozszerzenie ml interfejsu wiersza polecenia platformy Azure w wersji 2 (bieżąca)Zestaw SDK języka Python azure-ai-ml v2 (bieżąca)

Usługa Azure Machine Learning obsługuje typ tabeli (mltable). Dzięki temu można utworzyć schemat, który definiuje sposób ładowania plików danych do pamięci w postaci ramki danych Pandas lub Spark. Z tego artykułu dowiesz się:

Wymagania wstępne

• Subskrypcja platformy Azure. Jeśli nie masz jeszcze subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto. Wypróbuj bezpłatną lub płatną wersję usługi Azure Machine Learning

• Zestaw SDK usługi Azure Machine Learning dla języka Python

• Obszar roboczy usługi Azure Machine Learning

pip install -U mltable azureml-dataprep[pandas]

Klonowanie repozytorium przykładów

Fragmenty kodu w tym artykule są oparte na przykładach w repozytorium GitHub przykładów usługi Azure Machine Learning. Aby sklonować repozytorium do środowiska deweloperskiego, użyj następującego polecenia:

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

Przykłady dotyczące tabel usługi Azure Machine Learning można znaleźć w tym folderze sklonowanego repozytorium:

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

Wprowadzenie

Tabele Azure Machine Learning (mltable) pozwalają określić, jak chcesz ładować pliki danych do pamięci jako ramki danych Pandas i/lub Spark. Tabele mają dwie kluczowe funkcje:

1. Plik MLTable. Plik oparty na języku YAML, który definiuje strategię ładowania danych. W pliku MLTable można określić:
   • Lokalizacja magazynu lub lokalizacje danych — lokalna, w chmurze lub na publicznym serwerze http(s).
   • Wzorce dopasowywania w pamięci masowej w chmurze. Te lokalizacje mogą określać zestawy nazw plików z symbolami wieloznacznymi (*).
   • transformacja odczytu — na przykład typ formatu pliku (tekst rozdzielany separatorami, Parquet, Delta, JSON), ograniczniki, nagłówki itp.
   • Konwersje typów kolumn (w celu wymuszenia zgodności ze schematem).
   • Tworzenie nowej kolumny przy użyciu informacji o strukturze folderów — na przykład utworzenie kolumny rok i miesiąc przy użyciu {year}/{month} struktury folderów w ścieżce.
   • Podzestawy danych do załadowania — na przykład przefiltruj wiersze, zachowaj/upuść kolumny, pobierz losowe próbki.
2. Szybki i wydajny mechanizm do ładowania danych do obiektu DataFrame biblioteki Pandas lub Spark zgodnie ze schematem zdefiniowanym w pliku MLTable. Silnik opiera się na Rust, aby zapewnić dużą szybkość i efektywność pamięciową.

Tabele usługi Azure Machine Learning są przydatne w następujących scenariuszach:

• Należy użyć wzorca glob dla lokalizacji magazynu.
• Musisz utworzyć tabelę przy użyciu danych z różnych lokalizacji przechowywania (na przykład różnych kontenerów obiektów blob).
• Ścieżka zawiera istotne informacje, które chcesz wyodrębnić i zapisać w danych (na przykład datę i godzinę).
• Schemat danych często się zmienia.
• Potrzebujesz łatwej powtarzalności kroków ładowania danych.
• Potrzebny jest tylko podzbiór dużych danych.
• Twoje dane zawierają lokalizacje magazynowania, z których chcesz przesyłać strumieniowo dane do sesji Python. Na przykład chcesz przesyłać strumieniowo path w następującej strukturze wierszy JSON: [{"path": "abfss://fs@account.dfs.core.windows.net/my-images/cats/001.jpg", "label":"cat"}].
• Chcesz wytrenować modele uczenia maszynowego przy użyciu rozwiązania Azure Machine Learning AutoML.

Szybki start: tabele w usłudze Azure Machine Learning

W tym przewodniku Szybki start utworzysz tabelę (mltable) danych NYC Green Taxi z usługi Azure Open Datasets. Dane mają format parquet i obejmują lata 2008-2021. W publicznie dostępnym koncie usługi Blob Storage pliki danych mają następującą strukturę folderów:

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

Mając te dane, należy załadować je do ramki danych Pandas:

• Tylko pliki w formacie Parquet z lat 2015–2019
• Losowa próbka danych
• Tylko wiersze o odległości podróży większej niż 0
• Odpowiednie kolumny dla uczenia maszynowego
• Nowe kolumny — rok i miesiąc — przy użyciu informacji o ścieżce (puYear=X/puMonth=Y)

Kod biblioteki Pandas obsługuje to. Jednak osiągnięcie powtarzalności stanie się trudne, ponieważ należy wykonać jedną z następujących czynności:

• Udostępnij kod, co oznacza, że jeśli schemat ulegnie zmianie (na przykład nazwa kolumny może ulec zmianie), wszyscy użytkownicy muszą zaktualizować swój kod
• Napisz potok ETL o wysokim narzucie

Tabele usługi Azure Machine Learning zapewniają lekki mechanizm serializacji (zapisywania) kroków ładowania danych w MLTable pliku. Następnie Ty i członkowie Twojego zespołu będziecie mogli odtworzyć ramkę danych Pandas. Jeśli schemat ulegnie zmianie, wystarczy zaktualizować MLTable plik zamiast aktualizacji w wielu miejscach obejmujących kod ładowania danych w języku Python.

Sklonuj notatnik szybkiego startu lub utwórz nowy notatnik/skrypt

Jeśli używasz instancji obliczeniowej Azure Machine Learning, utwórz notes. Jeśli używasz środowiska IDE, należy utworzyć nowy skrypt języka Python.

Ponadto notes Szybki start jest również dostępny w repozytorium GitHub z przykładami dla usługi Azure Machine Learning. Użyj tego kodu, aby sklonować notes i uzyskać do niego dostęp:

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

Instalowanie zestawu mltable SDK języka Python

Aby załadować dane NYC Green Taxi do tabeli Azure Machine Learning, musisz mieć zainstalowane w środowisku Python składnik mltable Python SDK oraz pandas, używając następującego polecenia:

pip install -U mltable azureml-dataprep[pandas]

Tworzenie pliku MLTable

Użyj zestawu mltable SDK języka Python, aby utworzyć plik MLTable, aby udokumentować strategię ładowania danych. W tym celu skopiuj i wklej następujący kod do notesu/skryptu, a następnie wykonaj ten kod:

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)

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

Opcjonalnie możesz załadować obiekt MLTable do biblioteki Pandas przy użyciu:

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

Zapisywanie kroków ładowania danych

Następnie zapisz wszystkie kroki ładowania danych do pliku MLTable. Zapisanie kroków ładowania danych w pliku MLTable umożliwia odtworzenie ramki danych Pandas w późniejszym czasie bez konieczności każdorazowego ponownego definiowania kodu.

Możesz zapisać plik YAML MLTable w zasobie magazynu chmurowego lub w zasobach ścieżek lokalnych.

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

Odtwórz kroki ładowania danych

Po serializacji kroków ładowania danych do pliku można je odtworzyć w dowolnym momencie za pomocą metody load(). W ten sposób nie trzeba ponownie definiować kroków ładowania danych w kodzie i łatwiej udostępnić plik.

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

Tworzenie zasobu danych w celu pomocy w udostępnianiu i powtarzalności

Możesz zapisać plik MLTable na dysku, co może utrudnić udostępnianie członkom zespołu. Podczas tworzenia zasobu danych w usłudze Azure Machine Learning przesyłasz plik MLTable do magazynu w chmurze i tworzysz do niego zakładkę. Członkowie zespołu mogą uzyskać dostęp do tabeli MLTable za pomocą przyjaznej nazwy. Ponadto zasób danych jest wersjonowany.

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)

Odczytywanie zasobu danych w sesji interakcyjnej

Teraz, gdy MLTable jest przechowywany w chmurze, Ty i członkowie zespołu możecie uzyskać do niego dostęp przy użyciu przyjaznej nazwy w sesji interakcyjnej (na przykład w notatniku):

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

Odczytywanie zasobu danych w zadaniu

Jeśli ty lub członek zespołu chcesz uzyskać dostęp do tabeli w zadaniu, skrypt szkoleniowy języka Python będzie zawierał następujące elementy:

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

Zadanie wymaga pliku conda, który zawiera zależności pakietów języka Python:

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

Zadanie należy przesłać przy użyciu:

# 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-ubuntu22.04:latest
  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-ubuntu22.04:latest",
        conda_file="./job-env/conda_dependencies.yml",
    ),
    code="./src",
)

ml_client.jobs.create_or_update(job)

Tworzenie plików MLTable

Aby bezpośrednio utworzyć plik MLTable, zalecamy użycie mltable zestawu SDK języka Python do tworzenia plików MLTable — jak pokazano w przewodniku Szybki start tabel usługi Azure Machine Learning — zamiast edytora tekstów. W tej sekcji przedstawiamy możliwości pakietu mltable SDK języka Python.

Typy obsługiwanych plików

Tabelę MLTable można utworzyć z różnymi typami plików:

Aby uzyskać więcej informacji, przeczytaj zasób referencyjny MLTable

Definiowanie ścieżek

W przypadku tekstu rozdzielanego, parquet, wierszy JSON i ścieżek zdefiniuj listę słowników języka Python, które definiują ścieżkę lub ścieżki, z których mają być odczytywane:

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 obsługuje następujące typy ścieżek:

Uwaga dotycząca definiowania ścieżek dla tabel usługi Delta Lake

W porównaniu z innymi typami plików definiowanie ścieżek odczytu tabel usługi Delta Lake różni się. W przypadku tabel usługi Delta Lake ścieżka wskazuje pojedynczy folder (zazwyczaj w usłudze ADLS Gen2), który zawiera folder "_delta_log" i pliki danych. podróż w czasie jest obsługiwana. Poniższy kod pokazuje, jak zdefiniować ścieżkę dla tabeli usługi 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'
)

Aby uzyskać najnowszą wersję danych usługi Delta Lake, możesz przekazać bieżący znacznik czasu do pliku timestamp_as_of.

import mltable
import time

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

Pliki, foldery i globy

Tabele usługi Azure Machine Learning obsługują odczytywanie z:

• plik(i), na przykład: abfss://<file_system>@<account_name>.dfs.core.windows.net/my-csv.csv
• folder(y), na przykład abfss://<file_system>@<account_name>.dfs.core.windows.net/my-folder/
• wzorzec/wzorce glob, na przykład abfss://<file_system>@<account_name>.dfs.core.windows.net/my-folder/*.csv
• kombinacja plików, folderów i wzorców symboli globbingowych

Obsługiwane transformacje ładowania danych

Pełne i aktualne informacje na temat obsługiwanych przekształceń ładowania danych można znaleźć w dokumentacji referencyjnej MLTable.

Dodatkowe przykłady

Przykłady w repozytorium GitHub z przykładami usługi Azure Machine Learning stały się podstawą fragmentów kodu w tym artykule. Użyj tego polecenia, aby sklonować repozytorium do środowiska deweloperskiego:

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

Ten folder sklonowanego repozytorium zawiera przykłady związane z tabelami usługi Azure Machine Learning:

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

W poniższych przykładach opisano, jak pracować z rozdzielanymi plikami tekstowymi i plikami parquet oraz jak utworzyć zasób danych.

Używanie plików rozdzielanych

W tych przykładach użyto popularnego zestawu danych Titanic (12 zmiennych, 891 wierszy) używanego do modelowania przewidywań przetrwania. Najpierw utwórz tabelę MLTable na podstawie pliku CSV za pomocą następującego kodu:

import mltable
from mltable import MLTableHeaders, MLTableFileEncoding, DataType

# create paths to the data files
# Using a public dataset for easier access
paths = [{"file": "https://raw.githubusercontent.com/datasciencedojo/datasets/master/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 - this dataset is small so it's safe to load
df = tbl.to_pandas_dataframe()
df.head(5)

Zapisywanie kroków ładowania danych

Następnie zapisz wszystkie kroki ładowania danych do pliku MLTable. Podczas zapisywania kroków ładowania danych w pliku MLTable można odtworzyć ramkę danych biblioteki Pandas w późniejszym momencie bez konieczności ponownego definiowania kodu za każdym razem.

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

Odtwórz kroki ładowania danych

Teraz, gdy plik ma zserializowane kroki ładowania danych, możesz odtworzyć je w dowolnym momencie za load() pomocą metody . W ten sposób nie trzeba ponownie definiować kroków ładowania danych w kodzie i łatwiej udostępnić plik.

import mltable

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

Aby udostępnić tę tabelę MLTable członkom zespołu, możesz utworzyć zasób danych w usłudze Azure Machine Learning. Aby uzyskać szczegółowe informacje, zobacz Tworzenie zasobu danych obrazu zwierząt domowych .

Korzystanie z plików parquet

Przewodnik Szybki start dotyczący tabel usługi Azure Machine Learning wyjaśnia, jak odczytywać pliki parquet.

Ścieżki: tworzenie tabeli plików obrazów

Możesz utworzyć tabelę zawierającą ścieżki do magazynu w chmurze. W tym przykładzie znajduje się kilka obrazów psów i kotów znajdujących się w magazynie w chmurze w następującej strukturze folderów:

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

Obiekt mltable może utworzyć tabelę zawierającą ścieżki przechowywania tych obrazów oraz nazwy ich folderów (etykiety), które można wykorzystać do strumieniowego przesyłania obrazów. Ten kod tworzy tabelę MLTable:

import mltable

# create paths to the data files
paths = [{"pattern": "wasb://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")

Ten kod pokazuje, jak otworzyć lokalizację przechowywania w ramce danych Pandas i wyświetlić obrazy:

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

Tworzenie zasobu danych obrazu zwierząt domowych

Być może plik mltable jest obecnie zapisany na dysku, co utrudnia udostępnianie członkom zespołu. Podczas tworzenia zasobu danych w usłudze Azure Machine Learning element mltable jest przesyłany do magazynu w chmurze i dodawany do zakładek. Członkowie zespołu mogą następnie uzyskać dostęp do elementu mltable przy użyciu przyjaznej nazwy. Ponadto zasób danych jest wersjonowany.

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)

Teraz, gdy element mltable jest przechowywany w chmurze, Ty i Twoi członkowie zespołu będą mogli uzyskać do niego dostęp za pomocą przyjaznej nazwy w sesji interaktywnej (na przykład notesu):

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

Możesz również załadować dane do swojego zadania.

Następne kroki

• Uzyskiwanie dostępu do danych w zadaniu
• Tworzenie zasobów danych i zarządzanie nimi
• Importowanie zasobów danych (wersja zapoznawcza)
• Administrowanie danymi