Pytorch-Lightning-Aprendizaje

Enterprise 2023-10-04 21:41:47 views: null

0 Prefacio

  • Se mudó de aquí

  • Tutorial conciso de Pytorch-Lightning

  • Guía completa de Pytorch Lightning

  • PyTorch Lightning se hereda completamente de Pytorch: todo lo que hay en Pytorch se puede usar en PyTorch Lightning y todos los elementos de PyTorch Lightning también se pueden usar en Pytorch.

  • PyTorch Lightning, como paquete de alto nivel de Pytorch, contiene una lógica de entrenamiento completa y modificable.

  • La detección de hardware de PyTorch Lightning se basa en Pytorch y también se puede modificar con Trainer.

  • Los tipos de datos cambian automáticamente en PyTorch Lightning, sin necesidad de .cpu y .cuda.

1. Defina el conjunto de datos utilizando Dataset y DataLoader de Pytorch.

2. Utilice LightningModule para definir el modelo e implementar la lógica de entrenamiento.

  • LightningModule: una de las dos API principales de Pytorch Lightning, es una encapsulación de alto nivel de torch.nn.Module.

(1) Definir el modelo

  • __init__():Igual que __init__ en torch.nn.Module, usado para construir modelos.

  • forward(*args, **kwargs):Igual que adelante en torch.nn.Module, la propagación hacia adelante se implementa a través de cada módulo en __init__.

(2) Modelo de entrenamiento

#训练模型
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)

Tres componentes principales:

  • Modelo
  • optimizador
  • Pasos de tren/Val/prueba

Pseudocódigo de flujo de datos:

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

Código Lightning equivalente:

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

Todo lo que tenemos que hacer es completar estas funciones como si llenaran los espacios en blanco.

3. Utilice los parámetros de configuración del Entrenador para el entrenamiento automático.

  • Una de las dos API principales de Pytorch Lightning, similar al "pegamento", conecta varias partes de LightningModule para formar una lógica completa.

(1) Método

__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)

