Poprawa wydajności treningów i odporności systemu w AI Runtime

W miarę skalowania zadania na więcej GPU, prawdopodobieństwo awarii sprzętu i oprogramowania rośnie. Ta strona omawia strategie, które sprawią, że Twoje uruchomienia treningu będą szybsze i bardziej odporne na błędy:

Dzięki tym wzorcom checkpointowanie modelu jest tanie, więc możesz często tworzyć punkty kontrolne, tanio wznawiać i poprawić efektywność obliczeniową GPU.

Note

databricks.air.data.UCVolumeDataset, databricks.air.data.DataLoader, databricks.air.data.UCVolumeWriter i databricks.air.data.UCVolumeReader pochodzą z paczki databricks-sdk-air. Zainstaluj go z opcją extra data, która również instaluje także kompatybilne torch:

%pip install "databricks-sdk-air[data]"

Wydajne ładowanie danych, aby zminimalizować czas bezczynności GPU

Etap treningowy powinien łączyć obliczenia GPU z przygotowaniem danych do następnego kroku. W AI Runtime cały dostęp do danych odbywa się przez Unity Catalog. Dla zbiorów danych opartych na plikach w woluminach Unity Catalog używaj databricks.air.data.UCVolumeDataset, który kopiuje każdy plik z montażu FUSE do szybkiej lokalnej pamięci podręcznej przy pierwszym dostępie i zwraca ścieżkę lokalną z pamięci podręcznej.

Połącz to z databricks.air.data.DataLoader, podklasą drop-in PyTorch DataLoader dostrojoną do AI Runtime I/O, która pobiera i buforuje pliki równocześnie, podczas gdy GPU wykonuje obliczenia.

%pip install "databricks-sdk-air[data]"

import databricks.air.data

dataset = databricks.air.data.UCVolumeDataset("/Volumes/my-catalog/my-schema/my-volume/data")

loader = databricks.air.data.DataLoader(
    dataset,
    batch_size=64,
)

for batch in loader:
    local_paths = batch  # open these immediately; see the caching note below
    ...

Warning

Ścieżka wyznaczona przez databricks.air.data.UCVolumeDataset jest ulotna. Pamięć podręczna usuwa najdawniej pobrane pliki, gdy ilość wolnego miejsca na dysku spadnie poniżej progu (domyślnie 10% systemu plików pamięci podręcznej, nadpisywalnego zmienną środowiskową SGC_FSLAYER_MIN_FREE_DISK_BYTES), więc ścieżka może zostać usunięta zaraz po pobraniu kolejnego elementu. Otwórz ją, zdekoduj lub skopiuj w tej samej iteracji pętli. Nigdy nie zapisuj zwróconej ścieżki w liście ani słowniku, aby później ponownie ją otworzyć.

Dekoduj pliki, opakowując je w databricks.air.data.UCVolumeDataset w drugim IterableDataset, które pochłania strumień ścieżki. Wrapper otrzymuje już zbuforowane ścieżki lokalne, więc parsowanie nigdy nie uzyskuje dostępu do punktu montowania FUSE:

from torch.utils.data import IterableDataset
from PIL import Image
import torchvision.transforms.functional as TF

class ImageDataset(IterableDataset):
    """Decodes each cached file path from UCVolumeDataset into a tensor."""

    def __init__(self, path_dataset: databricks.air.data.UCVolumeDataset):
        self._path_dataset = path_dataset

    def __iter__(self):
        for local_path in self._path_dataset:
            image = Image.open(local_path).convert("RGB")
            yield TF.to_tensor(image)


path_dataset = databricks.air.data.UCVolumeDataset("/Volumes/my-catalog/my-schema/my-volume/images")
dataset = ImageDataset(path_dataset)
loader = databricks.air.data.DataLoader(dataset, batch_size=64)

Dwa wymagania przy skalowaniu:

  • Zawsze używaj databricks.air.data.DataLoader do treningu wieloepokowego. Wymusza persistent_workers=True, gdy num_workers > 0, dzięki czemu mechanizm śledzenia usuwania z pamięci podręcznej w pamięci każdego pracownika przetrwa przez epoki. Standardowy PyTorch DataLoader domyślnie ponownie tworzy procesy robocze w każdej epoce, co powoduje wyciek zasobów związanych ze współdzielonym katalogiem pamięci podręcznej aż do momentu, gdy się on zapełni.
  • Wszystkie poziomy muszą spełniać te same wymagania num_workers. databricks.air.data.UCVolumeDataset Dzieli pliki na partycje za pomocą globalnego kroku między gniazdami world_size × num_workers. Niedopasowane wartości powodują, że pliki są duplikowane lub pomijane w rangach.

