Udostępnij za pośrednictwem

Uzyskiwanie dostępu do danych w zadaniu

  • Artykuł

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

Z tego artykułu dowiesz się:

  • Jak odczytywać dane z usługi Azure Storage w zadaniu usługi Azure Machine Learning.
  • Jak zapisywać dane z zadania usługi Azure Machine Learning w usłudze Azure Storage.
  • Różnica między trybami instalacji i pobierania .
  • Jak używać tożsamości użytkownika i tożsamości zarządzanej do uzyskiwania dostępu do danych.
  • Ustawienia instalacji dostępne w zadaniu.
  • Optymalne ustawienia instalacji dla typowych scenariuszy.
  • Jak uzyskać dostęp do zasobów danych w wersji 1.

Wymagania wstępne

Szybki start

Przed zapoznaniem się ze szczegółowymi opcjami dostępnymi podczas uzyskiwania dostępu do danych najpierw opiszemy odpowiednie fragmenty kodu na potrzeby dostępu do danych.

Odczytywanie danych z usługi Azure Storage w zadaniu usługi Azure Machine Learning

W tym przykładzie przesyłasz zadanie usługi Azure Machine Learning, które uzyskuje dostęp do danych z publicznego konta magazynu obiektów blob. Można jednak dostosować fragment kodu, aby uzyskać dostęp do własnych danych na prywatnym koncie usługi Azure Storage. Zaktualizuj ścieżkę zgodnie z opisem w tym miejscu. Usługa Azure Machine Learning bezproblemowo obsługuje uwierzytelnianie w magazynie w chmurze, a usługa Microsoft Entra passthrough. Po przesłaniu zadania możesz wybrać następujące opcje:

  • Tożsamość użytkownika: przekazywanie tożsamości firmy Microsoft Entra w celu uzyskania dostępu do danych
  • Tożsamość zarządzana: użyj tożsamości zarządzanej obiektu docelowego obliczeniowego, aby uzyskać dostęp do danych
  • Brak: nie określaj tożsamości w celu uzyskania dostępu do danych. Użyj opcji Brak podczas korzystania z magazynów danych opartych na poświadczeniach (tokenu klucza/sygnatury dostępu współdzielonego) lub podczas uzyskiwania dostępu do danych publicznych

Napiwek

Jeśli używasz kluczy lub tokenów SAS do uwierzytelniania, sugerujemy utworzenie magazynu danych usługi Azure Machine Learning, ponieważ środowisko uruchomieniowe automatycznie połączy się z magazynem bez ujawnienia klucza/tokenu.

from azure.ai.ml import command, Input, MLClient, UserIdentityConfiguration, ManagedIdentityConfiguration
from azure.ai.ml.entities import Data
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)

Zapisywanie danych z zadania usługi Azure Machine Learning w usłudze Azure Storage

W tym przykładzie przesyłasz zadanie usługi Azure Machine Learning, które zapisuje dane w domyślnym magazynie danych usługi Azure Machine Learning. Opcjonalnie możesz ustawić name wartość zasobu danych, aby utworzyć zasób danych w danych wyjściowych.

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)

Środowisko uruchomieniowe danych usługi Azure Machine Learning

Po przesłaniu zadania środowisko uruchomieniowe danych usługi Azure Machine Learning kontroluje obciążenie danych z lokalizacji magazynu do docelowego obiektu obliczeniowego. Środowisko uruchomieniowe danych usługi Azure Machine Learning jest zoptymalizowane pod kątem szybkości i wydajności zadań uczenia maszynowego. Kluczowe korzyści obejmują:

  • Dane są ładowane w języku Rust, czyli języku znanym z dużej szybkości i wysokiej wydajności pamięci. W przypadku współbieżnych pobierania danych rust unika problemów z blokadą globalnego interpretera języka Python (GIL)
  • Lekka waga; Rust nie ma zależności od innych technologii — na przykład JVM. W związku z tym środowisko uruchomieniowe jest szybko instalowane i nie opróżnia dodatkowych zasobów (procesora CPU, pamięci) na docelowym obiekcie obliczeniowym
  • Ładowanie danych wieloprocesowych (równoległych)
  • Pobiera dane wstępnie jako zadanie w tle na procesorach CPU, aby umożliwić lepsze wykorzystanie procesorów GPU podczas uczenia głębokiego
  • Bezproblemowa obsługa uwierzytelniania w magazynie w chmurze
  • Udostępnia opcje instalowania danych (strumienia) lub pobierania wszystkich danych. Aby uzyskać więcej informacji, odwiedź sekcje Instalowanie (przesyłanie strumieniowe) i Pobieranie .
  • Bezproblemowa integracja z fsspec — ujednolicony interfejs pythonic do lokalnych, zdalnych i osadzonych systemów plików oraz magazynu bajtowego.

Napiwek

Zalecamy korzystanie ze środowiska uruchomieniowego danych usługi Azure Machine Learning zamiast tworzenia własnej możliwości instalowania/pobierania w kodzie trenowania (klienta). Zaobserwowaliśmy ograniczenia przepływności magazynu, gdy kod klienta używa języka Python do pobierania danych z magazynu z powodu problemów z globalną blokadą interpretera (GIL).

Ścieżki

Po podaniu danych wejściowych/wyjściowych do zadania należy określić path parametr wskazujący lokalizację danych. W tej tabeli przedstawiono różne lokalizacje danych obsługiwane przez usługę Azure Machine Learning, a także przedstawiono path przykłady parametrów:

Lokalizacja Przykłady Dane wejściowe Dane wyjściowe
Ścieżka na komputerze lokalnym ./home/username/data/my_data Y N
Ścieżka na publicznym serwerze HTTP https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv Y N
Ścieżka w usłudze Azure Storage wasbs://<container_name>@<account_name>.blob.core.windows.net/<path>
abfss://<file_system>@<account_name>.dfs.core.windows.net/<path>		 Y, tylko w przypadku uwierzytelniania opartego na tożsamościach. N
Ścieżka w magazynie danych usługi Azure Machine Learning azureml://datastores/<data_store_name>/paths/<path> Y Y
Ścieżka do zasobu danych azureml:<my_data>:<version> Y N, ale możesz użyć polecenia name i version utworzyć zasób danych na podstawie danych wyjściowych

