Poznámka:
Přístup k této stránce vyžaduje autorizaci. Můžete se zkusit přihlásit nebo změnit adresáře.
Přístup k této stránce vyžaduje autorizaci. Můžete zkusit změnit adresáře.
PLATÍ PRO:
Rozšíření Azure CLI ml v2 (aktuální)Python SDK azure-ai-ml v2 (aktuální)
V tomto článku se dozvíte:
- Jak číst data z úložiště Azure v úloze Azure Machine Learning
- Jak zapisovat data z úlohy Azure Machine Learning do Služby Azure Storage
- Rozdíl mezi režimy připojení a stahování .
- Jak používat identitu uživatele a spravovanou identitu pro přístup k datům.
- Nastavení připojení disků dostupná v úloze.
- Optimální nastavení montáže pro běžné scénáře.
- Přístup k datovým prostředkům V1
Požadavky
Předplatné Azure. Pokud ještě nemáte předplatné Azure, vytvořte si napřed bezplatný účet. Vyzkoušejte bezplatnou nebo placenou verzi služby Azure Machine Learning.
Balíček Pythonu pro azure-identity (
pip install azure-identity).Pracovní prostor služby Azure Machine Learning.
Cílový výpočetní objekt služby Azure Machine Learning (například výpočetní cluster s názvem
cpu-cluster).
Rychlý start
Než prozkoumáte podrobné možnosti, které máte k dispozici při přístupu k datům, nejprve popíšeme relevantní fragmenty kódu pro přístup k datům.
Čtení dat z úložiště Azure v úloze Azure Machine Learning
V tomto příkladu odešlete úlohu Služby Azure Machine Learning, která přistupuje k datům z veřejného účtu úložiště objektů blob. Fragment kódu ale můžete přizpůsobit tak, aby přistupoval k vlastním datům v privátním účtu azure Storage. Aktualizujte cestu, jak je popsáno zde. Azure Machine Learning bezproblémově zajišťuje ověřování v cloudovém úložišti a průchod Microsoft Entra. Když odešlete úlohu, můžete zvolit:
- Identita uživatele: Předání identity Microsoft Entra pro přístup k datům
- Spravovaná identita: Použití spravované identity cílového výpočetního objektu pro přístup k datům
- Žádné: Nezadávejte identitu pro přístup k datům. Použití žádné při použití úložišť dat založených na přihlašovacích údajích (klíč/token SAS) nebo při přístupu k veřejným datům
Návod
Pokud k ověření používáte klíče nebo tokeny SAS, doporučujeme vytvořit úložiště dat služby Azure Machine Learning. Modul runtime se automaticky připojí k úložišti bez vystavení vašich přihlašovacích údajů.
from azure.ai.ml import command, Input, MLClient
from azure.ai.ml.entities import Data, UserIdentityConfiguration, ManagedIdentityConfiguration
from azure.ai.ml.constants import AssetTypes, InputOutputModes
from azure.identity import DefaultAzureCredential
# Set your subscription, resource group and workspace name:
subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace = "<AML_WORKSPACE_NAME>"
# connect to the AzureML workspace
ml_client = MLClient(
DefaultAzureCredential(), subscription_id, resource_group, workspace
)
# ==============================================================
# Set the URI path for the data.
# Supported `path` formats for input include:
# local: `./<path>
# Blob: wasbs://<container_name>@<account_name>.blob.core.windows.net/<path>
# ADLS: abfss://<file_system>@<account_name>.dfs.core.windows.net/<path>
# Datastore: azureml://datastores/<data_store_name>/paths/<path>
# Data Asset: azureml:<my_data>:<version>
# Supported `path` format for output is:
# Datastore: azureml://datastores/<data_store_name>/paths/<path>
# We set the input path to a file on a public blob container
# ==============================================================
path = "wasbs://data@azuremlexampledata.blob.core.windows.net/titanic.csv"
# ==============================================================
# What type of data does the path point to? Options include:
# data_type = AssetTypes.URI_FILE # a specific file
# data_type = AssetTypes.URI_FOLDER # a folder
# data_type = AssetTypes.MLTABLE # an mltable
# The path we set above is a specific file
# ==============================================================
data_type = AssetTypes.URI_FILE
# ==============================================================
# Set the mode. The popular modes include:
# mode = InputOutputModes.RO_MOUNT # Read-only mount on the compute target
# mode = InputOutputModes.DOWNLOAD # Download the data to the compute target
# ==============================================================
mode = InputOutputModes.RO_MOUNT
# ==============================================================
# You can set the identity you want to use in a job to access the data. Options include:
# identity = UserIdentityConfiguration() # Use the user's identity
# identity = ManagedIdentityConfiguration() # Use the compute target managed identity
# ==============================================================
# This example accesses public data, so we don't need an identity.
# You also set identity to None if you use a credential-based datastore
identity = None
# Set the input for the job:
inputs = {
"input_data": Input(type=data_type, path=path, mode=mode)
}
# This command job uses the head Linux command to print the first 10 lines of the file
job = command(
command="head ${{inputs.input_data}}",
inputs=inputs,
environment="azureml://registries/azureml/environments/sklearn-1.1/versions/4",
compute="cpu-cluster",
identity=identity,
)
# Submit the command
ml_client.jobs.create_or_update(job)
Zápis dat z úlohy Azure Machine Learning do Azure Storage
V tomto příkladu odešlete úlohu Služby Azure Machine Learning, která zapisuje data do výchozího úložiště dat služby Azure Machine Learning. Volitelně můžete nastavit hodnotu name datového aktiva, abyste vytvořili datové aktivum ve výstupu.
from azure.ai.ml import command, Input, Output, MLClient
from azure.ai.ml.constants import AssetTypes, InputOutputModes
from azure.identity import DefaultAzureCredential
# Set your subscription, resource group and workspace name:
subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace = "<AML_WORKSPACE_NAME>"
# connect to the AzureML workspace
ml_client = MLClient(
DefaultAzureCredential(), subscription_id, resource_group, workspace
)
# ==============================================================
# Set the URI path for the data.
# Supported `path` formats for input include:
# local: `./<path>
# Blob: wasbs://<container_name>@<account_name>.blob.core.windows.net/<path>
# ADLS: abfss://<file_system>@<account_name>.dfs.core.windows.net/<path>
# Datastore: azureml://datastores/<data_store_name>/paths/<path>
# Data Asset: azureml:<my_data>:<version>
# Supported `path` format for output is:
# Datastore: azureml://datastores/<data_store_name>/paths/<path>
# As an example, we set the input path to a file on a public blob container
# As an example, we set the output path to a folder in the default datastore
# ==============================================================
input_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/titanic.csv"
output_path = "azureml://datastores/workspaceblobstore/paths/quickstart-output/titanic.csv"
# ==============================================================
# What type of data are you pointing to?
# AssetTypes.URI_FILE (a specific file)
# AssetTypes.URI_FOLDER (a folder)
# AssetTypes.MLTABLE (a table)
# The path we set above is a specific file
# ==============================================================
data_type = AssetTypes.URI_FILE
# ==============================================================
# Set the input mode. The most commonly-used modes:
# InputOutputModes.RO_MOUNT
# InputOutputModes.DOWNLOAD
# Set the mode to Read Only (RO) to mount the data
# ==============================================================
input_mode = InputOutputModes.RO_MOUNT
# ==============================================================
# Set the output mode. The most commonly-used modes:
# InputOutputModes.RW_MOUNT
# InputOutputModes.UPLOAD
# Set the mode to Read Write (RW) to mount the data
# ==============================================================
output_mode = InputOutputModes.RW_MOUNT
# Set the input and output for the job:
inputs = {
"input_data": Input(type=data_type, path=input_path, mode=input_mode)
}
outputs = {
"output_data": Output(type=data_type,
path=output_path,
mode=output_mode,
# optional: if you want to create a data asset from the output,
# then uncomment `name` (`name` can be set without setting `version`, and in this way, we will set `version` automatically for you)
# name = "<name_of_data_asset>", # use `name` and `version` to create a data asset from the output
# version = "<version>",
)
}
# This command job copies the data to your default Datastore
job = command(
command="cp ${{inputs.input_data}} ${{outputs.output_data}}",
inputs=inputs,
outputs=outputs,
environment="azureml://registries/azureml/environments/sklearn-1.1/versions/4",
compute="cpu-cluster",
)
# Submit the command
ml_client.jobs.create_or_update(job)
Modul runtime dat služby Azure Machine Learning
Když odešlete úlohu, modul runtime dat Azure Machine Learning řídí načítání dat z umístění úložiště do cílového výpočetního objektu. Modul runtime dat Služby Azure Machine Learning je optimalizovaný pro rychlost a efektivitu úloh strojového učení. Mezi klíčové výhody patří:
- Načítání dat zapsané v jazyce Rust, známém svou vysokou rychlostí a paměťovou efektivitou. U souběžných stahování dat se Rust vyhne problémům s globálním zámkem interpreta Pythonu (GIL).
- Lehká hmotnost; Rust nemá žádné závislosti na jiných technologiích – například JVM. V důsledku toho se modul runtime rychle nainstaluje a nevyprázdní další prostředky (procesor, paměť) do cílového výpočetního objektu.
- Víceprocesové (paralelní) načítání dat
- Předem načte data jako úlohu na pozadí na jednom nebo více procesorech, aby bylo možné při hlubokém učení lépe využít GPU.
- Bezproblémové řízení ověřování do cloudového úložiště
- Poskytuje možnosti připojení dat (streamu) nebo stažení všech dat. Další informace najdete v částech Připojit (streamování) a Stáhnout .
- Bezproblémová integrace s fsspec – jednotné pythonické rozhraní pro místní, vzdálené a vložené systémy souborů a úložiště bajtů.
Návod
Doporučujeme použít modul pro běh dat služby Azure Machine Learning místo vytvoření vlastní funkce pro připojování a stahování dat ve vašem kódu pro trénink (klient). Zjistili jsme omezení propustnosti úložiště, když klientský kód používá Python ke stahování dat z úložiště kvůli problémům s globálním zámkem interpreta (GIL).
Cesty
Při zadávání vstupu nebo výstupu dat do úlohy je nutné zadat path parametr, který odkazuje na umístění dat. Tato tabulka ukazuje různá umístění dat, která Azure Machine Learning podporuje, a obsahuje path příklady parametrů:
| Umístění | Příklady | Vstup | Výstup |
|---|---|---|---|
| Cesta ve vašem místním počítači | ./home/username/data/my_data |
Й | N |
| Cesta na veřejném serveru HTTP(S) | https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv |
Й | N |
| Cesta ve službě Azure Storage | wasbs://<container_name>@<account_name>.blob.core.windows.net/<path>abfss://<file_system>@<account_name>.dfs.core.windows.net/<path> |
Y, pouze pro ověřování na základě identity | N |
| Cesta k úložišti dat služby Azure Machine Learning | azureml://datastores/<data_store_name>/paths/<path> |
Й | Й |
| Cesta k datovému aktivu | azureml:<my_data>:<version> |
Й | N, ale můžete použít name a version k vytvoření datového zdroje na základě výstupu. |
Režimy
Když spustíte úlohu s datovými vstupy a výstupy, můžete si vybrat z těchto možností režimu :
ro_mount: Připojte úložiště jako pouze pro čtení na lokální výpočetní cíl SSD disku.rw_mount: Připojte umístění úložiště jako čtení a zápis na cílový výpočetní objekt místního disku (SSD).download: Stáhněte data z umístění úložiště do cílového výpočetního objektu místního disku (SSD).upload: Nahrajte data z cílového výpočetního objektu do umístění úložiště.eval_mount/eval_download:Tyto režimy jsou jedinečné pro MLTable. V některých scénářích může tabulka MLTable přinést soubory, které se mohou nacházet v účtu úložiště, který se liší od účtu úložiště, který je hostitelem souboru MLTable. Nebo MLTable může vytvořit podmnožinu dat nebo je zamíchat, která jsou umístěna v prostředku úložiště. Toto zobrazení podmnožina/náhodného prohazování se zobrazí jenom v případech, kdy modul runtime dat Služby Azure Machine Learning vyhodnotí soubor MLTable. Tento diagram například ukazuje, jak se tabulka MLTable používá seval_mountneboeval_downloadk pořizování obrázků ze dvou různých kontejnerů úložiště a anotace uložené v souboru umístěném v jiném účtu úložiště a jak je poté možné připojit nebo stáhnout do systému souborů vzdáleného cílového výpočetního objektu.
Složka
camera1,camera2složka aannotations.csvsoubor jsou pak přístupné v systému souborů cílového výpočetního objektu ve struktuře složek:/INPUT_DATA ├── account-a │ ├── container1 │ │ └── camera1 │ │ ├── image1.jpg │ │ └── image2.jpg │ └── container2 │ └── camera2 │ ├── image1.jpg │ └── image2.jpg └── account-b └── container1 └── annotations.csvdirect: Můžete chtít číst data přímo z identifikátoru URI prostřednictvím jiných rozhraní API, a ne procházet modulem runtime dat služby Azure Machine Learning. Například můžete chtít přistupovat k datům v úložišti s3 (s adresou URL ve stylu virtuálního hostitele nebo ve stylu cestyhttps) pomocí klienta boto s3. Identifikátor URI vstupu můžete získat jako řetězec s režimemdirect. V úlohách Sparku se používá přímý režim, protože metodyspark.read_*()vědí, jak zpracovat URI. Pro úlohy mimo Spark je vaší zodpovědností spravovat přístupové přihlašovací údaje. Musíte například explicitně použít Managed Service Identity (MSI) nebo jiný způsob zprostředkování přístupu.
Tato tabulka ukazuje možné režimy pro různé kombinace typu, režimu, vstupu a výstupu:
| Typ | Vstup a výstup | upload |
download |
ro_mount |
rw_mount |
direct |
eval_download |
eval_mount |
|---|---|---|---|---|---|---|---|---|
uri_folder |
Vstup | ✓ | ✓ | ✓ | ||||
uri_file |
Vstup | ✓ | ✓ | ✓ | ||||
mltable |
Vstup | ✓ | ✓ | ✓ | ✓ | ✓ | ||
uri_folder |
Výstup | ✓ | ✓ | |||||
uri_file |
Výstup | ✓ | ✓ | |||||
mltable |
Výstup | ✓ | ✓ | ✓ |
Stáhnout
V režimu stahování se všechna vstupní data zkopírují na místní disk (SSD) cílového výpočetního objektu. Modul runtime dat služby Azure Machine Learning spustí trénovací skript uživatele, jakmile se zkopírují všechna data. Když se spustí uživatelský skript, načte data z místního disku stejně jako ostatní soubory. Po dokončení úlohy se data odeberou z disku cílového výpočetního objektu.
| Výhody | Nevýhody |
|---|---|
| Při spuštění trénování jsou všechna data k dispozici na místním disku (SSD) cílového výpočetního objektu pro trénovací skript. Nevyžaduje se žádná interakce se službou Azure Storage nebo sítí. | Datová sada se musí zcela vejít na cílový výpočetní disk. |
| Po spuštění uživatelského skriptu neexistují žádné závislosti na spolehlivosti úložiště nebo sítě. | Stáhnou se celá datová sada (pokud trénování potřebuje náhodně vybrat jenom malou část dat, velká část stahování se pak promarní). |
| Modul runtime dat Azure Machine Learning dokáže paralelizovat stahování, což výrazně ovlivňuje výkon při práci s mnoha malými soubory, a maximalizovat propustnost sítě a úložiště. | Úloha čeká na stažení všech dat na místní disk cílového výpočetního objektu. V případě odeslané úlohy hlubokého učení jsou GPU nečinné, dokud nebudou data připravená. |
| Vrstva FUSE nepřidává žádné nevyhnutelné režijní náklady (kolečko: volání v uživatelském skriptu v prostoru uživatele → jádro → uživatelský prostor FUSE daemona → jádro → odpověď na uživatelský skript v uživatelském prostoru). | Změny úložiště se po dokončení stahování neprojeví na datech. |
Kdy použít stahování
- Data jsou dostatečně malá, aby se vešla na disk cílového výpočetního objektu bez zásahu do jiného trénování.
- Trénování používá většinu nebo všechny datové sady.
- Proces trénování čte soubory z datové sady více než jednou.
- Trénování musí přeskakovat na náhodné pozice velkého souboru.
- Před zahájením trénování je v pořádku počkat na stažení všech dat.
Dostupná nastavení stahování
Nastavení stahování můžete vyladit pomocí těchto proměnných prostředí ve své úloze:
| Název proměnné prostředí | Typ | Výchozí hodnota | Popis |
|---|---|---|---|
RSLEX_DOWNLOADER_THREADS |
u64 | NUMBER_OF_CPU_CORES * 4 |
Počet souběžných vláken ke stažení |
AZUREML_DATASET_HTTP_RETRY_COUNT |
u64 | 7 | Počet pokusů o opakování jednotlivých úložišť nebo http požadavku k obnovení z přechodných chyb. |
Ve své úloze můžete výše uvedené výchozí hodnoty změnit nastavením proměnných prostředí , například:
Pro stručnost ukazujeme, jak definovat proměnné prostředí v úloze.
from azure.ai.ml import command
env_var = {
"RSLEX_DOWNLOADER_THREADS": 64,
"AZUREML_DATASET_HTTP_RETRY_COUNT": 10
}
job = command(
environment_variables=env_var
)
Stažení metrik výkonu
Velikost virtuálního počítače cílového výpočetního objektu má vliv na dobu stahování dat. Konkrétně:
- Počet jader. Čím více jader je k dispozici, tím více souběžnosti a tím rychlejší stahování.
- Očekávaná šířka pásma sítě. Každý virtuální počítač v Azure má maximální propustnost z síťové karty (NIC).
Poznámka:
U virtuálních počítačů s GPU A100 může Azure Machine Learning runtime nasytit síťový adaptér (síťovou kartu) při stahování dat do cílového výpočetního prostředku (~24 Gbit/s): Teoretická maximální možná propustnost.
Tato tabulka ukazuje výkon stahování, který může modul runtime dat služby Azure Machine Learning zpracovat pro 100GB soubor na virtuálním Standard_D15_v2 počítači (20 jader, propustnost sítě 25 Gbit/s):
| Struktura dat | Pouze stahování (sekundy) | Stažení a výpočet MD5 (sekundy) | Dosažená propustnost (Gbit/s) |
|---|---|---|---|
| Soubory, každý o velikosti 10 x 10 GB | 55.74 | 260.97 | 14.35 Gbit/s |
| 100 souborů po 1 GB | 58.09 | 259.47 | 13,77 Gbit/s |
| Soubor 1 x 100 GB | 96.13 | 300.61 | 8,32 Gbit/s |
Vidíme, že větší soubor, rozdělený na menší soubory, může zlepšit výkon stahování z důvodu paralelismu. Doporučujeme, abyste se vyhnuli příliš malým souborům (méně než 4 MB), protože doba potřebná k odeslání požadavků na úložiště se zvyšuje vzhledem k času strávenému stažením datové části. Další informace naleznete v článku Problém s mnoha malými soubory.
Připojení (streamování)
V režimu připojení využívá datová funkce Azure Machine Learning funkci FUSE (systém souborů v uživatelském prostoru) v Linuxu k vytvoření emulovaného systému souborů. Místo stažení všech dat na místní disk (SSD) cílového výpočetního objektu může modul runtime reagovat na akce skriptu uživatele v reálném čase. Například "otevřít soubor", "načíst 2KB blok z pozice X", "vypsat obsah adresáře".
| Výhody | Nevýhody |
|---|---|
| Data, která překračují kapacitu místního disku cílového výpočetního prostředku, je možné použít (ne omezená výpočetním hardwarem). | Přidaná režie modulu FUSE pro Linux. |
| Žádné zpoždění na začátku trénování (na rozdíl od režimu stahování). | Závislost na chování kódu uživatele (pokud trénovací kód, který postupně čte malé soubory v jednom připojení vlákna, také vyžaduje data z úložiště, nemusí maximalizovat propustnost sítě nebo úložiště). |
| Další dostupná nastavení pro vyladění scénáře použití | Žádná podpora windows. |
| Z úložiště se čtou jenom data potřebná pro trénování. |
Kdy použít mountování
- Data jsou velká a nevejdou se na cílový výpočetní místní disk.
- Každý jednotlivý výpočetní uzel v clusteru nemusí číst celou datovou sadu (náhodný soubor nebo řádky ve výběru souboru CSV atd.).
- Zpoždění čekání na stažení všech dat před zahájením trénování se může stát problémem (nečinný čas GPU).
Dostupná nastavení připojení
Nastavení montování můžete v úloze vyladit pomocí těchto proměnných prostředí:
| Název proměnné env | Typ | Výchozí hodnota | Popis |
|---|---|---|---|
DATASET_MOUNT_ATTRIBUTE_CACHE_TTL |
u64 | Nenastaveno (mezipaměť nikdy nevyprší) | Čas, v milisekundách, k zachování výsledků volání getattr v mezipaměti a k zamezení opakovaného získávání těchto informací z úložiště. |
DATASET_RESERVED_FREE_DISK_SPACE |
u64 | 150 MB | Účelem konfigurace systému je zajistit, aby byl výpočetní výkon v pořádku. Bez ohledu na hodnoty ostatních nastavení nepoužívá modul runtime dat služby Azure Machine Learning poslední RESERVED_FREE_DISK_SPACE bajty místa na disku. |
DATASET_MOUNT_CACHE_SIZE |
usize | Bez omezení | Určuje, kolik místa na disku může připojení použít. Kladná hodnota nastaví absolutní hodnotu v bajtech. Záporná hodnota nastaví, kolik místa na disku necháte volné. Tato tabulka poskytuje další možnosti mezipaměti disku.
KB Podporuje MBa GB modifikátory pro usnadnění. |
DATASET_MOUNT_FILE_CACHE_PRUNE_THRESHOLD |
f64 | 1.0 | Připojení svazku spustí prořezávání mezipaměti, když je mezipaměť zaplněna až na AVAILABLE_CACHE_SIZE * DATASET_MOUNT_FILE_CACHE_PRUNE_THRESHOLD. Měla by být mezi 0 a 1. Nastavení této hodnoty na < 1 spustí předčasné vyřazení mezipaměti na pozadí.
AVAILABLE_CACHE_SIZE není proměnná prostředí, kterou můžete upravovat ani zobrazovat přímo. V tomto kontextu odkazuje na "počet bajtů, které systém vypočítá jako dostupný pro ukládání do mezipaměti". Tato hodnota závisí na faktorech, jako je velikost disku, velikost místa na disku vyžadované pro stav systému a konfigurace nastavené v proměnných prostředí (například DATASET_RESERVED_FREE_DISK_SPACE a DATASET_MOUNT_CACHE_SIZE). |
DATASET_MOUNT_FILE_CACHE_PRUNE_TARGET |
f64 | 0,7 | Vyřazení mezipaměti se pokusí uvolnit alespoň (1-DATASET_MOUNT_FILE_CACHE_PRUNE_TARGET) místo v mezipaměti. |
DATASET_MOUNT_READ_BLOCK_SIZE |
usize | 2 MB | Velikost bloku čtení streamu Pokud je soubor dostatečně velký, požádejte o alespoň DATASET_MOUNT_READ_BLOCK_SIZE dat z úložiště a ukládejte do mezipaměti, i když operace fuse požadovaného čtení byla pro menší množství dat. |
DATASET_MOUNT_READ_BUFFER_BLOCK_COUNT |
usize | 32 | Počet bloků, které se mají předem načíst (čtení bloku k spustí na pozadí přednačítání bloků k+1, ..., k.+DATASET_MOUNT_READ_BUFFER_BLOCK_COUNT) |
DATASET_MOUNT_READ_THREADS |
usize | NUMBER_OF_CORES * 4 |
Počet vláken předběžného načítání na pozadí |
DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED |
Booleova hodnota | nepravdivý | Povolte ukládání do mezipaměti založené na blokech. |
DATASET_MOUNT_MEMORY_CACHE_SIZE |
usize | 128 MB | Platí jenom pro ukládání do mezipaměti založené na blokech. Velikost blokové mezipaměti RAM, kterou lze využít. Hodnota 0 zakáže ukládání do mezipaměti zcela. |
DATASET_MOUNT_BLOCK_FILE_CACHE_ENABLED |
Booleova hodnota | pravda | Platí jenom pro ukládání do mezipaměti založené na blokech. Pokud je hodnota nastavena na true, ukládání do mezipaměti používá místní pevný disk k ukládání bloků do mezipaměti. |
DATASET_MOUNT_BLOCK_FILE_CACHE_MAX_QUEUE_SIZE |
usize | 512 MB | Platí jenom pro ukládání do mezipaměti založené na blokech. Blokové ukládání do mezipaměti zapisuje blok uložený v mezipaměti na místní disk na pozadí. Toto nastavení určuje, kolik paměti může připojení paměti použít k ukládání bloků čekajících na vyprázdnění do místní mezipaměti disku. |
DATASET_MOUNT_BLOCK_FILE_CACHE_WRITE_THREADS |
usize | NUMBER_OF_CORES * 2 |
Platí jenom pro ukládání do mezipaměti založené na blokech. Počet vláken na pozadí, které blokové ukládání do mezipaměti používá k zápisu stažených bloků na místní disk cílového výpočetního objektu. |
DATASET_UNMOUNT_TIMEOUT_SECONDS |
u64 | 30 | Doba v sekundách pro unmount, aby (řádně) dokončil všechny čekající operace (například volání pro vyprázdnění), než dojde k násilnému ukončení smyčky pro montování zpráv. |
Ve své úloze můžete výše uvedené výchozí hodnoty změnit nastavením proměnných prostředí, například:
from azure.ai.ml import command
env_var = {
"DATASET_MOUNT_BLOCK_FILE_CACHE_ENABLED": True
}
job = command(
environment_variables=env_var
)
Režim otevření na základě bloků
Režim otevření na základě bloků rozdělí jednotlivé soubory na bloky předdefinované velikosti (s výjimkou posledního bloku). Žádost o čtení ze zadané pozice vyžaduje odpovídající blok z úložiště a okamžitě vrátí požadovaná data. Čtení také aktivuje na pozadí předběžné načtení dalšího N bloků pomocí více vláken (těchto vláken optimalizovaných pro sekvenční čtení). Stažené bloky se ukládají do mezipaměti ve dvou vrstvách (RAM a místní disk).
| Výhody | Nevýhody |
|---|---|
| Rychlé doručování dat do trénovacího skriptu (méně blokování pro části, které ještě nebyly žádány). | Náhodné čtení může plýtvat dopředu přednačtenými bloky. |
| Více práce se přesměruje na vlákna na pozadí (předběžné načítání nebo ukládání do mezipaměti). Trénování pak může pokračovat. | Zvýšená režie při navigaci mezi jednotlivými mezipamětmi ve srovnání s přímým čtením ze souboru uloženého v mezipaměti na místním disku (například v režimu ukládání celé soubory do mezipaměti). |
| Z úložiště se čtou jenom požadovaná data (plus předběžné načtení). | |
| Pro malá data se používá rychlá mezipaměť založená na paměti RAM. |
Kdy použít režim otevření založeného na blokech
Doporučuje se pro většinu scénářů s výjimkou případů, kdy potřebujete rychlé čtení z náhodných umístění souborů. V takových případech použijte režim otevření celé mezipaměti souborů.
Režim otevření celé mezipaměti souborů
Při otevření souboru ve složce připojení (například f = open(path, args)) v režimu celého souboru se proces zablokuje, dokud se celý soubor nestáhne do adresáře vyrovnávací paměti cílového počítače na disku. Všechna následná volání čtení se přesměrovávají do souboru uloženého v mezipaměti, takže není potřeba žádná interakce s úložištěm. Pokud mezipaměť nemá dostatek volného místa pro uložení aktuálního souboru, systém se pokusí uvolnit místo odstraněním nejdéle nepoužitého souboru z mezipaměti. V případech, kdy nelze soubor umístit na disk (s ohledem na nastavení mezipaměti), běhové prostředí dat se přesune do režimu průběžného streamování.
| Výhody | Nevýhody |
|---|---|
| Po otevření souboru nejsou žádné závislosti na spolehlivosti úložiště a propustnosti. | Otevření volání je zablokováno, dokud se nestáhne celý soubor. |
| Rychlé náhodné čtení (čtení bloků dat z náhodných míst souboru) | Celý soubor se načte z úložiště, i když některé části souboru nemusí být potřeba. |
Kdy ji použít
Pokud jsou potřeba náhodné čtení pro relativně velké soubory, které překračují 128 MB.
Využití
Nastavte proměnnou prostředí DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED na false ve vaší úloze:
from azure.ai.ml import command
env_var = {
"DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED": False
}
job = command(
environment_variables=env_var
)
Připojení: Výpis souborů
Při práci s miliony souborů se vyhněte rekurzivnímu výpisu , například ls -R /mnt/dataset/folder/. Rekurzivní výpis aktivuje mnoho volání pro výpis obsahu adresáře nadřazeného adresáře. Pak vyžaduje samostatné rekurzivní volání pro každý adresář uvnitř všech podřízených úrovní. Azure Storage obvykle umožňuje vrácení pouze 5 000 prvků na jeden požadavek na seznam. V důsledku toho rekurzivní výpis 1M složek obsahujících 10 souborů vyžaduje 1,000,000 / 5000 + 1,000,000 = 1,000,200 požadavky na úložiště. Ve srovnání s 1 000 složkami s 10 000 soubory by pro rekurzivní výpis potřebovalo pouze 1 001 požadavků na úložiště.
Přípojný bod služby Azure Machine Learning provádí výpis pomocí líného načítání. Pokud tedy chcete vypsat mnoho malých souborů, je lepší použít volání iterativní klientské knihovny (například os.scandir() v Pythonu) místo volání klientské knihovny, které vrací úplný seznam (například os.listdir() v Pythonu). Iterativní volání klientské knihovny vrátí generátor, což znamená, že nemusí čekat na načtení celého seznamu. Pak může pokračovat rychleji.
Tato tabulka porovnává čas potřebný pro Python os.scandir() a os.listdir() funkce k vypsání obsahu složky, která obsahuje přibližně 4 miliony souborů v ploché struktuře.
| Metrika | os.scandir() |
os.listdir() |
|---|---|---|
| Čas na získání první položky (sekundy) | 0.67 | 553.79 |
| Čas získat prvních 50 tisíc položek (sekundy) | 9.56 | 562.73 |
| Čas získání všech položek (sek) | 558.35 | 582.14 |
Optimální nastavení montáže pro běžné scénáře
Při určitých běžných scénářích představujeme optimální nastavení pro připojení, která je potřeba nastavit ve vaší úloze Azure Machine Learning.
Čtení velkého souboru postupně jednou (zpracování řádků v souboru CSV)
Do sekce konfigurace úlohy Azure Machine Learning zahrňte tato nastavení připojení environment_variables.
Poznámka:
Pokud chcete používat bezserverové výpočetní prostředky, odstraňte compute="cpu-cluster", ho v tomto kódu.
from azure.ai.ml import command
env_var = {
"DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED": True, # Enable block-based caching
"DATASET_MOUNT_BLOCK_FILE_CACHE_ENABLED": False, # Disable caching on disk
"DATASET_MOUNT_MEMORY_CACHE_SIZE": 0, # Disabling in-memory caching
# Increase the number of blocks used for prefetch. This leads to use of more RAM (2 MB * #value set).
# Can adjust up and down for fine-tuning, depending on the actual data processing pattern.
# An optimal setting based on our test ~= the number of prefetching threads (#CPU_CORES * 4 by default)
"DATASET_MOUNT_READ_BUFFER_BLOCK_COUNT": 80,
}
job = command(
environment_variables=env_var
)
Čtení velkého souboru jednou z více vláken (zpracování dělených souborů CSV ve více vláknech)
Do sekce konfigurace úlohy Azure Machine Learning zahrňte tato nastavení připojení environment_variables.
from azure.ai.ml import command
env_var = {
"DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED": True, # Enable block-based caching
"DATASET_MOUNT_BLOCK_FILE_CACHE_ENABLED": False, # Disable caching on disk
"DATASET_MOUNT_MEMORY_CACHE_SIZE": 0, # Disabling in-memory caching
}
job = command(
environment_variables=env_var
)
Čtení milionů malých souborů (obrázků) z více vláken jednou (jedno epochové trénování obrázků)
Do sekce konfigurace úlohy Azure Machine Learning zahrňte tato nastavení připojení environment_variables.
from azure.ai.ml import command
env_var = {
"DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED": True, # Enable block-based caching
"DATASET_MOUNT_BLOCK_FILE_CACHE_ENABLED": False, # Disable caching on disk
"DATASET_MOUNT_MEMORY_CACHE_SIZE": 0, # Disabling in-memory caching
}
job = command(
environment_variables=env_var
)
Čtení milionů malých souborů (obrázků) z více vláken opakovaně (v průběhu více epoch při trénování na obrázcích)
Do sekce konfigurace úlohy Azure Machine Learning zahrňte tato nastavení připojení environment_variables.
from azure.ai.ml import command
env_var = {
"DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED": True, # Enable block-based caching
}
job = command(
environment_variables=env_var
)
Čtení velkého souboru s náhodným hledáním (například obsluha souborové databáze z připojené složky)
Do sekce konfigurace úlohy Azure Machine Learning zahrňte tato nastavení připojení environment_variables.
from azure.ai.ml import command
env_var = {
"DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED": False, # Disable block-based caching
}
job = command(
environment_variables=env_var
)
Diagnostika a řešení kritických bodů načítání dat
Při spuštění úlohy Azure Machine Learning s daty určuje mode vstupu způsob, jak se bajty čtou z úložiště a ukládají se do mezipaměti na místním SSD disku cílového výpočetního prostředku. V režimu stahování se všechna data ukládají na disk před spuštěním uživatelského kódu. Maximální rychlost stahování ovlivňuje několik faktorů:
- Počet paralelních vláken
- Počet souborů
- Velikost souboru
V režimu připojení musí uživatelský kód začít otevírat soubory, než se data začnou ukládat do mezipaměti. Různá nastavení připojení vedou k různým chováním při čtení a ukládání do mezipaměti. Různé faktory ovlivňují rychlost načítání dat z úložiště:
- Umístění dat pro výpočty: Úložiště a cílové umístění výpočetních prostředků by měly být stejné. Pokud se úložiště a cíl výpočetních prostředků nachází v různých oblastech, výkon se sníží, protože data se musí přenášet mezi oblastmi. Další informace o tom, jak zajistit, aby vaše data se nacházela spolu s výpočetními jednotkami, najdete v tématu Colocate data s výpočetními jednotkami.
-
Cílová velikost výpočetních prostředků: Malé výpočetní prostředky mají nižší počet jader (menší paralelismus) a menší očekávanou šířku pásma sítě ve srovnání s většími velikostmi výpočetních prostředků – oba faktory ovlivňují výkon načítání dat.
- Pokud například používáte malou velikost virtuálního počítače, například
Standard_D2_v2(2 jádra, 1 500 Mb/s síťové karty) a pokusíte se načíst 50 000 MB (50 GB) dat, nejlepší dosažitelná doba načítání dat by byla ~270 sekund (za předpokladu, že saturujete síťovou kartu při propustnosti 187,5 MB/s). Naproti tomuStandard_D5_v2(16 jader, 12 000 Mb/s) by se stejná data načetla do přibližně 33 sekund (za předpokladu, že síťové rozhraní saturujete při propustnosti 1500 MB/s).
- Pokud například používáte malou velikost virtuálního počítače, například
- Úroveň úložiště: Pro většinu scénářů – včetně velkých jazykových modelů (LLM) – storage úrovně Standard poskytuje nejlepší profil nákladů a výkonu. Pokud ale máte mnoho malých souborů, nabízí Premium Storage lepší profil nákladů a výkonu. Další informace najdete v možnostech služby Azure Storage.
- Zatížení úložiště: Pokud je účet úložiště pod vysokým zatížením – například mnoho uzlů GPU v clusteru požadujících data – pak riskujete dosažení výstupní kapacity úložiště. Pro více informací si přečtěte zatížení úložiště. Pokud máte mnoho malých souborů, které potřebují přístup paralelně, možná dosáhnete limitů požadavků úložiště. Přečtěte si aktuální informace o limitech pro požadavky na výchozí kapacitu i úložiště v cílech škálování pro účty úložiště úrovně Standard.
- Vzor přístupu k datům v uživatelském kódu: Při použití režimu připojení se data načítají na základě otevřených a přečtených akcí v kódu. Například při čtení náhodných oddílů velkého souboru může výchozí nastavení předběžného načtení dat připojení vést ke stahování bloků, které se nebudou číst. Možná budete muset vyladit některá nastavení, abyste dosáhli maximální propustnosti. Další informace najdete v tématu Optimální nastavení montáže pro běžné scénáře.
Použití protokolů k diagnostice problémů
Pro přístup k záznamům modulu runtime dat z vaší úlohy:
- Na stránce úlohy vyberte Výstupy a protokoly .
- Vyberte složku system_logs následovanou data_capability složkou.
- Měli byste vidět dva logovací soubory:
Soubor protokolu data-capability.log zobrazuje základní informace o době strávené při načítání klíčových dat. Například při stahování dat protokoluje modul runtime časy zahájení a dokončení aktivity stahování:
INFO 2023-05-18 17:14:47,790 sdk_logger.py:44 [28] - ActivityStarted, download
INFO 2023-05-18 17:14:50,295 sdk_logger.py:44 [28] - ActivityCompleted: Activity=download, HowEnded=Success, Duration=2504.39 [ms]
Pokud je propustnost stahování zlomkem očekávané šířky pásma sítě pro velikost virtuálního počítače, můžete zkontrolovat soubor protokolu rslex.log.<ČASOVÉ RAZÍTKO>. Tento soubor obsahuje veškeré podrobné protokolování z modulu runtime založeného na Rustu; Například paralelizace:
2023-05-18T14:08:25.388670Z INFO copy_uri:copy_uri:copy_dataset:write_streams_to_files:collect:reduce:reduce_and_combine:reduce:get_iter: rslex::prefetching: close time.busy=23.2µs time.idle=1.90µs sessionId=012ea46a-341c-4258-8aba-90bde4fdfb51 source=Dataset[Partitions: 1, Sources: 1] file_name_column=None break_on_first_error=true skip_existing_files=false parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4 i=0 index=0
2023-05-18T14:08:25.388731Z INFO copy_uri:copy_uri:copy_dataset:write_streams_to_files:collect:reduce:reduce_and_combine:reduce: rslex::dataset_crossbeam: close time.busy=90.9µs time.idle=9.10µs sessionId=012ea46a-341c-4258-8aba-90bde4fdfb51 source=Dataset[Partitions: 1, Sources: 1] file_name_column=None break_on_first_error=true skip_existing_files=false parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4 i=0
2023-05-18T14:08:25.388762Z INFO copy_uri:copy_uri:copy_dataset:write_streams_to_files:collect:reduce:reduce_and_combine:combine: rslex::dataset_crossbeam: close time.busy=1.22ms time.idle=9.50µs sessionId=012ea46a-341c-4258-8aba-90bde4fdfb51 source=Dataset[Partitions: 1, Sources: 1] file_name_column=None break_on_first_error=true skip_existing_files=false parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4 self=Dataset[Partitions: 1, Sources: 1] parallelization_degree=4
Soubor rslex.log poskytuje podrobnosti o veškerém kopírování souboru bez ohledu na to, jestli jste zvolili režimy připojení nebo stahování. Popisuje také použitá nastavení (proměnné prostředí). Pokud chcete spustit ladění, zkontrolujte, jestli jste nastavili optimální nastavení připojení pro běžné scénáře.
Monitorování úložiště Azure
Na Azure Portal vyberte svůj účet úložiště a poté metriky pro zobrazení metrik úložiště:
Pak vykreslíte SuccessE2ELatency s SuccessServerLatency. Pokud metriky zobrazují vysokou hodnotu SuccessE2ELatency a nízkou hodnotu SuccessServerLatency, máte omezená dostupná vlákna nebo máte nedostatek prostředků, jako je procesor, paměť nebo šířka pásma sítě, měli byste:
- Pomocí zobrazení monitorování v studio Azure Machine Learning zkontrolujte využití procesoru a paměti vaší úlohy. Pokud nemáte procesor a paměť, zvažte zvýšení velikosti cílového výpočetního virtuálního počítače.
- Zvažte zvýšení
RSLEX_DOWNLOADER_THREADS, pokud stahujete a nevyužíváte procesor a paměť. Pokud používáte mount, měli byste zvýšitDATASET_MOUNT_READ_BUFFER_BLOCK_COUNTpro více předběžného načítání a zvýšitDATASET_MOUNT_READ_THREADSpro více vláken čtení.
Pokud metriky zobrazují nízkou hodnotu SuccessE2ELatency a low SuccessServerLatency, ale u klienta dochází k vysoké latenci, máte zpoždění v požadavku na úložiště, které dosáhne služby. Měli byste zkontrolovat:
- Určuje, jestli je počet vláken používaných pro připojení/stahování (
DATASET_MOUNT_READ_THREADS/RSLEX_DOWNLOADER_THREADS) nastavený příliš nízký vzhledem k počtu jader dostupných v cílovém výpočetním objektu. Pokud je nastavení příliš nízké, zvyšte počet vláken. - Určuje, jestli je počet opakovaných pokusů o stažení (
AZUREML_DATASET_HTTP_RETRY_COUNT) příliš vysoký. Pokud ano, snižte počet opakování.
Monitorování využití disků během úlohy
Z studio Azure Machine Learning můžete během provádění úlohy také monitorovat vstupně-výstupní operace a využití cílového výpočetního disku. Přejděte do své úlohy a vyberte kartu Monitorování . Tato karta poskytuje přehledy o prostředcích vaší úlohy za 30 dnů. Příklad:
Poznámka:
Monitorování úloh podporuje pouze výpočetní prostředky, které spravuje Azure Machine Learning. Úlohy s dobou běhu kratší než 5 minut nebudou mít dostatek dat, aby naplnily toto zobrazení.
Azure Machine Learning Data Runtime nepoužívá poslední RESERVED_FREE_DISK_SPACE bajty místa na disku, aby byl výpočetní výkon v pořádku (výchozí hodnota je 150MB). Pokud je disk plný, kód zapisuje soubory na disk bez deklarování souborů jako výstupu. Zkontrolujte proto kód a ujistěte se, že se data nepíšou chybně na dočasný disk. Pokud musíte zapisovat soubory na dočasný disk a tento prostředek se zaplní, zvažte následující:
- Zvětšení velikosti virtuálního počítače na virtuální počítač s větším dočasným diskem
- Nastavení hodnoty TTL u dat uložených v mezipaměti (
DATASET_MOUNT_ATTRIBUTE_CACHE_TTL) pro vymazání dat z disku
Kolokace dat s výpočetními prostředky
Upozornění
Pokud jsou úložiště a výpočetní prostředky v různých oblastech, výkon se sníží, protože data se musí přenášet mezi oblastmi. Tím se zvyšují náklady. Ujistěte se, že váš účet úložiště a výpočetní prostředky jsou ve stejné oblasti.
Pokud jsou vaše data a pracovní prostor Služby Azure Machine Learning uložené v různých oblastech, doporučujeme data zkopírovat do účtu úložiště ve stejné oblasti pomocí nástroje azcopy . AzCopy používá rozhraní API typu server-server, aby se data zkopírovala přímo mezi servery úložiště. Tyto operace kopírování nepoužívají šířku pásma sítě vašeho počítače. Propustnost těchto operací můžete zvýšit pomocí AZCOPY_CONCURRENCY_VALUE proměnné prostředí. Další informace najdete v tématu Zvýšení souběžnosti.
Zátěž úložiště
Při vysokém zatížení může dojít k omezení jednoho účtu úložiště, když:
- Vaše úloha používá mnoho uzlů GPU.
- Váš účet úložiště má mnoho souběžných uživatelů a aplikací, které při spuštění úlohy přistupují k datům.
Tato část ukazuje výpočty, které určují, jestli se omezování může stát problémem pro vaši úlohu a jak přistupovat ke snížení omezování.
Výpočet limitů šířky pásma
Účet Služby Azure Storage má výchozí limity výstupu 120 Gbit/s. Virtuální počítače Azure mají různé šířky pásma sítě, které mají vliv na teoreticky počet výpočetních uzlů potřebných k dosažení maximální výchozí výstupní kapacity úložiště:
| Velikost | Karta GPU | Virtuální procesory | Paměť: GiB | Dočasné úložiště (SSD): GiB | Počet karet GPU | Paměť GPU: GiB | Očekávaná šířka pásma sítě (Gbit/s) | Výchozí maximum účtu úložiště (Gbit/s)* | Počet uzlů, které se mají dostat do výchozí výstupní kapacity |
|---|---|---|---|---|---|---|---|---|---|
| Standard_ND96asr_v4 | A100 | 96 | 900 | 6 000 | 8 | 40 | 24 | 120 | 5 |
| Standard_ND96amsr_A100_v4 | A100 | 96 | 1900 | 6400 | 8 | 80 | 24 | 120 | 5 |
| Standard_NC6s_v3 | V100 | 6 | 112 | 736 | 1 | 16 | 24 | 120 | 5 |
| Standard_NC12s_v3 | V100 | 12 | 224 | 1474 | 2 | 32 | 24 | 120 | 5 |
| Standard_NC24s_v3 | V100 | 24 | 448 | 2948 | 4 | 64 | 24 | 120 | 5 |
| Standard_NC24rs_v3 | V100 | 24 | 448 | 2948 | 4 | 64 | 24 | 120 | 5 |
| Standard_NC4as_T4_v3 | T4 | 4 | 28 | 180 | 1 | 16 | 8 | 120 | 15 |
| Standard_NC8as_T4_v3 | T4 | 8 | 56 | 360 | 1 | 16 | 8 | 120 | 15 |
| Standard_NC16as_T4_v3 | T4 | 16 | 110 | 360 | 1 | 16 | 8 | 120 | 15 |
| Standard_NC64as_T4_v3 | T4 | 64 | 440 | 2880 | 4 | 64 | 32 | 120 | 3 |
Modely A100/V100 mají maximální síťovou propustnost na uzel 24 Gbit/s. Pokud každý uzel, který čte data z jednoho účtu, může číst téměř teoreticky maximálně 24 gb/s, dojde k výstupní kapacitě s pěti uzly. Použití šesti nebo více výpočetních uzlů by začalo snižovat propustnost dat napříč všemi uzly.
Důležité
Pokud vaše úloha potřebuje více než šest uzlů A100/V100, nebo se domníváte, že překročíte výchozí výstupní kapacitu úložiště (120Gbit/s), obraťte se na podporu (přes Azure Portal) a požádejte o navýšení limitu výchozího přenosu dat úložiště.
Škálování mezi několika účty úložiště
Můžete překročit maximální výstupní kapacitu úložiště a/nebo můžete narazit na limity přenosové rychlosti požadavků. Pokud k těmto problémům dojde, doporučujeme nejprve kontaktovat podporu, abyste tyto limity pro účet úložiště zvýšili.
Pokud nemůžete zvýšit maximální kapacitu výchozího přenosu dat nebo limit rychlosti požadavků, měli byste zvážit replikaci dat napříč několika účty úložiště. Zkopírujte data do více účtů pomocí služby Azure Data Factory, Průzkumník služby Azure Storage, nebo azcopy, a připojte všechny účty ve vašem tréninkovém úkolu. Stahují se pouze data, ke kterým je přistupováno na připojeném úložišti. Trénovací kód proto může číst RANK z proměnné prostředí a vybrat, ze kterého z více připojených vstupů se má číst. Definice úlohy se předává v seznamu účtů úložiště:
$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
code: src
command: >-
python train.py
--epochs ${{inputs.epochs}}
--learning-rate ${{inputs.learning_rate}}
--data ${{inputs.cifar_storage1}}, ${{inputs.cifar_storage2}}
inputs:
epochs: 1
learning_rate: 0.2
cifar_storage1:
type: uri_folder
path: azureml://datastores/storage1/paths/cifar
cifar_storage2:
type: uri_folder
path: azureml://datastores/storage2/paths/cifar
environment: azureml:AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu@latest
compute: azureml:gpu-cluster
distribution:
type: pytorch
process_count_per_instance: 1
resources:
instance_count: 2
display_name: pytorch-cifar-distributed-example
experiment_name: pytorch-cifar-distributed-example
description: Train a basic convolutional neural network (CNN) with PyTorch on the CIFAR-10 dataset, distributed via PyTorch.
Trénovací kód Pythonu pak může použít RANK k získání účtu úložiště specifického pro daný uzel:
import argparse
import os
parser = argparse.ArgumentParser()
parser.add_argument('--data', nargs='+')
args = parser.parse_args()
world_size = int(os.environ["WORLD_SIZE"])
rank = int(os.environ["RANK"])
local_rank = int(os.environ["LOCAL_RANK"])
data_path_for_this_rank = args.data[rank]
Problém s mnoha malými soubory
Čtení souborů z úložiště zahrnuje provádění požadavků na každý soubor. Počet požadavků na soubor se liší v závislosti na velikostech souborů a nastavení softwaru, který zpracovává čtení souboru.
Soubory se čtou v blocích o velikosti 1–4 MB. Soubory menší než blok se čtou jedním požadavkem (GET file.jpg 0–4 MB) a soubory větší než blok mají jeden požadavek na jeden blok (GET file.jpg 0–4 MB, GET file.jpg 4–8 MB). Tato tabulka ukazuje, že soubory menší než blok o velikosti 4 MB mají za následek více požadavků na úložiště v porovnání s většími soubory:
| # Soubory | Velikost souboru | Celková velikost dat | Velikost bloku | # Požadavky na úložiště |
|---|---|---|---|---|
| 2,000,000 | 500 kB | 1 TB | 4 MB | 2,000,000 |
| 1000 | 1 GB | 1 TB | 4 MB | 256,000 |
U malých souborů interval latence většinou zahrnuje zpracování požadavků na úložiště místo přenosů dat. Proto nabízíme tato doporučení ke zvýšení velikosti souboru:
- Pro nestrukturovaná data (obrázky, videa atd.), archivujte malé soubory společně pomocí formátů zip/tar, abyste je ukládali jako větší soubor, který lze číst v několika blocích. Tyto větší archivované soubory je možné otevřít ve výpočetním prostředku a PyTorch Archive DataPipes může extrahovat menší soubory.
- U strukturovaných dat (CSV, parquet atd.) zkontrolujte proces ETL a ujistěte se, že slučuje soubory ke zvětšení velikosti. Spark má
repartition()acoalesce()metody, které vám pomůžou zvýšit velikost souborů.
Pokud nemůžete zvětšit velikost souborů, prozkoumejte možnosti služby Azure Storage.
Možnosti služby Azure Storage
Azure Storage nabízí dvě úrovně – Standard a Premium:
| Storage | Scénář |
|---|---|
| Azure Blob – Standard (HDD) | Vaše data jsou strukturovaná ve větších objektech blob – obrázky, video atd. |
| Azure Blob – Premium (SSD) | Vysoké rychlosti transakcí, menší objekty nebo konzistentně nízké požadavky na latenci úložiště |
Návod
U "mnoha" malých souborů (velikost KB) doporučujeme použít premium (SSD), protože náklady na úložiště jsou menší než náklady na provoz výpočetních prostředků GPU.
Čtení datových aktiv V1
Tato část vysvětluje, jak v úloze V2 číst datové entity V1 FileDataset a TabularDataset.
Přečtěte si FileDataset
V objektu Inputtype zadejte jako AssetTypes.MLTABLE a mode jako InputOutputModes.EVAL_MOUNT:
Poznámka:
Pokud chcete používat bezserverové výpočetní prostředky, odstraňte compute="cpu-cluster", ho v tomto kódu.
Další informace o objektu MLClient, možnostech inicializace objektů MLClient a o tom, jak se připojit k pracovnímu prostoru, najdete v tématu Připojení k pracovnímu prostoru.
from azure.ai.ml import command
from azure.ai.ml.entities import Data
from azure.ai.ml import Input
from azure.ai.ml.constants import AssetTypes, InputOutputModes
from azure.ai.ml import MLClient
ml_client = MLClient.from_config(credential=DefaultAzureCredential())
filedataset_asset = ml_client.data.get(name="<filedataset_name>", version="<version>")
my_job_inputs = {
"input_data": Input(
type=AssetTypes.MLTABLE,
path=filedataset_asset.id,
mode=InputOutputModes.EVAL_MOUNT
)
}
job = command(
code="./src", # Local path where the code is stored
command="ls ${{inputs.input_data}}",
inputs=my_job_inputs,
environment="<environment_name>:<version>",
compute="cpu-cluster",
)
# Submit the command
returned_job = ml_client.jobs.create_or_update(job)
# Get a URL for the job status
returned_job.services["Studio"].endpoint
Přečtěte si TabularDataset
V objektu Inputtype zadejte jako AssetTypes.MLTABLEa mode jako InputOutputModes.DIRECT:
Poznámka:
Pokud chcete používat bezserverové výpočetní prostředky, odstraňte compute="cpu-cluster", ho v tomto kódu.
from azure.ai.ml import command
from azure.ai.ml.entities import Data
from azure.ai.ml import Input
from azure.ai.ml.constants import AssetTypes, InputOutputModes
from azure.ai.ml import MLClient
ml_client = MLClient.from_config(credential=DefaultAzureCredential())
filedataset_asset = ml_client.data.get(name="<tabulardataset_name>", version="<version>")
my_job_inputs = {
"input_data": Input(
type=AssetTypes.MLTABLE,
path=filedataset_asset.id,
mode=InputOutputModes.DIRECT
)
}
job = command(
code="./src", # Local path where the code is stored
command="python train.py --inputs ${{inputs.input_data}}",
inputs=my_job_inputs,
environment="<environment_name>:<version>",
compute="cpu-cluster",
)
# Submit the command
returned_job = ml_client.jobs.create_or_update(job)
# Get a URL for the status of the job
returned_job.services["Studio"].endpoint
Cleanup
Pokud jste pro tento kurz vytvořili prostředky Azure, které už nepotřebujete, odeberte je, abyste se vyhnuli účtování nákladů:
Pokud už výpočetní cluster nepotřebujete, škálujte výpočetní cluster na nula uzlů nebo ho odstraňte:
az ml compute update --name cpu-cluster --resource-group <RESOURCE_GROUP> --workspace-name <AML_WORKSPACE_NAME> --min-instances 0Odstraňte všechny výstupní datové prostředky nebo kontejnery úložiště, které jste vytvořili během testování.