Gdy torch.distributed zostanie zainicjalizowany, databricks.air.data.UCVolumeDataset odczytuje rangę podczas iteracji i automatycznie dzieli pliki między rangi, więc nie potrzebujesz DistributedSampler dla danych woluminowych opartych na plikach.

Punkt przywracania z rozproszonym punktem przywracania (DCP)

Użyj PyTorch Distributed Checkpoint (DCP) zamiast torch.save. Każdy rank zapisuje swój własny fragment równolegle do katalogu punktów kontrolnych, wykorzystując pełną łączną przepustowość I/O i unikając skoku pamięci związanego z gromadzeniem wszystkich stanów do jednego ranka. DCP przechowuje także globalne metadane tensorów, dzięki czemu checkpoint zapisany przy użyciu jednej liczby GPU można wznowić przy innej liczbie.

W AI Runtime databricks.air.data.UCVolumeWriter i databricks.air.data.UCVolumeReader są backendami pamięci masowej DCP. Buforują całe I/O w szybkim lokalnym katalogu (/tmp, wspieranym przez NVMe na węzłach GPU AIR) oraz przesyłają je do lub pobierają z woluminu Unity Catalog, co jest szybsze niż zapisywanie shardów bezpośrednio w punkcie montowania FUSE.

import torch.distributed.checkpoint as dcp
from torch.distributed.checkpoint.state_dict import get_state_dict, set_state_dict
import databricks.air.data

checkpoint_path = "/Volumes/my-catalog/my-schema/my-volume/checkpoints/step_1000"

# Save
model_sd, optim_sd = get_state_dict(model, optimizer)
state_dict = {"model": model_sd, "optim": optim_sd, "step": 1000}
dcp.save(state_dict, storage_writer=databricks.air.data.UCVolumeWriter(checkpoint_path))

# Load
model_sd, optim_sd = get_state_dict(model, optimizer)
state_dict = {"model": model_sd, "optim": optim_sd}
dcp.load(state_dict, storage_reader=databricks.air.data.UCVolumeReader(checkpoint_path))
set_state_dict(
    model,
    optimizer,
    model_state_dict=state_dict["model"],
    optim_state_dict=state_dict["optim"],
)

Warto stosować DCP nawet do czysto równoległego treningu danych (DDP), gdzie wagi są replikowane między rangami. DCP zapisuje pojedynczą zdeduplikowaną kopię zreplikowanych wag, jednocześnie rejestrując unikalny stan każdej rangi (pozycję danych i stan RNG, opisane poniżej), i jest to ten sam interfejs API, którego potrzebujesz, jeśli później przejdziesz na FSDP lub równoległość tensorową.

Zapisz asynchronicznie

Synchroniczny zapis blokuje trenowanie, aż bajty są trwale zapisane na woluminie. Dla dużego checkpointu jest to czas bezczynności GPU. dcp.async_save Kopiuje stan do bufora pośredniego (FAST), a następnie przesyła go w tle podczas trwającego treningu. Ponieważ każde tworzenie punktu kontrolnego kosztuje prawie zero czasu GPU, możesz sobie pozwolić na znacznie częstsze tworzenie punktów kontrolnych, co ogranicza utratę pracy po przerwaniu.

Asynchroniczne zapisy wymagają backendu CPU w grupie procesów, więc zainicjalizuj ją z użyciem zarówno gloo, jak i nccl:

import torch.distributed as dist
import torch.distributed.checkpoint as dcp
from torch.distributed.checkpoint.state_dict import get_state_dict
import databricks.air.data

dist.init_process_group(backend="cpu:gloo,cuda:nccl")

checkpoint_future = None

def save_async(step, model, optimizer):
    global checkpoint_future
    # Ensure the previous async save finished before starting a new one.
    if checkpoint_future is not None:
        checkpoint_future.result()

    model_sd, optim_sd = get_state_dict(model, optimizer)
    state_dict = {"model": model_sd, "optim": optim_sd, "step": step}
    writer = databricks.air.data.UCVolumeWriter(f"/Volumes/my-catalog/my-schema/my-volume/checkpoints/step_{step}")
    checkpoint_future = dcp.async_save(state_dict, storage_writer=writer)

Przywróć automatycznie z najnowszego ważnego punktu kontrolnego

Przebieg może zostać przerwany w trakcie zapisu, pozostawiając częściowy katalog punktów kontrolnych. databricks.air.data.UCVolumeWriter Publikuje .metadata plik do woluminu dopiero po zakończeniu przesyłania plików danych odłamków, więc obecność pliku .metadata jest wiarygodnym sygnałem, że zapis został ukończony. Użyj go, aby wybrać najnowszy prawidłowy punkt zapisu przy wznowieniu.

