Pytorch-Lightning-Learning

Pytorch-Lightning-Learning

0 Vorwort

Von hier umgezogen
Kurzes Pytorch-Lightning-Tutorial
Vollständiger Leitfaden für Pytorch Lightning
PyTorch Lightning ist vollständig von Pytorch geerbt. Alles in Pytorch kann in PyTorch Lightning verwendet werden, und alle Elemente in PyTorch Lightning können auch in Pytorch verwendet werden.
PyTorch Lightning enthält als High-Level-Paket von Pytorch eine vollständige und modifizierbare Trainingslogik.
Die Hardwareerkennung von PyTorch Lightning basiert auf Pytorch und kann auch mit Trainer geändert werden.
Datentypen ändern sich in PyTorch Lightning automatisch, es sind keine .cpu und .cuda erforderlich.

1. Definieren Sie den Datensatz mit Pytorchs Dataset und DataLoader

2. Verwenden Sie LightningModule, um das Modell zu definieren und die Trainingslogik zu implementieren

LightningModule: Eine der beiden Haupt-APIs von Pytorch Lightning. Es handelt sich um eine Kapselung auf hoher Ebene von Torch.nn.Module.

(1) Definieren Sie das Modell

__init__(): Identisch mit __init__ in Torch.nn.Module, wird zum Erstellen von Modellen verwendet.
forward(*args, **kwargs): Wie vorwärts in Torch.nn.Module wird die Vorwärtsausbreitung durch jedes Modul in __init__ implementiert.

(2) Trainingsmodell

#训练模型
training_step(*args, **kwargs)
"""
训练一批数据并反向传播。参数如下：
- batch (Tensor | (Tensor, …) | [Tensor, …]) – 数据输入，一般为x, y = batch。
- batch_idx (int) – 批次索引。
- optimizer_idx (int) – 当使用多个优化器时，会使用本参数。
- hiddens (Tensor) – 当truncated_bptt_steps > 0时使用。
"""
#举个例子：

def training_step(self, batch, batch_idx): # 数据类型自动转换，模型自动调用.train()
    x, y = batch
    _y = self(x)
    loss = criterion(_y, y) # 计算loss
    return loss # 返回loss，更新网络

def training_step(self, batch, batch_idx, hiddens):
    # hiddens是上一次截断反向传播的隐藏状态
    out, hiddens = self.lstm(data, hiddens)
    return {
    
    "loss": loss, "hiddens": hiddens}

#--------------------------------------

training_step_end(*args, **kwargs)
"""一批数据训练结束时的操作。一般用不着，分布式训练的时候会用上。参数如下：
- batch_parts_outputs – 当前批次的training_step()的返回值
"""
#举个例子：
def training_step(self, batch, batch_idx):
    x, y = batch
    _y = self(x)
    return {
    
    "output": _y， "target": y}

def training_step_end(self, training_step_outputs): # 多GPU分布式训练,计算loss
    gpu_0_output = training_step_outputs[0]["output"]
    gpu_1_output = training_step_outputs[1]["output"]
    
    gpu_0_target = training_step_outputs[0]["target"]
    gpu_1_target = training_step_outputs[1]["target"]

    # 对所有GPU的数据进行处理
    loss = criterion([gpu_0_output, gpu_1_output]， [gpu_0_target, gpu_1_target])
    return loss

#--------------------------------------

training_epoch_end(outputs)
"""一轮数据训练结束时的操作。主要针对于本轮所有training_step的输出。参数如下：
- outputs (List[Any]) – training_step()的输出。
"""
#举个例子：
def training_epoch_end(self, outs): # 计算本轮的loss和acc
    loss = 0.
    for out in outs: # outs按照训练顺序排序
        loss += out["loss"].cpu().detach().item()
    loss /= len(outs)
    acc = self.train_metric.compute()

    self.history["loss"].append(loss)
    self.history["acc"].append(acc)

Drei Kernkomponenten:

Modell
Optimierer
Trainings-/Value-/Testschritte

Datenfluss-Pseudocode:

outs = []
for batch in data:
    out = training_step(batch)
    outs.append(out)
training_epoch_end(outs)

Äquivalenter Lightning-Code:

def training_step(self, batch, batch_idx):
    prediction = ...
    return prediction