Tryby

Po uruchomieniu zadania z danymi wejściowymi/wyjściowymi można wybrać spośród następujących opcji trybu :

  • ro_mount: Zainstaluj lokalizację magazynu jako tylko do odczytu na docelowym obiekcie obliczeniowym dysku lokalnego (SSD).

  • rw_mount: Zainstaluj lokalizację magazynu jako odczyt-zapis na docelowym obiekcie obliczeniowym dysku lokalnego (SSD).

  • download: pobierz dane z lokalizacji magazynu do docelowego obiektu obliczeniowego dysku lokalnego (SSD).

  • upload: przekaż dane z docelowego obiektu obliczeniowego do lokalizacji magazynu.

  • eval_mount/eval_download: Te tryby są unikatowe dla tabeli MLTable. W niektórych scenariuszach tabela MLTable może zwracać pliki, które mogą znajdować się na koncie magazynu innym niż konto magazynu hostujące plik MLTable. Alternatywnie tabela MLTable może podzestawować lub przetasować dane znajdujące się w zasobie magazynu. Ten widok podzestawu/mieszania staje się widoczny tylko wtedy, gdy środowisko uruchomieniowe danych usługi Azure Machine Learning faktycznie ocenia plik MLTable. Na przykład na tym diagramie pokazano, jak tabela MLTable używana z tabelą eval_mount eval_download MLTable może wykonywać obrazy z dwóch różnych kontenerów magazynu oraz plik adnotacji znajdujący się na innym koncie magazynu, a następnie zainstalować/pobrać do systemu plików zdalnego obiektu docelowego obliczeniowego.

    Zrzut ekranu przedstawiający ocenę instalacji.

    Folder camera1 , camera2 folder i annotations.csv plik są następnie dostępne w systemie plików obiektu docelowego obliczeniowego w strukturze folderów:

    /INPUT_DATA
├── account-a
│   ├── container1
│   │   └── camera1
│   │       ├── image1.jpg
│   │       └── image2.jpg
│   └── container2
│       └── camera2
│           ├── image1.jpg
│           └── image2.jpg
└── account-b
    └── container1
        └── annotations.csv

  • direct: Możesz chcieć odczytywać dane bezpośrednio z identyfikatora URI za pośrednictwem innych interfejsów API, zamiast przechodzić przez środowisko uruchomieniowe danych usługi Azure Machine Learning. Na przykład możesz chcieć uzyskać dostęp do danych w zasobniku s3 (z adresem URL typu hostowanego w trybie wirtualnym lub w stylu https ścieżki) przy użyciu klienta boto s3. Identyfikator URI danych wejściowych można uzyskać jako ciąg z trybem direct . Zobaczysz użycie trybu bezpośredniego w zadaniach platformy Spark, ponieważ spark.read_*() metody wiedzą, jak przetwarzać identyfikatory URI. W przypadku zadań innych niż Spark ponosisz odpowiedzialność za zarządzanie poświadczeniami dostępu. Na przykład należy jawnie korzystać z obliczeniowej tożsamości usługi zarządzanej lub w inny sposób uzyskać dostęp brokera.

W tej tabeli przedstawiono możliwe tryby dla różnych kombinacji typów/trybu/danych wejściowych/wyjściowych:

Typ Dane wejściowe/wyjściowe upload download ro_mount rw_mount direct eval_download eval_mount
uri_folder Dane wejściowe ✓ ✓ ✓
uri_file Dane wejściowe ✓ ✓ ✓
mltable Dane wejściowe ✓ ✓ ✓ ✓ ✓
uri_folder Dane wyjściowe ✓ ✓
uri_file Dane wyjściowe ✓ ✓
mltable Dane wyjściowe ✓ ✓ ✓

Pobierz

W trybie pobierania wszystkie dane wejściowe są kopiowane na dysk lokalny (SSD) docelowego obiektu obliczeniowego. Środowisko uruchomieniowe danych usługi Azure Machine Learning uruchamia skrypt trenowania użytkownika po skopiowaniu wszystkich danych. Po uruchomieniu skryptu użytkownika odczytuje dane z dysku lokalnego, podobnie jak w przypadku innych plików. Po zakończeniu zadania dane zostaną usunięte z dysku docelowego obiektu obliczeniowego.

Zalety Wady
Po rozpoczęciu trenowania wszystkie dane są dostępne na dysku lokalnym (SSD) docelowego obiektu obliczeniowego dla skryptu trenowania. Nie jest wymagana żadna interakcja z usługą Azure Storage/siecią. Zestaw danych musi być całkowicie dopasowany do dysku docelowego obliczeń.
Po uruchomieniu skryptu użytkownika nie ma zależności od niezawodności magazynu/sieci. Cały zestaw danych jest pobierany (jeśli trenowanie musi losowo wybrać tylko niewielką część danych, znaczna część pobierania zostanie zmarnowana).
Środowisko uruchomieniowe danych usługi Azure Machine Learning może zrównać pobieranie (znaczącą różnicę w przypadku wielu małych plików) i maksymalną przepływność sieci/magazynu. Zadanie czeka na pobranie wszystkich danych na dysk lokalny docelowego obiektu obliczeniowego. W przypadku przesłanego zadania uczenia głębokiego procesory GPU bezczynne, dopóki dane nie będą gotowe.
Brak nieuniknionego obciążenia dodanego przez warstwę FUSE (dwukierunkowe wywołanie przestrzeni użytkownika w skrypcie użytkownika → jądra → demona bezpiecznika przestrzeni użytkownika → jądra → odpowiedzi na skrypt użytkownika w przestrzeni użytkownika) Zmiany magazynu nie są odzwierciedlane na danych po zakończeniu pobierania.