import os

def find_latest_valid(checkpoint_root):
    """Return the newest checkpoint directory that finished writing, or None."""
    candidates = sorted(
        (d for d in os.listdir(checkpoint_root) if d.startswith("step_")),
        key=lambda d: int(d.split("_")[1]),
        reverse=True,
    )
    for name in candidates:
        path = os.path.join(checkpoint_root, name)
        if os.path.exists(os.path.join(path, ".metadata")):  # save completed
            return path
    return None  # nothing valid; start fresh

Odporna pętla treningowa wybiera najnowszy prawidłowy checkpoint, przywraca go i często zapisuje checkpointy. Interwał punktu kontrolnego ogranicza utratę pracy po przerwaniu, więc częste, tanie asynchroniczne zapisy ograniczają zakres ponownych obliczeń:

CHECKPOINT_EVERY = 100

latest = find_latest_valid("/Volumes/my-catalog/my-schema/my-volume/checkpoints")
start_step = 0
if latest is not None:
    model_sd, optim_sd = get_state_dict(model, optimizer)
    state = {"model": model_sd, "optim": optim_sd, "step": 0}
    dcp.load(state, storage_reader=databricks.air.data.UCVolumeReader(latest))
    set_state_dict(
        model,
        optimizer,
        model_state_dict=state["model"],
        optim_state_dict=state["optim"],
    )
    start_step = state["step"]

for step in range(start_step, total_steps):
    train_step(...)
    if step % CHECKPOINT_EVERY == 0:
        save_async(step, model, optimizer)  # inexpensive, so run it often

Ta pętla zapisuje stan modelu i optymalizatora w punktach kontrolnych. Nie przywraca jeszcze pozycji pipeline'u danych, co jest opisane w następnej sekcji.

Utwórz punkt kontrolny potoku danych

Punkt kontrolny modelu rejestruje stan modelu i optymalizatora, ale nie określa pozycji twojego potoku danych w zbiorze danych. Załóżmy, że przywracasz model w kroku 1900, ale dataloader zaczyna od początku zbioru danych. Wznowione uruchomienie ponownie uczy się na przykładach już przetworzonych w tej epoce i pomija przykłady w pobliżu punktu przerwania, po cichu zaburzając rozkład danych, nie zgłaszając błędu.

Aby wznowić pracę na właściwych danych, śledź swoją pozycję w zbiorze danych jako część własnego stanu treningowego i przywróć ją po wznowieniu. Należy wziąć pod uwagę cztery kwestie:

Śledzenie próbki danych lub przesunięcia sharda

Zanotuj, jak daleko w epoce zaszedłeś, używając globalnego indeksu próbki, liczby partii lub listy zużytych identyfikatorów odłamków w słowniku stanu checkpointu, i przejdź do tej pozycji, gdy wznowisz. Dzięki temu stan danych jest pod twoją pełną kontrolą, zamiast polegać na dataloaderze do serializacji jego stanu wewnętrznego.

# Include the data position in the checkpoint state dict:
state_dict = {
    "model": model_sd,
    "optim": optim_sd,
    "step": step,
    "epoch": epoch,
    "samples_seen": samples_seen,  # your own counter, advanced each batch
}

W przypadku zestawu danych w stylu mapowym z deterministycznym samplerem pomiń partie już wykorzystane w tej epoce podczas wznowienia. Ponieważ kolejność próbkowania jest deterministyczna dla danego (seed, epoch) (zobacz Ustaw potok deterministyczny), przewijanie do przodu odtwarza dokładną pozycję:

resume_batch = state["samples_seen"] // batch_size

for epoch in range(start_epoch, num_epochs):
    sampler.set_epoch(epoch)
    for batch_idx, batch in enumerate(loader):
        # On the resumed epoch only, skip batches already processed.
        if epoch == start_epoch and batch_idx < resume_batch:
            continue
        train_step(batch)
        samples_seen += batch_size

W przypadku fragmentowanego, strumieniowego zestawu danych śledź zamiast tego zestaw ukończonych fragmentów i przekaż wznowionemu uruchomieniu tylko te fragmenty, które pozostały. Dzięki temu nie musisz ponownie przetwarzać partii z całej epoki tylko po to, by dotrzeć do punktu przerwania:

# Filter the shard list down to work not yet done, then build the loader from it.
remaining = [s for s in all_shards if s not in state["completed_shards"]]
dataset = ShardDataset(remaining)

Utwórz punkt kontrolny stanu wewnętrznego niestandardowego zbioru danych