def training_epoch_end(self, training_step_outputs):
    for prediction in predictions:
        # do something with these

Alles, was wir tun müssen, ist, diese Funktionen genau wie die Lücken auszufüllen.

3. Verwenden Sie die Trainer-Konfigurationsparameter für das automatische Training

Eine der beiden Haupt-APIs von Pytorch Lightning verbindet, ähnlich wie „Glue“, verschiedene Teile von LightningModule zu einer vollständigen Logik.

(1) Methode

__init__(logger=True, checkpoint_callback=True, callbacks=None, \
default_root_dir=None, gradient_clip_val=0, process_position=0, num_nodes=1, \
num_processes=1, gpus=None, auto_select_gpus=False, tpu_cores=None, \
log_gpu_memory=None, progress_bar_refresh_rate=1, overfit_batches=0.0, \
track_grad_norm=-1, check_val_every_n_epoch=1, fast_dev_run=False, \
accumulate_grad_batches=1, max_epochs=1000, min_epochs=1, max_steps=None, \
min_steps=None, limit_train_batches=1.0, limit_val_batches=1.0, \
limit_test_batches=1.0, val_check_interval=1.0, flush_logs_every_n_steps=100, \
log_every_n_steps=50, accelerator=None, sync_batchnorm=False, precision=32, \
weights_summary='top', weights_save_path=None, num_sanity_val_steps=2, \
truncated_bptt_steps=None, resume_from_checkpoint=None, profiler=None, \
benchmark=False, deterministic=False, reload_dataloaders_every_epoch=False, \
auto_lr_find=False, replace_sampler_ddp=True, terminate_on_nan=False, \
auto_scale_batch_size=False, prepare_data_per_node=True, plugins=None, \
amp_backend='native', amp_level='O2', distributed_backend=None, \
automatic_optimization=True, move_metrics_to_cpu=False)

Es gibt viele Parameter zum Initialisieren des Trainers, die im Folgenden vorgestellt werden:

Hardware-Parameter:
- gpus[Keine]:
  - Legen Sie den Wert 0 oder None fest, um die CPU zu verwenden.
  - Auf eine Ganzzahl n größer als 0 gesetzt, was angibt, dass n GPUs verwendet werden.
  - Wird auf eine ganzzahlige Zeichenfolge „n“ größer als 0 gesetzt, was angibt, dass die GPU mit der ID n verwendet werden soll.
  - Legen Sie den Wert auf -1 oder „-1“ fest, um alle GPUs zu verwenden.
  - Wird auf ein ganzzahliges Array [a, b] oder eine ganzzahlige Array-Zeichenfolge „a, b“ festgelegt, was angibt, dass die GPUs mit den IDs a und b verwendet werden.
- auto_select_gpus[False]:
  - Auf „True“ setzen, um automatisch die erforderliche GPU auszuwählen.
  - Auf „False“ setzen, um die gewünschten GPUs nacheinander auszuwählen.
- num_nodes[1]:
  - Auf 1 setzen, um den aktuellen GPU-Knoten auszuwählen.
  - Auf eine Ganzzahl n größer als 0 gesetzt, was angibt, dass n Knoten verwendet werden.
- tpu_cores[Keine]:
  - Legen Sie „Keine“ fest, um kein TPU zu verwenden.
  - Auf 1 einstellen, um 1 TPU-Kern zu verwenden.
  - Wird auf ein ganzzahliges Array [n] größer als 0 gesetzt, was angibt, dass der TPU-Kern mit der ID n verwendet wird.
  - Stellen Sie den Wert auf 8 ein, um alle TPU-Kerne zu verwenden.
Genauigkeitsparameter:
- Präzision[32]: Auf 2, 4, 8, 16 oder 32 eingestellt, was jeweils unterschiedliche Genauigkeiten anzeigt.
- amp_backend[„native“]:
  - Legen Sie „native“ fest, um native gemischte Präzision zu verwenden.
  - Stellen Sie „Apex“ ein, um die gemischte Apex-Präzision zu verwenden.
