Arbeta med tabeller i Azure Machine Learning

Artikel
04/19/2024

GÄLLER FÖR:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (aktuell)

Azure Machine Learning stöder en tabelltyp (mltable). På så sätt kan du skapa en skiss som definierar hur du läser in datafiler i minnet som en Pandas- eller Spark-dataram. I den här artikeln lär du dig:

När du ska använda Azure Machine Learning-tabeller i stället för filer eller mappar
Så här installerar du SDK:et mltable
Definiera en skiss för datainläsning med hjälp av en mltable fil
Exempel som visar hur mltable används i Azure Machine Learning
Så här använder mltable du under interaktiv utveckling (till exempel i en notebook-fil)

Förutsättningar

En Azure-prenumeration. Om du inte redan har en Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar. Prova den kostnadsfria eller betalda versionen av Azure Machine Learning
Azure Machine Learning SDK för Python
En Azure Machine Learning-arbetsyta

Viktigt!

Se till att du har det senaste mltable paketet installerat i Python-miljön:

pip install -U mltable azureml-dataprep[pandas]

Klona exempellagringsplatsen

Kodfragmenten i den här artikeln baseras på exempel i GitHub-lagringsplatsen för Azure Machine Learning-exempel. Om du vill klona lagringsplatsen till utvecklingsmiljön använder du det här kommandot:

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

Dricks

Använd --depth 1 för att endast klona den senaste incheckningen till lagringsplatsen. Detta minskar den tid som krävs för att slutföra åtgärden.

Du hittar exempel som är relevanta för Azure Machine Learning-tabeller i den här mappen för den klonade lagringsplatsen:

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

Introduktion

Med Azure Machine Learning-tabeller (mltable) kan du definiera hur du vill läsa in dina datafiler i minnet, som en Pandas- och/eller Spark-dataram. Tabeller har två viktiga funktioner:

En MLTable-fil. En YAML-baserad fil som definierar skissen för datainläsning. I MLTable-filen kan du ange:
- Lagringsplatsen eller platserna för data – lokalt, i molnet eller på en offentlig http-server.
- Globbningsmönster över molnlagring. Dessa platser kan ange uppsättningar med filnamn med jokertecken (*).
- read transformation – till exempel filformattypen (avgränsad text, Parquet, Delta, json), avgränsare, rubriker osv.
- Konverteringar av kolumntyp (för att framtvinga schema).
- Ny kolumn skapas med hjälp av mappstrukturinformation – till exempel skapande av en kolumn för år och månad med hjälp {year}/{month} av mappstrukturen i sökvägen.
- Delmängder av data som ska läsas in – till exempel filtrera rader, behålla/släppa kolumner, ta slumpmässiga exempel.
En snabb och effektiv motor för att läsa in data i en Pandas- eller Spark-dataram, enligt skissen som definieras i MLTable-filen. Motorn förlitar sig på Rust för hög hastighet och minneseffektivitet.

Azure Machine Learning-tabeller är användbara i följande scenarier:

Du måste glob över lagringsplatser.
Du måste skapa en tabell med data från olika lagringsplatser (till exempel olika blobcontainrar).
Sökvägen innehåller relevant information som du vill samla in i dina data (till exempel datum och tid).
Dataschemat ändras ofta.
Du vill ha enkel reproducerbarhet för dina datainläsningssteg.
Du behöver bara en delmängd med stora data.
Dina data innehåller lagringsplatser som du vill strömma till python-sessionen. Du vill till exempel strömma path i följande JSON-linjestruktur: [{"path": "abfss://fs@account.dfs.core.windows.net/my-images/cats/001.jpg", "label":"cat"}].
Du vill träna ML-modeller med Hjälp av Azure Machine Learning AutoML.

Dricks

För tabelldata kräver Azure Machine Learning inte användning av Azure Machine Learning-tabeller (mltable). Du kan använda typerna Azure Machine Learning File (uri_file) och Folder (uri_folder) och din egen parsningslogik läser in data i en Pandas- eller Spark-dataram.

För en enkel CSV-fil eller Parquet-mapp är det enklare att använda Azure Machine Learning Files/Folders i stället för tabeller.

Snabbstart för Azure Machine Learning-tabeller