Hay muchos parámetros para inicializar el entrenador, que se presentarán a continuación:

  • Parámetros de hardware:

    • gpus[Ninguno]:
      • Establezca en 0 o Ninguno para usar la CPU.
      • Establecido en un número entero n mayor que 0, lo que indica que se utilizan n GPU.
      • Establezca una cadena entera 'n' mayor que 0, lo que indica que se debe usar la GPU con ID n.
      • Establezca en -1 o '-1' para usar todas las GPU.
      • Establezca una matriz de enteros [a, b] o una cadena de matriz de enteros 'a, b', lo que indica que se utilizan las GPU con ID a y b.
    • auto_select_gpus[Falso]:
      • Configúrelo en Verdadero para seleccionar automáticamente la GPU requerida.
      • Configúrelo en False para seleccionar las GPU deseadas secuencialmente.
    • núm_nodos[1]:
      • Establezca en 1 para seleccionar el nodo de gpu actual.
      • Establecido en un número entero n mayor que 0, lo que indica que se utilizan n nodos.
    • tpu_cores[Ninguno]:
      • Establezca en Ninguno para no usar tpu.
      • Establezca en 1 para usar 1 núcleo de tpu.
      • Establezca una matriz de enteros [n] mayor que 0, lo que indica que se utiliza el núcleo de TPU con id n.
      • Configúrelo en 8 para usar todos los núcleos de tpu.

  • Parámetros de precisión:

    • precision[32]: Establecido en 2, 4, 8, 16 o 32, indicando diferentes precisiones respectivamente.
    • amp_backend[“nativo”]:
      • Establezca en "nativo" para utilizar precisión mixta nativa.
      • Establezca en "ápice" para utilizar precisión mixta de ápice.
    • amp_level[“O2”]: establecido en O0, O1, O2 u O3, respectivamente:
      • O0: entrenamiento FP32 puro, que se puede utilizar como base para la precisión.
      • O1: entrenamiento de precisión mixto (recomendado), determina automáticamente si se utiliza FP16 (GEMM, convolución) o FP32 (Softmax) para el cálculo según la lista blanca y negra.
      • O2: Entrenamiento de precisión mixto "Casi FP16", no hay una lista blanca y negra, excepto la norma por lotes, casi todos los cálculos se realizan en FP16.
      • O3: El entrenamiento puro del FP16 es muy inestable, pero puede usarse como base para la velocidad.

  • Hiperparámetros de entrenamiento:

    • max_epochs[1000]: Número máximo de rondas de entrenamiento.
    • min_epochs[1]: Número mínimo de rondas de entrenamiento.
    • max_steps[Ninguno]: Número máximo de pasos de entrenamiento por ronda.
    • min_steps[Ninguno]: número mínimo de pasos de entrenamiento por ronda.

  • Parámetros de registro y parámetros de punto de control:

    • checkpoint_callback[Verdadero]:
      • Configúrelo en Verdadero para guardar automáticamente el punto de control.
      • Configúrelo en Falso para no guardar puntos de control.
    • logger[TensorBoardLogger]: configura la herramienta de registro. Falso significa no utilizar el registrador.
    • default_root_dir[os.getcwd()]: el directorio raíz predeterminado, utilizado para guardar registros y puntos de control.
    • Flush_logs_every_n_steps[100]: cuántos pasos se deben actualizar el registro en el disco.
    • log_every_n_steps[50]: cuántos pasos se deben actualizar el registro en la memoria.
    • log_gpu_memory[Ninguno]:
      • Establezca en Ninguno para no registrar información de la memoria de la GPU.
      • Configúrelo en "todo" para registrar toda la información de la memoria de la GPU.
      • Establezca en "min_max" para registrar el valor máximo de información de la memoria de la GPU.
    • check_val_every_n_epoch[1]: cuántas rondas de verificación.
    • val_check_interval[1.0]:
      • Establecer en un decimal, lo que significa tomar una cierta proporción del conjunto de validación.
      • Establecido en un número entero, indica que se tomará una cierta cantidad de conjuntos de verificación.
    • resume_from_checkpoint[Ninguno]: resumen del punto de control, ruta de entrada.
    • Progress_bar_refresh_rate[1]: la frecuencia de actualización de la barra de progreso.
    • resumen_pesos[“arriba”]:
      • Establezca en Ninguno para no generar información del modelo.
      • Establezca en "arriba" para generar información breve del modelo.
      • Establezca en "completo" para generar toda la información del modelo.
    • pesos_save_path[os.getcwd()]:
      • El camino para salvar los pesos.

  • Parámetros de prueba:

    • num_sanity_val_steps[2]: cuántos lotes de datos de validación se deben verificar antes del entrenamiento.
    • fast_dev_run[False]: una serie de pruebas unitarias.
    • reload_dataloaders_every_epoch[False]: si se deben recargar datos en cada ronda.

  • Parámetros distribuidos:

    • acelerador[Ninguno]:

      • dp (DataParallel) consiste en dividir el procesamiento por lotes entre GPU de la misma computadora.

      • ddp (DistributedDataParallel) se entrena en cada GPU en cada nodo y sincroniza los gradientes. Opción predeterminada de TPU.

      • ddp_cpu (DistributedDataParallel en CPU) es lo mismo que ddp, pero no usa la GPU. Útil para el entrenamiento de CPU de múltiples nodos o la depuración de un solo nodo.

      • ddp2 es el dp en el nodo y el ddp entre nodos.

    • acumular_grad_batches[1]: cuántos lotes se utilizan para acumular gradientes.

    • sync_batchnorm[False]: procesamiento por lotes sincrónico, generalmente utilizado cuando se distribuye con varias GPU.

  • Parámetros automáticos:

    • automatic_optimization[True]: si se habilita la optimización automática.
    • auto_scale_batch_size[Ninguno]: si se busca automáticamente el tamaño máximo de lote.
    • auto_lr_find[False]: si se busca automáticamente la mejor tasa de aprendizaje.

  • Parámetros deterministas:

    • punto de referencia [Falso]: si se debe utilizar cudnn.benchmark.
    • determinista [Falso]: si se debe habilitar el determinismo.

  • Parámetros restrictivos y de muestreo:

    • gradient_clip_val[0.0]: Recorte de degradado.
    • limit_train_batches[1.0]: limita el número de lotes de entrenamiento por ronda.
    • limit_val_batches[1.0]: limita el número de lotes de verificación en cada ronda.
    • limit_test_batches[1.0]: limita el número de lotes de prueba por ronda.
    • overfit_batches[0.0]: limita el número de duplicados en un lote.
    • prepare_data_per_node[True]: si se deben preparar datos para cada nodo.
    • replace_sampler_ddp[True]: si se habilita la función de agregar automáticamente muestreadores distribuidos.

  • Otros parámetros:

    • devoluciones de llamada []: Buenos chicos, devolución de llamada.
    • Process_position[0]: Procesa la barra de progreso en orden.
    • perfilador[Ninguno]
    • track_grad_norm[-1]
    • truncated_bptt_steps[Ninguno]

  • fit(model, train_dataloader=Ninguno, val_dataloaders=Ninguno, datamodule=Ninguno)
    comienza a entrenar. Los parámetros son los siguientes:

    • módulo de datos (Opcional[LightningDataModule]): una instancia de LightningDataModule.
    • modelo (LightningModule): el modelo entrenado.
    • train_dataloader (Opcional[DataLoader]) – datos de entrenamiento.
    • val_dataloaders (Unión[DataLoader, List[DataLoader], Ninguno]) – Validar datos.

  • test(model=None, test_dataloaders=None, ckpt_path='best', verbose=True, datamodule=None)
    activa la prueba. Los parámetros son los siguientes:

    • ckpt_path (Opcional[str]): mejor o la ruta con el peso del punto de control que más desea probar. Ninguno usa el último peso.
    • módulo de datos (Opcional[LightningDataModule]): una instancia de LightningDataModule.
    • modelo (Opcional[LightningModule]): el modelo a probar.
    • test_dataloaders (Unión[DataLoader, List[DataLoader], Ninguno]) – datos de prueba.
    • detallado (bool): si se imprimen los resultados.

  • tune(model, train_dataloader=Ninguno, val_dataloaders=Ninguno, datamodule=Ninguno)
    ajusta los hiperparámetros antes del entrenamiento. Los parámetros son los siguientes:

    • módulo de datos (Opcional[LightningDataModule]): una instancia de LightningDataModule.
    • modelo (LightningModule): el modelo ajustado.
    • train_dataloader (Opcional[DataLoader]) – datos de entrenamiento.
    • val_dataloaders (Unión[DataLoader, List[DataLoader], Ninguno]) – Validar datos.