Kiedy należy używać pobierania

  • Dane są wystarczająco małe, aby zmieścić się na dysku obiektu docelowego obliczeniowego bez ingerencji w inne szkolenia
  • Trenowanie używa większości lub wszystkich zestawów danych
  • Trenowanie odczytuje pliki z zestawu danych więcej niż raz
  • Trenowanie musi przechodzić do losowych pozycji dużego pliku
  • Poczekaj na pobranie wszystkich danych przed rozpoczęciem trenowania

Dostępne ustawienia pobierania

Ustawienia pobierania można dostroić przy użyciu tych zmiennych środowiskowych w zadaniu:

Nazwa zmiennej środowiskowej Typ Wartość domyślna opis
RSLEX_DOWNLOADER_THREADS u64 NUMBER_OF_CPU_CORES * 4 Liczba równoczesnych pobrań wątków może być używana
AZUREML_DATASET_HTTP_RETRY_COUNT u64 7 Liczba ponownych prób pojedynczego magazynu/ http żądania odzyskania po błędach przejściowych.

W zadaniu możesz zmienić powyższe wartości domyślne, ustawiając zmienne środowiskowe — na przykład:

W przypadku zwięzłości pokazujemy tylko sposób definiowania zmiennych środowiskowych w zadaniu.

from azure.ai.ml import command

env_var = {
"RSLEX_DOWNLOADER_THREADS": 64,
"AZUREML_DATASET_HTTP_RETRY_COUNT": 10
}

job = command(
        environment_variables=env_var
)

Pobieranie metryk wydajności

Rozmiar maszyny wirtualnej docelowego obiektu obliczeniowego ma wpływ na czas pobierania danych. Szczególnie:

  • Liczba rdzeni. Więcej dostępnych rdzeni, tym większa współbieżność i tym większa szybkość pobierania.
  • Oczekiwana przepustowość sieci. Każda maszyna wirtualna na platformie Azure ma maksymalną przepływność z karty interfejsu sieciowego.

Uwaga

W przypadku maszyn wirtualnych z procesorem GPU A100 środowisko uruchomieniowe danych usługi Azure Machine Learning może saturacji karty sieciowej (karty interfejsu sieciowego) podczas pobierania danych do docelowego obiektu obliczeniowego (~24 Gbit/s): teoretyczna maksymalna możliwa przepływność.

W tej tabeli przedstawiono wydajność pobierania, które środowisko uruchomieniowe danych usługi Azure Machine Learning może obsłużyć dla pliku 100 GB na maszynie Standard_D15_v2 wirtualnej (20 rdzeni, przepływność sieci 25 GB/s):

Struktura danych Tylko pobieranie (s) Pobieranie i obliczanie md5 (s) Osiągnięta przepływność (Gbit/s)
10 x 10 GB plików 55.74 260.97 14,35 Gb/s
100 x 1 GB plików 58.09 259.47 13,77 Gb/s
1 x 100 GB pliku 96.13 300.61 8.32 Gb/s

Widzimy, że większy plik podzielony na mniejsze pliki może zwiększyć wydajność pobierania z powodu równoległości. Zalecamy unikanie plików, które stają się zbyt małe (mniej niż 4 MB), ponieważ czas potrzebny do przesłania żądań magazynu wzrasta w porównaniu z czasem spędzonym na pobieraniu ładunku. Aby uzyskać więcej informacji, przeczytaj wiele problemów z małymi plikami.

Instalowanie (przesyłanie strumieniowe)

W trybie instalacji funkcja danych usługi Azure Machine Learning korzysta z funkcji FUSE (systemu plików w przestrzeni użytkownika) systemu Linux w celu utworzenia emulowanego systemu plików. Zamiast pobierać wszystkie dane na dysk lokalny (SSD) docelowego obiektu obliczeniowego, środowisko uruchomieniowe może reagować na akcje skryptu użytkownika w czasie rzeczywistym. Na przykład "otwórz plik", "odczytaj fragment o rozmiarze 2 KB z pozycji X", "list directory content".

Zalety Wady
Dane przekraczające docelową pojemność dysku lokalnego obliczeniowego mogą być używane (nie tylko przez sprzęt obliczeniowy) Dodano obciążenie modułu FUSE systemu Linux.
Brak opóźnień na początku trenowania (w przeciwieństwie do trybu pobierania). Zależność od zachowania kodu użytkownika (jeśli kod trenowania, który sekwencyjnie odczytuje małe pliki w jednym wątku, żąda również danych z magazynu, może nie zmaksymalizować przepływności sieci lub magazynu).
Bardziej dostępne ustawienia dostrajania scenariusza użycia. Brak obsługi okien.
Tylko dane potrzebne do trenowania są odczytywane z magazynu.

Kiedy należy użyć instalacji

  • Dane są duże i nie mieszczą się na docelowym dysku lokalnym obliczeniowym.
  • Każdy pojedynczy węzeł obliczeniowy w klastrze nie musi odczytywać całego zestawu danych (losowego pliku lub wierszy w zaznaczeniu pliku CSV itp.).
  • Opóźnienia oczekiwania na pobranie wszystkich danych przed rozpoczęciem trenowania mogą stać się problemem (czas bezczynności procesora GPU).

Dostępne ustawienia instalacji

Ustawienia instalacji można dostosować przy użyciu tych zmiennych środowiskowych w zadaniu:

Nazwa zmiennej Env Typ Domyślna wartość opis
DATASET_MOUNT_ATTRIBUTE_CACHE_TTL u64 Nie ustawiono (pamięć podręczna nigdy nie wygasa) Czas w milisekundach potrzebny do zachowania getattr wyników wywołania w pamięci podręcznej i uniknięcia kolejnych żądań tych informacji z magazynu.
DATASET_RESERVED_FREE_DISK_SPACE u64 150 MB Przeznaczone do konfiguracji systemu, aby zachować dobrą kondycję obliczeniową. Niezależnie od wartości innych ustawień środowisko uruchomieniowe danych usługi Azure Machine Learning nie używa ostatnich RESERVED_FREE_DISK_SPACE bajtów miejsca na dysku.
DATASET_MOUNT_CACHE_SIZE usize Nieograniczony Określa, ile miejsca na dysku może używać. Wartość dodatnia ustawia wartość bezwzględną w bajtach. Wartość ujemna określa ilość wolnego miejsca na dysku. Ta tabela zawiera więcej opcji pamięci podręcznej dysku. Obsługuje KBmetody i GB MB modyfikatory dla wygody.
DATASET_MOUNT_FILE_CACHE_PRUNE_THRESHOLD f64 1.0 Instalacja woluminu uruchamia oczyszczanie pamięci podręcznej, gdy pamięć podręczna jest wypełniana do AVAILABLE_CACHE_SIZE * DATASET_MOUNT_FILE_CACHE_PRUNE_THRESHOLD. Powinna należeć do zakresu od 0 do 1. Ustawienie go < 1 powoduje wcześniejsze oczyszczanie pamięci podręcznej w tle. AVAILABLE_CACHE_SIZE nie jest zmienną środowiskową, którą można modyfikować ani wyświetlać bezpośrednio. W tym kontekście odnosi się do "liczby bajtów, które system oblicza jako dostępne dla buforowania". Ta wartość zależy od czynników, takich jak rozmiar dysku, ilość miejsca na dysku wymagana do kondycji systemu i konfiguracje ustawione w zmiennych środowiskowych (na przykład DATASET_RESERVED_FREE_DISK_SPACE i DATASET_MOUNT_CACHE_SIZE).
DATASET_MOUNT_FILE_CACHE_PRUNE_TARGET f64 0,7 Czyszczenie pamięci podręcznej próbuje zwolnić co najmniej (1-DATASET_MOUNT_FILE_CACHE_PRUNE_TARGET) miejsca w pamięci podręcznej.
DATASET_MOUNT_READ_BLOCK_SIZE usize 2 MB Rozmiar bloku odczytu przesyłania strumieniowego. Gdy plik jest wystarczająco duży, zażądaj co najmniej DATASET_MOUNT_READ_BLOCK_SIZE danych z magazynu i pamięci podręcznej nawet wtedy, gdy żądano operacji odczytu przez bezpiecznik dla mniejszej liczby.
DATASET_MOUNT_READ_BUFFER_BLOCK_COUNT usize 32 Liczba bloków do pobrania wstępnego (blok odczytu k wyzwala wstępne pobieranie w tle bloków k+1, ..., k.+DATASET_MOUNT_READ_BUFFER_BLOCK_COUNT)
DATASET_MOUNT_READ_THREADS usize NUMBER_OF_CORES * 4 Liczba wątków pobierania wstępnie w tle.
DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED bool fałsz Włącz buforowanie oparte na blokach.
DATASET_MOUNT_MEMORY_CACHE_SIZE usize 128 MB Dotyczy tylko buforowania opartego na blokach. Rozmiar buforowania opartego na blokach pamięci RAM może być używany. Wartość 0 powoduje całkowite wyłączenie buforowania pamięci.
DATASET_MOUNT_BLOCK_FILE_CACHE_ENABLED bool prawda Dotyczy tylko buforowania opartego na blokach. W przypadku ustawienia wartości true buforowanie oparte na bloku używa lokalnego dysku twardego do buforowania bloków.
DATASET_MOUNT_BLOCK_FILE_CACHE_MAX_QUEUE_SIZE usize 512 MB Dotyczy tylko buforowania opartego na blokach. Buforowanie blokowe zapisuje buforowane bloki na dysku lokalnym w tle. To ustawienie określa, ile miejsca instalacji pamięci może używać do przechowywania bloków oczekujących na opróżnienie do pamięci podręcznej dysku lokalnego.
DATASET_MOUNT_BLOCK_FILE_CACHE_WRITE_THREADS usize NUMBER_OF_CORES * 2 Dotyczy tylko buforowania opartego na blokach. Liczba wątków w tle używanych do zapisywania pobranych bloków na dysku lokalnym docelowego obliczeniowego.
DATASET_UNMOUNT_TIMEOUT_SECONDS u64 30 Czas (w sekundach), aby unmount (bezpiecznie) zakończyć wszystkie oczekujące operacje (na przykład opróżnianie wywołań) przed wymuszonym kończeniem pętli komunikatów instalacji.

W zadaniu możesz zmienić powyższe wartości domyślne, ustawiając zmienne środowiskowe, na przykład:

from azure.ai.ml import command

env_var = {
"DATASET_MOUNT_BLOCK_FILE_CACHE_ENABLED": True
}

job = command(
        environment_variables=env_var
)

Tryb otwierania oparty na bloku

Tryb otwierania oparty na bloku dzieli każdy plik na bloki wstępnie zdefiniowanego rozmiaru (z wyjątkiem ostatniego bloku). Żądanie odczytu z określonej pozycji żąda odpowiedniego bloku z magazynu i natychmiast zwraca żądane dane. Odczyt wyzwala również wstępne pobieranie w tle N następnych bloków przy użyciu wielu wątków (zoptymalizowanych pod kątem odczytu sekwencyjnego). Pobrane bloki są buforowane w dwóch warstwach pamięci podręcznej (pamięć RAM i dysk lokalny).