I den här snabbstarten skapar du en tabell (mltable) med NYC Green Taxi Data från Azure Open Datasets. Data har ett parquet-format och omfattar åren 2008–2021. På ett offentligt tillgängligt bloblagringskonto har datafilerna den här mappstrukturen:

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

Med dessa data måste du läsa in i en Pandas-dataram:

Endast parquet-filerna för åren 2015-19
Ett slumpmässigt urval av data
Endast rader med ett ripavstånd större än 0
Relevanta kolumner för Machine Learning
Nya kolumner – år och månad – med sökvägsinformationen (puYear=X/puMonth=Y)

Pandas-koden hanterar detta. Det skulle dock bli svårt att uppnå reproducerbarhet eftersom du antingen måste:

Dela kod, vilket innebär att om schemat ändras (till exempel ett kolumnnamn kan ändras) måste alla användare uppdatera sin kod
Skriva en ETL-pipeline, som har stora omkostnader

Azure Machine Learning-tabeller ger en lättviktsmekanism för att serialisera (spara) datainläsningsstegen i en MLTable fil. Sedan kan du och medlemmar i ditt team återskapa Pandas-dataramen. Om schemat ändras uppdaterar MLTable du bara filen i stället för uppdateringar på många platser där Python-data läser in kod.

Klona snabbstartsanteckningsboken eller skapa en ny notebook-fil/skript

Om du använder en Azure Machine Learning-beräkningsinstans skapar du en ny notebook-fil. Om du använder en IDE bör du skapa ett nytt Python-skript.

Dessutom är snabbstartsanteckningsboken tillgänglig i GitHub-lagringsplatsen för Azure Machine Learning-exempel. Använd den här koden för att klona och komma åt notebook-filen:

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

`mltable` Installera Python SDK

Om du vill läsa in NYC Green Taxi Data i en Azure Machine Learning-tabell måste du ha mltable Python SDK och pandas installerat i Python-miljön med det här kommandot:

pip install -U mltable azureml-dataprep[pandas]

Skapa en MLTable-fil

mltable Använd Python SDK för att skapa en MLTable-fil för att dokumentera skissen för datainläsning. För detta kopierar och klistrar du in följande kod i notebook-filen/skriptet och kör sedan koden:

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)

Du kan välja att läsa in MLTable-objektet i Pandas med hjälp av:

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

Spara stegen för datainläsning

Spara sedan alla datainläsningssteg i en MLTable-fil. Om du sparar dina datainläsningssteg i en MLTable-fil kan du återskapa din Pandas-dataram vid en senare tidpunkt, utan att behöva omdefiniera koden varje gång.

Du kan spara MLTable yaml-filen till en molnlagringsresurs, eller så kan du spara den i lokala sökvägsresurser.

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

Viktigt!

Om samlokaliserade == True kopierar vi data till samma mapp med MLTable yaml-filen om de inte är samlokaliserade för tillfället, och vi använder relativa sökvägar i MLTable yaml.
Om samallokerade == False flyttar vi inte data, vi använder absoluta sökvägar för molndata och använder relativa sökvägar för lokala data.
Vi stöder inte den här parameterkombinationen: data lagras i en lokal resurs, samlokaliserade == False, path riktar sig mot en molnkatalog. Ladda upp dina lokala data till molnet och använd molndatasökvägarna för MLTable i stället.

Återskapa datainläsningssteg

Nu när du serialiserade datainläsningsstegen i en fil kan du återskapa dem när som helst med metoden load(). På så sätt behöver du inte omdefiniera datainläsningsstegen i koden, och du kan enklare dela filen.

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

Du kanske har sparat MLTable-filen på disken, vilket gör det svårt att dela med gruppmedlemmar. När du skapar en datatillgång i Azure Machine Learning laddas MLTable upp till molnlagring och "bokmärke". Dina teammedlemmar kan sedan komma åt MLTable med ett eget namn. Dessutom är datatillgången versionshanterad.

CLI
Python

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

Kommentar

Sökvägen pekar på mappen som innehåller MLTable filen.

Ange din prenumeration, resursgrupp och arbetsyta:

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

Du kan skapa en datatillgång i Azure Machine Learning med den här Python-koden:

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)

Kommentar

Sökvägen pekar på mappen som innehåller MLTable-artefakten.

Läsa datatillgången i en interaktiv session

Nu när din MLTable har lagrats i molnet kan du och teammedlemmarna komma åt den med ett eget namn i en interaktiv session (till exempel en notebook-fil):

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