- amp_level[„O2“]: Auf O0, O1, O2 bzw. O3 setzen:
  - O0: Reines FP32-Training, das als Grundlage für Genauigkeit verwendet werden kann.
  - O1: Gemischtes Präzisionstraining (empfohlen), bestimmt automatisch, ob FP16 (GEMM, Faltung) oder FP32 (Softmax) für die Berechnung basierend auf der schwarzen und weißen Liste verwendet werden soll.
  - O2: „Fast FP16“ gemischtes Präzisionstraining, es gibt keine schwarze und weiße Liste, außer der Batch-Norm, fast alle Berechnungen werden in FP16 durchgeführt.
  - O3: Das reine FP16-Training ist sehr instabil, kann aber als Grundlage für Geschwindigkeit verwendet werden.
Hyperparameter trainieren:
- max_epochs[1000]: Maximale Anzahl an Trainingsrunden.
- min_epochs[1]: Mindestanzahl an Trainingsrunden.
- max_steps[None]: Maximale Anzahl an Trainingsschritten pro Runde.
- min_steps[Keine]: Mindestanzahl an Trainingsschritten pro Runde.
Protokollparameter und Prüfpunktparameter:
- checkpoint_callback[True]:
  - Auf „True“ setzen, um die Prüfpunktspeicherung automatisch durchzuführen.
  - Auf „Falsch“ setzen, um keine Prüfpunktspeicherung durchzuführen.
- logger[TensorBoardLogger]: Richten Sie das Protokolltool ein. Falsch bedeutet, dass Logger nicht verwendet wird.
- default_root_dir[os.getcwd()]: Das Standardstammverzeichnis, das zum Speichern von Protokollen und Prüfpunkten verwendet wird.
- Flush_logs_every_n_steps[100]: Wie viele Schritte zum Aktualisieren des Protokolls auf der Festplatte.
- log_every_n_steps[50]: Wie viele Schritte zum Aktualisieren des Protokolls im Speicher.
- log_gpu_memory[Keine]:
  - Legen Sie „Keine“ fest, um keine GPU-Speicherinformationen aufzuzeichnen.
  - Auf „alle“ einstellen, um alle GPU-Speicherinformationen aufzuzeichnen.
  - Auf „min_max“ setzen, um den Maximalwert der GPU-Speicherinformationen aufzuzeichnen.
- check_val_every_n_epoch[1]: Wie viele Überprüfungsrunden.
- val_check_interval[1.0]:
  - Auf eine Dezimalzahl eingestellt, was bedeutet, dass ein bestimmter Anteil des Validierungssatzes übernommen wird.
  - Auf eine Ganzzahl gesetzt, die angibt, dass eine bestimmte Anzahl von Verifizierungssätzen durchgeführt wird.
- resume_from_checkpoint[Keine]: Checkpoint-Lebenslauf, Eingabepfad.
- progress_bar_refresh_rate[1]: Die Aktualisierungsrate des Fortschrittsbalkens.
- Weights_summary[„top“]:
  - Legen Sie „Keine“ fest, um keine Modellinformationen auszugeben.
  - Auf „oben“ einstellen, um Kurzinformationen zum Modell auszugeben.
  - Auf „full“ setzen, um alle Modellinformationen auszugeben.
- weights_save_path[os.getcwd()]:
  - Der Weg, um die Gewichte zu sparen.
Testparameter:
- num_sanity_val_steps[2]: Wie viele Stapel von Validierungsdaten vor dem Training überprüft werden sollen.
- fast_dev_run[False]: Eine Reihe von Unit-Tests.
- reload_dataloaders_every_epoch[False]: Ob Daten in jeder Runde neu geladen werden sollen.
Verteilte Parameter:
- Beschleuniger[Keine]:
  - dp (DataParallel) dient dazu, die Stapelverarbeitung zwischen GPUs desselben Computers aufzuteilen.
  - ddp (DistributedDataParallel) wird auf jeder GPU auf jedem Knoten trainiert und synchronisiert Farbverläufe. TPU-Standardoption.
  - ddp_cpu (DistributedDataParallel on CPU) ist dasselbe wie ddp, verwendet jedoch nicht die GPU. Nützlich für das CPU-Training mit mehreren Knoten oder das Debuggen einzelner Knoten.
  - ddp2 ist der dp auf dem Knoten und der ddp zwischen Knoten.