Zalety Wady
Szybkie dostarczanie danych do skryptu trenowania (mniej blokowania fragmentów, których jeszcze nie zażądano). Losowe odczyty mogą marnować bloki pobrane do przodu.
Więcej pracy odciąża wątki w tle (pobieranie wstępne/buforowanie). Następnie można kontynuować szkolenie. Dodano nakład pracy nawigowanie między pamięciami podręcznymi w porównaniu z bezpośrednimi odczytami z pliku w lokalnej pamięci podręcznej dysku (na przykład w trybie pamięci podręcznej całego pliku).
Tylko żądane dane (plus pobieranie wstępne) są odczytywane z magazynu.
W przypadku wystarczająco małych danych używana jest szybka pamięć podręczna oparta na pamięci RAM.
Kiedy należy używać trybu otwierania opartego na blokach

Zalecane w przypadku większości scenariuszy , z wyjątkiem sytuacji, w których potrzebne są szybkie odczyty z losowych lokalizacji plików. W takich przypadkach należy użyć trybu otwierania całej pamięci podręcznej plików.

Tryb otwierania całej pamięci podręcznej plików

Po otwarciu pliku w folderze instalacji (na przykład f = open(path, args)) w trybie całego pliku wywołanie zostanie zablokowane do momentu pobrania całego pliku do docelowego folderu pamięci podręcznej obliczeniowej na dysku. Wszystkie kolejne wywołania odczytu przekierowują do buforowanego pliku, więc nie jest wymagana żadna interakcja z magazynem. Jeśli pamięć podręczna nie ma wystarczającej ilości dostępnego miejsca, aby zmieścić bieżący plik, zainstaluj spróbuje usunąć najmniej ostatnio używany plik z pamięci podręcznej. W przypadkach, gdy plik nie może zmieścić się na dysku (w odniesieniu do ustawień pamięci podręcznej), środowisko uruchomieniowe danych powraca do trybu przesyłania strumieniowego.

Zalety Wady
Brak zależności niezawodności/przepływności magazynu po otwarciu pliku. Otwarte wywołanie jest blokowane do momentu pobrania całego pliku.
Szybkie losowe operacje odczytu (odczytywanie fragmentów z losowych miejsc pliku). Cały plik jest odczytywany z magazynu, nawet jeśli niektóre fragmenty pliku mogą nie być potrzebne.
Zastosowanie

Gdy są potrzebne losowe operacje odczytu dla stosunkowo dużych plików, które przekraczają 128 MB.

Użycie

Ustaw zmienną środowiskową DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED na false w zadaniu:

from azure.ai.ml import command

env_var = {
"DATASET_MOUNT_BLOCK_BASED_CACHE_ENABLED": False
}

job = command(
        environment_variables=env_var
)

Instalowanie: wyświetlanie listy plików

Podczas pracy z milionami plików unikaj cyklicznej listy — na przykład ls -R /mnt/dataset/folder/. Lista cykliczna wyzwala wiele wywołań, aby wyświetlić listę zawartości katalogu nadrzędnego. Następnie wymaga oddzielnego wywołania cyklicznego dla każdego katalogu wewnątrz, na wszystkich poziomach podrzędnych. Zazwyczaj usługa Azure Storage umożliwia zwracanie tylko 5000 elementów na pojedyncze żądanie listy. W rezultacie cykliczna lista folderów 1M zawierających 10 plików, z których każdy wymaga 1,000,000 / 5000 + 1,000,000 = 1,000,200 żądań do magazynowania. Dla porównania 1000 folderów z 10 000 plików będzie potrzebować tylko 1001 żądań do magazynowania na potrzeby listy cyklicznego.

Lista uchwytów instalacji usługi Azure Machine Learning jest leniwa. Dlatego aby wyświetlić listę wielu małych plików, lepiej użyć iteracyjnego wywołania biblioteki klienta (na przykład w języku Python) zamiast wywołania biblioteki klienta zwracającej pełną listę (na przykład os.scandir() os.listdir() w języku Python). Wywołanie iteracyjnej biblioteki klienta zwraca generator, co oznacza, że nie musi czekać, aż cała lista zostanie załadowana. Następnie może działać szybciej.

Ta tabela porównuje czas potrzebny dla języka Python os.scandir() i os.listdir() funkcji, aby wyświetlić listę folderów zawierających pliki ~4M w płaskiej strukturze:

Metric os.scandir() os.listdir()
Czas uzyskania pierwszego wpisu (s) 0.67 553.79
Czas uzyskania pierwszych 50 tys. wpisów (s) 9.56 562.73
Czas na pobranie wszystkich wpisów (s) 558.35 582.14

Optymalne ustawienia instalacji dla typowych scenariuszy

W przypadku niektórych typowych scenariuszy przedstawiono optymalne ustawienia instalacji, które należy ustawić w zadaniu usługi Azure Machine Learning.

Odczytywanie dużych plików pojedynczo (przetwarzanie wierszy w pliku CSV)

Uwzględnij environment_variables te ustawienia instalacji w sekcji zadania usługi Azure Machine Learning:

Uwaga

Aby użyć bezserwerowych obliczeń, usuń compute="cpu-cluster", w tym kodzie.

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
)
Odczytywanie dużego pliku jednorazowo z wielu wątków (przetwarzanie partycjonowanego pliku CSV w wielu wątkach)

Uwzględnij environment_variables te ustawienia instalacji w sekcji zadania usługi Azure Machine Learning:

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
)
Odczytywanie milionów małych plików (obrazów) z wielu wątków jednorazowo (trenowanie pojedynczej epoki na obrazach)

Uwzględnij environment_variables te ustawienia instalacji w sekcji zadania usługi Azure Machine Learning:

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
)
Wielokrotne odczytywanie milionów małych plików (obrazów) z wielu wątków (trenowanie wielu epok na obrazach)

Uwzględnij environment_variables te ustawienia instalacji w sekcji zadania usługi Azure Machine Learning:

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
)
Odczytywanie dużego pliku z losowymi wyszukiwaniami (na przykład obsługa bazy danych plików z zainstalowanego folderu)