Läsa datatillgången i ett jobb

Om du eller en teammedlem vill komma åt tabellen i ett jobb innehåller python-träningsskriptet:

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

Jobbet behöver en conda-fil som innehåller Python-paketberoenden:

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

Du skickar jobbet med hjälp av:

CLI
Python

Skapa följande YAML-jobbfil:

# 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

Skapa jobbet i CLI:

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)

Redigera MLTable Files

Om du vill skapa MLTable-filen direkt rekommenderar vi att du använder mltable Python SDK för att skapa dina MLTable-filer – som visas i snabbstarten för Azure Machine Learning-tabeller – i stället för en textredigerare. I det här avsnittet beskriver vi funktionerna i mltable Python SDK.

Filtyper som stöds

Du kan skapa en MLTable med en rad olika filtyper:

Filtyp	`MLTable` Python SDK
Avgränsad text (till exempel CSV-filer)	`from_delimited_files(paths=[path])`
Parquet	`from_parquet_files(paths=[path])`
Data Lake	`from_delta_lake(delta_table_uri=<uri_pointing_to_delta_table_directory>,timestamp_as_of='2022-08-26T00:00:00Z')`
JSON-rader	`from_json_lines_files(paths=[path])`
Sekvenser (Skapa en tabell med en kolumn med sökvägar att strömma)	`from_paths(paths=[path])`

Mer information finns i referensresursen MLTable

Definiera sökvägar

För avgränsad text, parquet, JSON-rader och sökvägar definierar du en lista med Python-ordlistor som definierar sökvägen eller sökvägarna som ska läsas från:

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 stöder följande sökvägstyper:

Plats	Exempel
En sökväg på den lokala datorn	`./home/username/data/my_data`
En sökväg på en offentlig http-server	`https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv`
En sökväg i Azure Storage	`wasbs://<container_name>@<account_name>.blob.core.windows.net/<path>` `abfss://<file_system>@<account_name>.dfs.core.windows.net/<path>`
Ett långformat Azure Machine Learning-datalager	`azureml://subscriptions/<subid>/resourcegroups/<rgname>/workspaces/<wsname>/datastores/<name>/paths/<path>`

Kommentar

mltable hanterar genomströmning av användarautentiseringsuppgifter för sökvägar i Azure Storage- och Azure Machine Learning-datalager. Om du inte har behörighet till data på den underliggande lagringen kan du inte komma åt data.

En anteckning om hur du definierar sökvägar för Delta Lake-tabeller

Jämfört med de andra filtyperna är det annorlunda att definiera sökvägar för att läsa Delta Lake-tabeller. För Delta Lake-tabeller pekar sökvägen på en enda mapp (vanligtvis på ADLS gen2) som innehåller mappen "_delta_log" och datafiler. tidsresor stöds. Följande kod visar hur du definierar en sökväg för en Delta Lake-tabell:

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

Om du vill hämta den senaste versionen av Delta Lake-data kan du skicka aktuell tidsstämpel till 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()

Viktigt!

Begränsning: mltable stöder inte extrahering av partitionsnycklar vid läsning av data från Delta Lake. Omvandlingen mltableextract_columns_from_partition_format fungerar inte när du läser Delta Lake-data via mltable.

Viktigt!

Filer, mappar och globs

Azure Machine Learning-tabeller stöder läsning från:

fil(ar), till exempel: abfss://<file_system>@<account_name>.dfs.core.windows.net/my-csv.csv
mappar, till exempel abfss://<file_system>@<account_name>.dfs.core.windows.net/my-folder/
globmönster , till exempel abfss://<file_system>@<account_name>.dfs.core.windows.net/my-folder/*.csv
en kombination av filer, mappar och globbande mönster

Datainläsningstransformeringar som stöds

Hitta fullständig, uppdaterad information om de datainläsningstransformeringar som stöds i MLTable-referensdokumentationen.

Exempel

Exempel i Azure Machine Learning-exempel på GitHub-lagringsplats blev grunden för kodfragmenten i den här artikeln. Använd det här kommandot för att klona lagringsplatsen till utvecklingsmiljön:

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

Dricks

Använd --depth 1 för att endast klona den senaste incheckningen till lagringsplatsen. Detta minskar den tid som krävs för att slutföra åtgärden.