(2) Atributos

  • callback_metrics métricas de devolución de llamada. Por ejemplo:
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 número de época actual. Por ejemplo:
def training_step(self, batch, batch_idx):
    current_epoch = self.trainer.current_epoch
    if current_epoch > 100:
        # do something
        pass
  • registro actual del registrador. Por ejemplo:
def training_step(self, batch, batch_idx):
    logger = self.trainer.logger
    tensorboard = logger.experiment
  • logged_metrics Métricas enviadas a los registros. Por ejemplo:
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 directorio actual, utilizado para guardar imágenes, etc. Por ejemplo:
def training_step(self, batch, batch_idx):
    img = ...
    save_img(img, self.trainer.log_dir)

  • is_global_zero es el primero a nivel mundial.

  • Progress_bar_metrics Métricas enviadas a la barra de progreso. Por ejemplo:

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.devolución de llamada

  • El complemento más nb de Pytorch Lightning, universal, invencible, se puede conectar en cualquier lugar, plug and play.

(1) Método de entrenamiento

  • on_train_start(trainer, pl_module)
    Operación cuando comienza el primer entrenamiento.

  • on_train_end(trainer, pl_module)
    Operación cuando finaliza el último entrenamiento.

  • on_train_batch_start(entrenador, pl_module, lote, lote_idx, dataloader_idx)
    Operación cuando comienza un lote de entrenamiento de datos.

  • on_train_batch_end(trainer, pl_module, salidas, lote, lote_idx, dataloader_idx)
    Operación cuando finaliza un lote de entrenamiento de datos.

  • on_train_epoch_start(trainer, pl_module)
    Operación cuando comienza una ronda de entrenamiento de datos.

  • Operación on_train_epoch_end(trainer, pl_module, salidas)
    cuando finaliza una ronda de entrenamiento de datos.

(2) Método de verificación

  • on_validation_start(trainer, pl_module)
    Operación cuando comienza la primera verificación.

  • on_validation_end(self, trainer, pl_module)
    Operación cuando finaliza la última verificación.

  • on_validation_batch_start(trainer, pl_module, lote, lote_idx, dataloader_idx)
    Operación cuando se inicia un lote de validación de datos.

  • on_validation_batch_end(trainer, pl_module, salidas, lote, lote_idx, dataloader_idx)
    Operación cuando finaliza un lote de verificación de datos.

  • on_validation_epoch_start(trainer, pl_module)
    Operación cuando comienza una ronda de validación de datos.

  • on_validation_epoch_end(trainer, pl_module)
    Operación cuando finaliza una ronda de verificación de datos.

(3) Método de prueba

  • on_test_start(trainer, pl_module)
    Operación cuando comienza la primera prueba.

  • on_test_end(self, trainer, pl_module)
    Operación cuando finaliza la última prueba.

  • on_test_batch_start(entrenador, pl_module, lote, lote_idx, dataloader_idx)
    Operación cuando se inicia un lote de pruebas de datos.

  • on_test_batch_end(trainer, pl_module, salidas, lote, lote_idx, dataloader_idx)
    Operación cuando finaliza un lote de pruebas de datos.

  • on_test_epoch_start(trainer, pl_module)
    Operación cuando comienza una ronda de pruebas de datos.

  • on_test_epoch_end(trainer, pl_module)
    Operación cuando finaliza una ronda de pruebas de datos.

(4) Otros métodos

  • Operación on_fit_start(trainer, pl_module)
    al llamar a .fit.

  • on_fit_end(trainer, pl_module)
    .Operación al final del ajuste.

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)

Supongo que te gusta

Origin blog.csdn.net/fb_941219/article/details/131556467
Recomendado
Clasificación
Diario
Más
2024-06-01(2)
2024-05-31(0)
2024-05-30(0)
2024-05-29(1)
2024-05-28(0)
2024-05-27(1)
2024-05-26(1)
2024-05-25(0)
2024-05-24(13)
2024-05-23(34)

Code World

© 2018 codetd.com