Uwzględnij environment_variables te ustawienia instalacji w sekcji zadania usługi Azure Machine Learning:

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
)

Diagnozowanie i rozwiązywanie wąskich gardeł ładowania danych

Gdy zadanie usługi Azure Machine Learning jest wykonywane z danymi, element wejściowy określa, mode jak bajty są odczytywane z magazynu i buforowane na docelowym docelowym dysku SSD obliczeniowym. W trybie pobierania wszystkie pamięci podręczne danych na dysku przed rozpoczęciem wykonywania kodu użytkownika. W związku z tym czynniki, takie jak

  • liczba wątków równoległych
  • liczba plików
  • rozmiar pliku

mają wpływ na maksymalną szybkość pobierania. W przypadku instalacji kod użytkownika musi zacząć otwierać pliki przed rozpoczęciem buforowania danych. Różne ustawienia instalacji powodują różne zachowanie odczytu i buforowania. Różne czynniki mają wpływ na szybkość ładowania danych z magazynu:

  • Lokalizacja danych do obliczenia: Lokalizacja docelowa magazynu i zasobów obliczeniowych powinna być taka sama. Jeśli magazyn i docelowy obiekt obliczeniowy znajdują się w różnych regionach, wydajność spada, ponieważ dane muszą być przesyłane między regionami. Aby uzyskać więcej informacji na temat sposobu zapewniania kolokacji danych za pomocą obliczeń, odwiedź stronę Colocate data with compute (Kolokuj dane za pomocą obliczeń).
  • Rozmiar docelowy obliczeń: Małe obliczenia mają mniejsze liczby rdzeni (mniejsze równoległości) i mniejszą oczekiwaną przepustowość sieci w porównaniu z większymi rozmiarami obliczeniowymi — oba czynniki wpływają na wydajność ładowania danych.
    • Jeśli na przykład używasz małego rozmiaru maszyny wirtualnej, na przykład Standard_D2_v2 (2 rdzenie, 1500 Mb/s karty sieciowej) i spróbujesz załadować 50 000 MB (50 GB) danych, najlepszym osiągalnym czasem ładowania danych będzie ok. 270 s (przy założeniu, że karta sieciowa jest usypnięta przy przepływności 187,5 MB/s). Standard_D5_v2 Natomiast (16 rdzeni, 12 000 Mb/s) załaduje te same dane w około 33 sekundach (przy założeniu, że karta sieciowa jest sytowana przy przepływności 1500 MB/s).
  • Warstwa magazynowania: w przypadku większości scenariuszy , w tym modeli dużych języków (LLM) — magazyn w warstwie Standardowa zapewnia najlepszy profil kosztów/wydajności. Jeśli jednak masz wiele małych plików, usługa Premium Storage oferuje lepszy koszt/profil wydajności. Aby uzyskać więcej informacji, przeczytaj opcje usługi Azure Storage.
  • Obciążenie magazynu: jeśli konto magazynu jest obciążone dużym obciążeniem — na przykład wiele węzłów procesora GPU w klastrze żądających danych — ryzyko przekroczenia pojemności magazynu wychodzącego. Aby uzyskać więcej informacji, zobacz Ładowanie magazynu. Jeśli masz wiele małych plików, które wymagają dostępu równolegle, możesz osiągnąć limity żądań magazynu. Przeczytaj aktualne informacje na temat limitów zarówno dla pojemności ruchu wychodzącego, jak i żądań magazynu w obszarze Cele skalowania dla standardowych kont magazynu.
  • Wzorzec dostępu do danych w kodzie użytkownika: w przypadku korzystania z trybu instalacji dane są pobierane na podstawie akcji otwierania/odczytu w kodzie. Na przykład podczas odczytywania losowych sekcji dużego pliku domyślne ustawienia pobierania danych wstępnych instalacji mogą prowadzić do pobierania bloków, które nie będą odczytywane. Może być konieczne dostosowanie niektórych ustawień w celu osiągnięcia maksymalnej przepływności. Aby uzyskać więcej informacji, zobacz Optymalne ustawienia instalacji dla typowych scenariuszy.

Diagnozowanie problemów przy użyciu dzienników

Aby uzyskać dostęp do dzienników środowiska uruchomieniowego danych z zadania:

  1. Wybierz kartę Dane wyjściowe+Dzienniki na stronie zadania.
  2. Wybierz folder system_logs, a następnie folder data_capability.
  3. Powinny zostać wyświetlone dwa pliki dziennika: Zrzut ekranu przedstawiający dzienniki środowiska uruchomieniowego danych.

Plik dziennika data-capability.log przedstawia ogólne informacje o czasie spędzonym na kluczowych zadaniach ładowania danych. Na przykład podczas pobierania danych środowisko uruchomieniowe rejestruje czas rozpoczęcia i zakończenia działania pobierania:

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]

Jeśli przepływność pobierania jest ułamkiem oczekiwanej przepustowości sieci dla rozmiaru maszyny wirtualnej, możesz sprawdzić plik dziennika rslex.log.<SYGNATURA CZASOWA>. Ten plik zawiera wszystkie szczegółowe rejestrowanie ze środowiska uruchomieniowego opartego na rust; na przykład równoległe:

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

Plik rslex.log zawiera szczegółowe informacje o wszystkich kopiach plików, niezależnie od tego, czy wybrano tryb instalacji, czy pobierania. Opisuje również używane ustawienia (zmienne środowiskowe). Aby rozpocząć debugowanie, sprawdź, czy dla typowych scenariuszy ustawiono optymalne ustawienia instalacji.

Monitorowanie usługi Azure Storage

W witrynie Azure Portal możesz wybrać konto magazynu, a następnie metryki, aby wyświetlić metryki magazynu:

Zrzut ekranu przedstawiający metryki obiektów blob.