Den här klondatabasmappen är värd för exemplen som är relevanta för Azure Machine Learning-tabeller:

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

Avgränsade filer

Skapa först en MLTable från en CSV-fil med den här koden:

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)

Spara stegen för datainläsning

Spara sedan alla datainläsningssteg i en MLTable-fil. När du sparar datainläsningsstegen i en MLTable-fil kan du återskapa din Pandas-dataram vid en senare tidpunkt, utan att behöva omdefiniera koden varje gång.

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

Återskapa datainläsningssteg

Nu när filen har de serialiserade datainläsningsstegen load() kan du återskapa dem när som helst med metoden. På så sätt behöver du inte omdefiniera datainläsningsstegen i koden, och du kan enklare dela filen.

import mltable

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

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)

Nu när din MLTable har lagrats i molnet kan du och teammedlemmarna komma åt den med ett eget namn i en interaktiv session (till exempel en notebook-fil):

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)

Du kan också enkelt komma åt datatillgången i ett jobb.

Parquet-filer

Snabbstarten för Azure Machine Learning-tabeller förklarar hur du läser parquet-filer.

Sökvägar: Skapa en tabell med bildfiler

Du kan skapa en tabell som innehåller sökvägarna i molnlagringen. I det här exemplet finns flera hund- och kattbilder i molnlagringen i följande mappstruktur:

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

mltable Kan konstruera en tabell som innehåller lagringssökvägarna för dessa bilder och deras mappnamn (etiketter), som kan användas för att strömma bilderna. Den här koden skapar 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")

Den här koden visar hur du öppnar lagringsplatsen i Pandas-dataramen och ritar bilderna:

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

Du kanske har sparat mltable filen på disken, vilket gör det svårt att dela med gruppmedlemmar. När du skapar en datatillgång i Azure Machine Learning laddas den mltable upp till molnlagring och "bokmärke". Dina teammedlemmar kan sedan komma åt mltable med ett eget namn. Dessutom är datatillgången versionshanterad.

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)

Nu när mltable lagras i molnet kan du och dina teammedlemmar komma åt den med ett eget namn i en interaktiv session (till exempel en notebook-fil):

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

Du kan också läsa in data i ditt jobb.

Arbeta med tabeller i Azure Machine Learning

Förutsättningar

Klona exempellagringsplatsen

Introduktion

Snabbstart för Azure Machine Learning-tabeller

Klona snabbstartsanteckningsboken eller skapa en ny notebook-fil/skript

`mltable` Installera Python SDK

Skapa en MLTable-fil

Spara stegen för datainläsning

Återskapa datainläsningssteg

Läsa datatillgången i en interaktiv session

Läsa datatillgången i ett jobb

Redigera MLTable Files

Filtyper som stöds

Definiera sökvägar

En anteckning om hur du definierar sökvägar för Delta Lake-tabeller

Filer, mappar och globs

Datainläsningstransformeringar som stöds

Exempel

Avgränsade filer

Spara stegen för datainläsning

Återskapa datainläsningssteg

Parquet-filer

Sökvägar: Skapa en tabell med bildfiler

Nästa steg

Ytterligare resurser

Arbeta med tabeller i Azure Machine Learning

Förutsättningar

Klona exempellagringsplatsen

Introduktion

Snabbstart för Azure Machine Learning-tabeller

Klona snabbstartsanteckningsboken eller skapa en ny notebook-fil/skript

mltable Installera Python SDK

Skapa en MLTable-fil

Spara stegen för datainläsning

Återskapa datainläsningssteg

Skapa en datatillgång för att underlätta delning och reproducerbarhet

Läsa datatillgången i en interaktiv session

Läsa datatillgången i ett jobb

Redigera MLTable Files

Filtyper som stöds

Definiera sökvägar

En anteckning om hur du definierar sökvägar för Delta Lake-tabeller

Filer, mappar och globs

Datainläsningstransformeringar som stöds

Exempel

Avgränsade filer

Spara stegen för datainläsning

Återskapa datainläsningssteg

Skapa en datatillgång för att underlätta delning och reproducerbarhet

Parquet-filer

Sökvägar: Skapa en tabell med bildfiler

Skapa en datatillgång för att underlätta delning och reproducerbarhet

Nästa steg

Ytterligare resurser

`mltable` Installera Python SDK