Notatka
Dostęp do tej strony wymaga autoryzacji. Może spróbować zalogować się lub zmienić katalogi.
Dostęp do tej strony wymaga autoryzacji. Możesz spróbować zmienić katalogi.
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:
- Wydajnie ładuj dane, żeby karty graficzne nie były bezczynne.
- Efektywnie zapisuj punkty kontrolne modelu i stan optymalizatora w woluminach Unity Catalog.
- Automatyczne odzyskiwanie po przerwaniu.
- Utwórz punkt kontrolny potoku danych, aby wznowiony przebieg kontynuował trenowanie na właściwych danych.
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.DataLoaderdo treningu wieloepokowego. Wymuszapersistent_workers=True, gdynum_workers > 0, dzięki czemu mechanizm śledzenia usuwania z pamięci podręcznej w pamięci każdego pracownika przetrwa przez epoki. Standardowy PyTorchDataLoaderdomyś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.UCVolumeDatasetDzieli pliki na partycje za pomocą globalnego kroku między gniazdamiworld_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.
Powiązane strony
- Załaduj dane w AI Runtime: ładowanie danych tabelarycznych i niestrukturalnych przez Unity Catalog.
- Śledzenie eksperymentów i obserwowalność: śledzenie eksperymentów MLflow, przeglądanie logów oraz monitorowanie zasobów GPU.
-
Trening rozproszony w notatnikach: dekorator
@distributedi trening na wielu procesorach GPU.