- akkumulieren_grad_batches[1]: Wie viele Stapel werden zum Sammeln von Farbverläufen verwendet?
- sync_batchnorm[False]: Synchrone Stapelverarbeitung, wird im Allgemeinen bei der Verteilung mit mehreren GPUs verwendet.
Automatische Parameter:
- Automatic_optimization[True]: Ob die automatische Optimierung aktiviert werden soll.
- auto_scale_batch_size[None]: Ob die maximale Batchgröße automatisch ermittelt werden soll.
- auto_lr_find[False]: Ob automatisch die beste Lernrate gefunden werden soll.
Deterministische Parameter:
- benchmark[False]: ob cudnn.benchmark verwendet werden soll.
- deterministic[False]: Ob Determinismus aktiviert werden soll.
Restriktive und Probenahmeparameter:
- gradient_clip_val[0.0]: Verlaufsausschnitt.
- limit_train_batches[1.0]: Begrenzen Sie die Anzahl der Trainingsbatches pro Runde.
- limit_val_batches[1.0]: Begrenzen Sie die Anzahl der Verifizierungsstapel in jeder Runde.
- limit_test_batches[1.0]: Begrenzen Sie die Anzahl der Teststapel pro Runde.
- overfit_batches[0.0]: Begrenzen Sie die Anzahl der Duplikate in einem Stapel.
- Prepare_data_per_node[True]: Ob Daten für jeden Knoten vorbereitet werden sollen.
- replace_sampler_ddp[True]: Ob die Funktion zum automatischen Hinzufügen verteilter Sampler aktiviert werden soll.
Weitere Parameter:
- Rückrufe[]: Gute Leute, Rückruf.
- process_position[0]: Verarbeiten Sie den Fortschrittsbalken der Reihe nach.
- Profiler[Keine]
- track_grad_norm[-1]
- truncated_bptt_steps[Keine]
fit(model, train_dataloader=None, val_dataloaders=None, datamodule=None)
startet das Training. Die Parameter sind wie folgt:
- datamodule (Optional[LightningDataModule]) – eine LightningDataModule-Instanz.
- Modell (LightningModule) – das trainierte Modell.
- train_dataloader (Optional[DataLoader]) – Trainingsdaten.
- val_dataloaders (Union[DataLoader, List[DataLoader], None]) – Daten validieren.
test(model=None, test_dataloaders=None, ckpt_path='best', verbose=True, datamodule=None)
aktiviert den Test. Die Parameter sind wie folgt:
- ckpt_path (Optional[str]) – best oder der Pfad mit der Checkpoint-Gewichtung, die Sie am meisten testen möchten, None verwendet die letzte Gewichtung.
- datamodule (Optional[LightningDataModule]) – eine LightningDataModule-Instanz.
- model (Optional[LightningModule]) – Das zu testende Modell.
- test_dataloaders (Union[DataLoader, List[DataLoader], None]) – Testdaten.
- verbose (bool) – ob Ergebnisse gedruckt werden sollen.
tune(model, train_dataloader=None, val_dataloaders=None, datamodule=None)
passt Hyperparameter vor dem Training an. Die Parameter sind wie folgt:
- datamodule (Optional[LightningDataModule]) – eine LightningDataModule-Instanz.
- model (LightningModule) – Das angepasste Modell.
- train_dataloader (Optional[DataLoader]) – Trainingsdaten.
- val_dataloaders (Union[DataLoader, List[DataLoader], None]) – Daten validieren.

(2) Attribute

callback_metrics Callback-Metriken. Zum Beispiel:

def training_step(self, batch, batch_idx):
    self.log('a_val', 2)

callback_metrics = trainer.callback_metricpythons
assert callback_metrics['a_val'] == 2

current_epoch aktuelle Epochennummer. Zum Beispiel:

def training_step(self, batch, batch_idx):
    current_epoch = self.trainer.current_epoch
    if current_epoch > 100:
        # do something
        pass

Logger aktuelles Protokoll. Zum Beispiel:

def training_step(self, batch, batch_idx):
    logger = self.trainer.logger
    tensorboard = logger.experiment

log_metrics An Protokolle gesendete Metriken. Zum Beispiel:

def training_step(self, batch, batch_idx):
    self.log('a_val', 2, log=True)

logged_metrics = trainer.logged_metrics
assert logged_metrics['a_val'] == 2