Jeśli piszesz własny zbiór danych, nadaj mu metody serializacji i przywracania własnej pozycji, a ten stan włącz do punktu kontrolnego. Dzięki temu logika wznawiania pozostaje obok logiki iteracji, a zbiór danych dokładnie wie, do czego musi się przewinąć (aktualny fragment, offset w nim, zawartość bufora shuffle itd.), zamiast aby pętla treningowa odtwarzała go na podstawie zewnętrznego licznika.

from torch.utils.data import IterableDataset

class ResumableShardDataset(IterableDataset):
    """A streaming dataset that can checkpoint and restore its own position."""

    def __init__(self, shards):
        self._shards = shards
        self._shard_idx = 0      # position advanced during __iter__
        self._offset = 0

    def state_dict(self):
        return {"shard_idx": self._shard_idx, "offset": self._offset}

    def load_state_dict(self, state):
        self._shard_idx = state["shard_idx"]
        self._offset = state["offset"]

    def __iter__(self):
        for i in range(self._shard_idx, len(self._shards)):
            self._shard_idx = i
            for j, example in enumerate(self._read_shard(self._shards[i])):
                if j < self._offset:
                    continue  # skip examples already consumed from this shard
                self._offset = j + 1
                yield example
            self._offset = 0
# Save and restore the dataset position with the rest of the checkpoint state.
state_dict["dataset"] = dataset.state_dict()
# On resume:
dataset.load_state_dict(state["dataset"])

Uruchom ponownie od granicy epoki

Jeśli przeskok do przodu jest niemożliwy, twórz punkty kontrolne tylko na granicach epok i wznowij na początku następnej epoki. Wówczas przebieg obejmuje każdy przykład dokładnie raz na epokę pomimo przerwania, kosztem utraty nawet jednej epoki postępu przy każdej awarii. Jest to najprostsze, gdy epoki są krótkie względem wskaźnika zawodności.

Uczyń potok przetwarzania deterministycznym

Każda z tych strategii wznawia działanie tylko na podstawie właściwych danych, jeśli potok jest powtarzalny z zapisanego stanu. Tasowanie i augmentacja czerpią z RNG, więc ustaw dla nich ziarno i przenoś ich stan w checkpointie. W przeciwnym razie kolejność tasowania i augmentacji po restarcie nie pokrywa się z kolejnością sprzed przerwy, a offset skip-ahead wskazuje na niewłaściwe próbki.

Aby wznowić proces w połowie pipeline'u, a nie tylko na granicy epoki, RNG napędzające tasowanie i augmentację muszą umożliwiać tworzenie checkpointów. Samo seeding odtwarza sekwencję od początku, ale nie od punktu, w którym przerwano. Używaj obiektów RNG, których wewnętrzny stan możesz serializować, i zapisz ten stan jako punkt kontrolny, aby każdy RNG kontynuował dokładnie tam, gdzie się skończył. Poleganie na globalnym RNG, które jest ponownie inicjalizowane dopiero na początku epoki, powoduje odtwarzanie tych samych losowań od początku epoki, co nie odpowiada już przesunięciu skip-ahead w środku epoki.

Zainicjuj wszystkie źródła losowości:

import random
import numpy as np
import torch

def seed_everything(seed: int):
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)

Zapisz i przywróć stan RNG wraz z modelem, aby sekwencje augmentacji i tasowania przebiegały płynnie:

# Save
state_dict["rng"] = {
    "python": random.getstate(),
    "numpy": np.random.get_state(),
    "torch": torch.get_rng_state(),
    "cuda": torch.cuda.get_rng_state_all(),
}

# Load
rng = state["rng"]
random.setstate(rng["python"])
np.random.set_state(rng["numpy"])
torch.set_rng_state(rng["torch"])
torch.cuda.set_rng_state_all(rng["cuda"])

Jeśli używasz DistributedSampler zamiast stanowego ładowacza danych, wywołaj sampler.set_epoch(epoch) na początku każdej epoki. Ponieważ tasowanie jest deterministyczną funkcją (seed, epoch), przywrócenie licznika epok odtwarza dokładną permutację:

for epoch in range(start_epoch, num_epochs):
    sampler.set_epoch(epoch)  # deterministic reshuffle per epoch
    for batch in loader:
        ...

Note

Aby zapewnić poprawność potoku danych, potrzebna jest powtarzalność kolejności danych i strumienia augmentacji, co zapewniają powyższe inicjalizacja ziarna i zapisywanie stanu RNG. Zazwyczaj nie potrzebujesz identycznych bitowo przebiegów w przód; torch.use_deterministic_algorithms(True) wymusza deterministyczne jądra, ale może zmniejszyć przepustowość i nie obejmuje każdej operacji.