Następnie wykreślisz element SuccessE2ELatency z elementem SuccessServerLatency. Jeśli metryki pokazują wysoką wydajność SuccessE2ELatency i niską liczbę powodzeniaServerLatency, masz ograniczone dostępne wątki lub korzystasz z małych zasobów, takich jak procesor CPU, pamięć lub przepustowość sieci, należy:

  • Użyj widoku monitorowania w usłudze Azure Machine Learning Studio , aby sprawdzić wykorzystanie procesora CPU i pamięci zadania. Jeśli jest mało procesora CPU i pamięci, rozważ zwiększenie docelowego rozmiaru maszyny wirtualnej obliczeniowej.
  • Rozważ zwiększenie RSLEX_DOWNLOADER_THREADS , jeśli pobierasz i nie korzystasz z procesora CPU i pamięci. Jeśli używasz instalacji, należy zwiększyć DATASET_MOUNT_READ_BUFFER_BLOCK_COUNT liczbę operacji pobierania wstępnego i zwiększyć DATASET_MOUNT_READ_THREADS liczbę wątków odczytu.

Jeśli metryki pokazują niską wartość SuccessE2ELatency i niską wartość SuccessServerLatency, ale klient ma duże opóźnienie, masz opóźnienie w żądaniu magazynu, które dociera do usługi. Należy sprawdzić:

  • Określa, czy liczba wątków używanych do instalacji/pobierania (DATASET_MOUNT_READ_THREADS/RSLEX_DOWNLOADER_THREADS) jest ustawiona za mało, względem liczby rdzeni dostępnych w docelowym obiekcie obliczeniowym. Jeśli ustawienie jest zbyt niskie, zwiększ liczbę wątków.
  • Określa, czy liczba ponownych prób pobierania (AZUREML_DATASET_HTTP_RETRY_COUNT) jest zbyt wysoka. Jeśli tak, zmniejsz liczbę ponownych prób.

Monitorowanie użycia dysku podczas zadania

W usłudze Azure Machine Learning Studio można również monitorować operacje we/wy dysku docelowego obliczeniowego i użycie podczas wykonywania zadania. Przejdź do zadania i wybierz kartę Monitorowanie . Ta karta zawiera szczegółowe informacje o zasobach zadania w 30 dniach. Na przykład:

Zrzut ekranu przedstawiający użycie dysku podczas wykonywania zadania.

Uwaga

Monitorowanie zadań obsługuje tylko zasoby obliczeniowe zarządzane przez usługę Azure Machine Learning. Zadania ze środowiskiem uruchomieniowym krótszym niż 5 minut nie będą miały wystarczającej ilości danych, aby wypełnić ten widok.

Środowisko uruchomieniowe danych usługi Azure Machine Learning nie używa ostatnich RESERVED_FREE_DISK_SPACE bajtów miejsca na dysku, aby zachować dobrą kondycję obliczeniową (wartość domyślna to 150MB). Jeśli dysk jest pełny, kod zapisuje pliki na dysku bez deklarowania plików jako danych wyjściowych. W związku z tym sprawdź kod, aby upewnić się, że dane nie są błędnie zapisywane na dysku tymczasowym. Jeśli musisz zapisać pliki na dysku tymczasowym i ten zasób staje się pełny, rozważ:

  • Zwiększanie rozmiaru maszyny wirtualnej do tego, który ma większy dysk tymczasowy
  • Ustawianie czasu wygaśnięcia na buforowanych danych (DATASET_MOUNT_ATTRIBUTE_CACHE_TTL) w celu przeczyszczania danych z dysku

Kolokowanie danych za pomocą obliczeń

Uwaga

Jeśli magazyn i zasoby obliczeniowe znajdują się w różnych regionach, wydajność spada, ponieważ dane muszą być przesyłane między regionami. Zwiększa to koszty. Upewnij się, że twoje konto magazynu i zasoby obliczeniowe znajdują się w tym samym regionie.

Jeśli dane i obszar roboczy usługi Azure Machine Learning są przechowywane w różnych regionach, zalecamy skopiowanie danych na konto magazynu w tym samym regionie za pomocą narzędzia azcopy . Narzędzie AzCopy używa interfejsów API serwer-serwer, dzięki czemu dane są kopiowe bezpośrednio między serwerami magazynu. Te operacje kopiowania nie korzystają z przepustowości sieci komputera. Możesz zwiększyć przepływność tych operacji za pomocą zmiennej środowiskowej AZCOPY_CONCURRENCY_VALUE . Aby dowiedzieć się więcej, zobacz Zwiększanie współbieżności.

Ładowanie magazynu

Pojedyncze konto magazynu może stać się ograniczone, jeśli występuje duże obciążenie, gdy:

  • Zadanie używa wielu węzłów procesora GPU
  • Konto magazynu ma wielu równoczesnych użytkowników/aplikacji, które uzyskują dostęp do danych podczas uruchamiania zadania

W tej sekcji przedstawiono obliczenia określające, czy ograniczanie przepustowości może stać się problemem dla obciążenia, oraz sposób podejścia do redukcji ograniczania przepustowości.

Obliczanie limitów przepustowości

Konto usługi Azure Storage ma domyślny limit ruchu wychodzącego 120 GB/s. Maszyny wirtualne platformy Azure mają różne przepustowości sieci, które mają wpływ na teoretyczną liczbę węzłów obliczeniowych potrzebnych do osiągnięciu maksymalnej domyślnej pojemności ruchu wychodzącego magazynu:

Rozmiar Karta procesora GPU Procesor wirtualny Pamięć: GiB Magazyn tymczasowy (SSD): GiB Liczba kart gpu Pamięć procesora GPU: GiB Oczekiwana przepustowość sieci (Gbit/s) Wartość domyślna maksymalnego ruchu wychodzącego konta magazynu (Gbit/s)* Liczba węzłów, które mają osiągnąć domyślną pojemność ruchu wychodzącego
Standard_ND96asr_v4 A100 96 900 6000 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 100 64 24 120 5
Standard_NC24rs_v3 V100 24 448 2948 100 64 24 120 5
Standard_NC4as_T4_v3 T4 100 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 100 64 32 120 3

