Modifique un guion PyTorch de entrenamiento

Si utiliza una técnica de optimización que se basa en normas de degradado globales, por ejemplo, una norma de degradado de todo el modelo, como algunas variantes del optimizador LAMB o el recorte de degradado global, debe recopilar todas las normas en las particiones del modelo para que sean correctas. Puede utilizar los tipos de datos básicos de comunicación de la biblioteca para hacerlo.

Todos los argumentos torch.Tensor a los métodos de reenvío del modelo nn.Modules deben utilizarse en el cálculo de la salida del módulo. En otras palabras, la biblioteca no admite ese caso en el que hay un argumento torch.Tensor a un módulo del que no depende la salida del módulo.

El argumento a la llamada smp.DistributedModel.backward() debe depender de todas las salidas del modelo. En otras palabras, no puede haber una salida de la llamada smp.DistributedModel.forward que no se utilice en el cálculo del tensor que se introduce en la llamada smp.DistributedModel.backward.

Si hay llamadas torch.cuda.synchronize() en su código, es posible que tenga que llamar torch.cuda.set_device(smp.local_rank()) inmediatamente antes de la llamada de sincronización. De lo contrario, se podrían crear contextos CUDA innecesarios en el dispositivo 0, que consumirá memoria innecesariamente.

Desde que la biblioteca coloca nn.Modules en distintos dispositivos, los módulos del modelo no deben depender de ningún estado global modificado en smp.step. Cualquier estado que permanezca fijo durante todo el entrenamiento o que se modifique fuera de smp.step de forma visible para todos los procesos, está permitido.

No es necesario mover el modelo a la GPU (por ejemplo, usando model.to(device)) al utilizar la biblioteca. Si intenta mover el modelo a la GPU antes de particionar el modelo (antes de la primera llamada smp.step), se ignora la llamada de movimiento. La biblioteca mueve automáticamente la parte del modelo asignada a un rango a su GPU. Una vez que comience el entrenamiento con la biblioteca, no mueva el modelo a la CPU y lo utilice, ya que no tendrá parámetros correctos para los módulos no asignados a la partición que tiene el proceso. Si quieres volver a entrenar un modelo o usarlo para realizar inferencias sin la biblioteca después de haberlo entrenado con la biblioteca de paralelismo de modelos, la forma recomendada es guardar el modelo completo con nuestra API de puntos de control y volver a cargarlo en un módulo normal. PyTorch

Si tiene una lista de módulos de modo que la salida de uno alimenta a otro, reemplazar esa lista por nn.Sequential puede mejorar significativamente el rendimiento.

La actualización de peso (optimizer.step()) tiene que ocurrir fuera de smp.stepporque es cuando se hace todo el paso hacia atrás y los gradientes están listos. Cuando se utiliza un modelo híbrido con paralelismo de modelos y datos, en este punto también se garantiza que los gradientes finalizarán. AllReduce

Cuando utilice la biblioteca en combinación con el paralelismo de datos, asegúrese de que el número de lotes en todos los rangos paralelos de datos sea el mismo para que AllReduce no se quede esperando a que un rango no participe en el paso.

Si lanza un trabajo de entrenamiento utilizando un tipo de instancia ml.p4d (como ml.p4d.24xlarge), debe establecer la variable del cargador de datos num_workers=0. Por ejemplo, puede definir su DataLoader de la siguiente manera:

dataloader = torch.utils.data.DataLoader(
            data,
            batch_size=batch_size,
            num_workers=0,
            pin_memory=True,
            drop_last=True,
            shuffle=shuffle,
        )

Las entradas para smp.step deben ser las entradas de modelo generadas por DataLoader. Esto se debe a que smp.step divide internamente los tensores de entrada a lo largo de la dimensión del lote y los canaliza. Esto significa que pasar DataLoader a la smp.step para generar las entradas del modelo en el interior no funciona.

Por ejemplo, si define un DataLoader de la siguiente manera:

train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)

Debe acceder a las entradas del modelo generadas por train_loader y pasarlos a una función decorada por smp.step. No pase train_loader directamente a la función smp.step.

def train(model, device, train_loader, optimizer):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        ...
        _, loss_mb = train_step(model, data, target)
        ...

@smp.step
def train_step(model, data, target):
    ...
    return output, loss

Los tensores de entrada a smp.step debe, moverse al dispositivo actual mediante la API .to(), que debe tener lugar después de la llamada torch.cuda.set_device(local_rank()).

Por ejemplo, puede utilizar la función train de la siguiente manera. Esta función añade data y target al dispositivo actual utilizando la API .to() antes de usar esos tensores de entrada para llamar train_step.

def train(model, device, train_loader, optimizer):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        # smdistributed: Move input tensors to the GPU ID used by the current process,
        # based on the set_device call.
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        # Return value, loss_mb is a StepOutput object
        _, loss_mb = train_step(model, data, target)

        # smdistributed: Average the loss across microbatches.
        loss = loss_mb.reduce_mean()

        optimizer.step()

Los tensores de entrada para esta función decorado por smp.set se ha movido al dispositivo actual en la función train anterior. El modelo no debe moverse al dispositivo actual. La biblioteca mueve automáticamente la parte del modelo asignada a un rango a su GPU.

@smp.step
def train_step(model, data, target):
    output = model(data)
    loss = F.nll_loss(output, target, reduction="mean")
    model.backward(loss)
    return output, loss

Si utiliza el paralelismo de datos con el PyTorch DDP nativo, la biblioteca no admite el módulo torch.nn.parallel.DistributedDataParallelcontenedor. La biblioteca gestiona internamente la integración con el PyTorch DDP, incluida la transmisión de parámetros y el gradiente. AllReduce Cuando se utiliza la biblioteca, los búferes de módulo solo se transmiten una vez al comienzo del entrenamiento. Si el modelo tiene búferes de módulo que deben sincronizarse entre los grupos paralelos de datos en cada paso, puede hacerlo a través de la API torch.distributed, utilizando el grupo de procesos que se puede obtener mediante smp.get_dp_process_group().

Para un entrenamiento de precisión mixta, el módulo apex.amp no es compatible. La forma recomendada de utilizar la biblioteca con precisión mixta automática es utilizar torch.cuda.amp, con la excepción de utilizar smp.amp.GradScaler en lugar de la aplicación en antorcha.

torch.jit.ScriptModules o ScriptFunctions no son compatibles con smp.DistributedModel.

apex : FusedLayerNorm, FusedAdam, FusedLAMB y FusedNovoGrad de apex no son compatibles. Puede utilizar las implementaciones de la biblioteca de principio a fin smp.optimizers y smp.nn APIs en su lugar.