log_dir aktuelles Verzeichnis, das zum Speichern von Bildern usw. verwendet wird. Zum Beispiel:

def training_step(self, batch, batch_idx):
    img = ...
    save_img(img, self.trainer.log_dir)

is_global_zero ist die globale erste.
progress_bar_metrics An die Fortschrittsleiste gesendete Metriken. Zum Beispiel:

def training_step(self, batch, batch_idx):
    self.log('a_val', 2, prog_bar=True)

progress_bar_metrics = trainer.progress_bar_metrics
assert progress_bar_metrics['a_val'] == 2

4. Rückruf

Das wichtigste Plug-In von Pytorch Lightning, universell, unbesiegbar, kann überall angeschlossen werden, Plug-and-Play.

(1) Trainingsmethode

on_train_start(trainer, pl_module)
Vorgang, wenn das erste Training beginnt.
on_train_end(trainer, pl_module)
Vorgang, wenn das letzte Training endet.
on_train_batch_start(trainer, pl_module, batch, batch_idx, dataloader_idx)
Vorgang, wenn ein Batch von Datentraining beginnt.
on_train_batch_end(trainer, pl_module, Outputs, Batch, Batch_idx, Dataloader_idx)
Vorgang, wenn ein Batch von Datentraining endet.
on_train_epoch_start(trainer, pl_module)
Vorgang, wenn eine Runde Datentraining beginnt.
on_train_epoch_end(trainer, pl_module, Outputs)
-Vorgang, wenn eine Datentrainingsrunde endet.

(2) Verifizierungsmethode

on_validation_start(trainer, pl_module)
Vorgang beim Start der ersten Verifizierung.
on_validation_end(self, trainer, pl_module)
Vorgang, wenn die letzte Überprüfung endet.
on_validation_batch_start(trainer, pl_module, batch, batch_idx, dataloader_idx)
Vorgang, wenn ein Batch der Datenvalidierung startet.
on_validation_batch_end(trainer, pl_module, Outputs, Batch, Batch_idx, Dataloader_idx)
Vorgang, wenn ein Batch der Datenüberprüfung endet.
on_validation_epoch_start(trainer, pl_module)
Vorgang, wenn eine Runde der Datenvalidierung beginnt.
on_validation_epoch_end(trainer, pl_module)
Vorgang, wenn eine Runde der Datenüberprüfung endet.

(3) Testmethode

on_test_start(trainer, pl_module)
Vorgang beim Start des ersten Tests.
on_test_end(self, trainer, pl_module)
Vorgang, wenn der letzte Test endet.
on_test_batch_start(trainer, pl_module, batch, batch_idx, dataloader_idx)
Vorgang, wenn ein Stapel von Datentests gestartet wird.
on_test_batch_end(trainer, pl_module, Outputs, Batch, Batch_idx, Dataloader_idx)
Vorgang, wenn ein Batch von Datentests endet.
on_test_epoch_start(trainer, pl_module)
Vorgang, wenn eine Runde von Datentests beginnt.
on_test_epoch_end(trainer, pl_module)
Vorgang, wenn eine Datentestrunde endet.

(4) Andere Methoden

on_fit_start(trainer, pl_module)
-Operation beim Aufruf von .fit.
on_fit_end(trainer, pl_module)
.Operation am Ende der Anpassung.

setup(trainer, pl_module, stage)
teardown(trainer, pl_module, stage)
on_init_start(trainer)
on_init_end(trainer)
on_sanity_check_start(trainer, pl_module)
on_sanity_check_end(trainer, pl_module)
on_batch_start(trainer, pl_module)
on_batch_end(trainer, pl_module)
on_epoch_start(trainer, pl_module)
on_epoch_end(trainer, pl_module)
on_keyboard_interrupt(trainer, pl_module)
on_save_checkpoint(trainer, pl_module)
on_load_checkpoint(checkpointed_state)

Pytorch-Lightning-Learning

Pytorch-Lightning-Learning

0 Vorwort

1. Definieren Sie den Datensatz mit Pytorchs Dataset und DataLoader

2. Verwenden Sie LightningModule, um das Modell zu definieren und die Trainingslogik zu implementieren

3. Verwenden Sie die Trainer-Konfigurationsparameter für das automatische Training

4. Rückruf

Guess you like