Obie jednostki SKU A100/V100 mają maksymalną przepustowość sieci na węzeł wynoszącą 24 gb/s. Jeśli każdy węzeł odczytujący dane z jednego konta może odczytywać blisko teoretycznego maksimum 24 GB/s, pojemność ruchu wychodzącego wystąpi z pięcioma węzłami. Użycie co najmniej sześciu węzłów obliczeniowych zacznie obniżać przepływność danych we wszystkich węzłach.

Ważne

Jeśli obciążenie wymaga więcej niż 6 węzłów A100/V100 lub uważasz, że przekroczysz domyślną pojemność ruchu wychodzącego magazynu (120 GB/s), skontaktuj się z pomocą techniczną (za pośrednictwem witryny Azure Portal) i zażądasz zwiększenia limitu ruchu wychodzącego magazynu.

Skalowanie na wielu kontach magazynu

Możesz przekroczyć maksymalną pojemność ruchu wychodzącego magazynu i/lub przekroczyć limity szybkości żądań. Jeśli wystąpią te problemy, sugerujemy, aby najpierw skontaktować się z pomocą techniczną, aby zwiększyć te limity na koncie magazynu.

Jeśli nie możesz zwiększyć maksymalnej pojemności ruchu wychodzącego lub limitu szybkości żądań, rozważ replikowanie danych na wielu kontach magazynu. Skopiuj dane do wielu kont za pomocą usługi Azure Data Factory, Eksplorator usługi Azure Storage lub azcopy, a następnie zainstaluj wszystkie konta w zadaniu szkoleniowym. Pobierane są tylko dane, do których uzyskuje się dostęp podczas instalacji. W związku z tym kod trenowania może odczytać RANK element ze zmiennej środowiskowej, aby wybrać, które z wielu instalacji wejściowych mają być odczytywane. Definicja zadania jest przekazywana na liście kont magazynu:

$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.

Kod języka Python trenowania może następnie użyć RANK polecenia , aby uzyskać konto magazynu specyficzne dla tego węzła:

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]

Problem z wieloma małymi plikami

Odczytywanie plików z magazynu obejmuje wykonywanie żądań dla każdego pliku. Liczba żądań na plik różni się w zależności od rozmiarów plików i ustawień oprogramowania obsługującego odczyty pliku.

Pliki są zwykle odczytywane w blokach o rozmiarze od 1 do 4 MB. Pliki mniejsze niż blok są odczytywane z pojedynczym żądaniem (GET file.jpg 0–4 MB), a pliki większe niż blok mają jedno żądanie na blok (GET file.jpg 0–4 MB, GET file.jpg 4–8 MB). W tej tabeli pokazano, że pliki mniejsze niż blok 4 MB powodują więcej żądań magazynowania w porównaniu z większymi plikami:

# Pliki Rozmiar pliku Łączny rozmiar danych Rozmiar bloku # Żądania magazynu
2,000,000 500 KB 1 TB 4 MB 2,000,000
1000 1 GB 1 TB 4 MB 256,000

W przypadku małych plików interwał opóźnienia obejmuje głównie obsługę żądań do magazynu zamiast transferów danych. W związku z tym oferujemy te zalecenia, aby zwiększyć rozmiar pliku:

  • W przypadku danych bez struktury (obrazów, tekstu, wideo itp.), archiwum (zip/tar) małych plików w celu przechowywania ich jako większego pliku, który można odczytać w wielu fragmentach. Te większe zarchiwizowane pliki można otworzyć w zasobie obliczeniowym, a narzędzie PyTorch Archive DataPipes może wyodrębnić mniejsze pliki.
  • W przypadku danych strukturalnych (CSV, parquet itp.) sprawdź proces ETL, aby upewnić się, że pliki łączą się w celu zwiększenia rozmiaru. Platforma Spark ma repartition() metody i coalesce() ułatwiające zwiększenie rozmiaru plików.

Jeśli nie możesz zwiększyć rozmiarów plików, zapoznaj się z opcjami usługi Azure Storage.

Opcje usługi Azure Storage

Usługa Azure Storage oferuje dwie warstwy — Standardowa i Premium:

Storage Scenariusz
Azure Blob — Standardowa (HDD) Dane są ustrukturyzowane w większych obiektach blob — obrazy, wideo itp.
Azure Blob — Wersja Premium (SSD) Wysokie stawki transakcji, mniejsze obiekty lub stale niskie wymagania dotyczące opóźnienia magazynu

Napiwek

W przypadku "wielu" małych plików (wielkość KB) zalecamy użycie warstwy Premium (SSD), ponieważ koszt magazynu jest mniejszy niż koszty uruchamiania obliczeń procesora GPU.

Odczytywanie zasobów danych w wersji 1

W tej sekcji wyjaśniono, jak odczytywać jednostki wersji 1 FileDataset i TabularDataset danych w zadaniu w wersji 2.

Odczytywanie FileDataset

Input W obiekcie określ type parametr i jako mode AssetTypes.MLTABLE InputOutputModes.EVAL_MOUNT:

Uwaga

Aby użyć bezserwerowych obliczeń, usuń compute="cpu-cluster", w tym kodzie.

Aby uzyskać więcej informacji o obiektach MLClient, opcjach inicjowania obiektu MLClient i sposobach nawiązywania połączenia z obszarem roboczym, odwiedź stronę Nawiązywanie połączenia z obszarem roboczym.

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

Odczytywanie TabularDataset

Input W obiekcie określ parametr type jako AssetTypes.MLTABLEi mode jako InputOutputModes.DIRECT:

Uwaga

Aby użyć bezserwerowych obliczeń, usuń compute="cpu-cluster", w tym kodzie.

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

Następne kroki