# Processo de execução

Ao trabalhar com sistemas de treinamento distribuído, é importante gerenciar como e quando os processos são executados entre as GPUs. Alguns processos são concluídos mais rapidamente do que outros, e alguns processos não devem começar se outros ainda não tiverem terminado. O Accelerate fornece ferramentas para orquestrar quando os processos são executados, garantindo que tudo permaneça sincronizado entre todos os dispositivos.

Este tutorial ensinará a executar um processo em apenas uma máquina e como adiar a execução até que todos os processos tenham atingido um determinado ponto.

## Executar em um processo

Certos trechos de código precisam ser executados apenas uma vez em uma máquina específica, como exibir uma mensagem de log ou mostrar apenas uma barra de progresso no processo principal local.

Você deve usar `accelerator.is_local_main_process` para indicar código que deve ser executado apenas uma vez.

```py
from tqdm.auto import tqdm

progress_bar = tqdm(range(args.max_train_steps), disable=not accelerator.is_local_main_process)
```

Você também pode envolver uma declaração com `accelerator.is_local_main_process`.

> [!TIP]
> Para declarações `print` isoladas que não estão envolvidas em `accelerator.is_local_main_process`, substitua `print` pelo método [print()](/docs/accelerate/v1.16.0/pt/package_reference/accelerator#accelerate.Accelerator.print) do Accelerate para imprimir apenas uma vez por processo.

```py
if accelerator.is_local_main_process:
    print("Accelerate is the best")
```

Para uma função que deve ser executada apenas uma vez, use [on_local_main_process()](/docs/accelerate/v1.16.0/pt/package_reference/accelerator#accelerate.Accelerator.on_local_main_process).

```py
@accelerator.on_local_main_process
def do_my_thing():
    "Something done once per server"
    do_thing_once_per_server()
```

Você também pode instruir o Accelerate a executar o código uma única vez em *todos os processos*, independentemente do número de máquinas. Isso é útil se você estiver fazendo o upload de um modelo final para o Hub.

Você deve usar `accelerator.is_main_process` para indicar código que deve ser executado apenas uma vez em todos os processos.

```py
if accelerator.is_main_process:
    repo.push_to_hub()
```

Para uma função que deve ser executada apenas uma vez em todos os processos, use [on_main_process()](/docs/accelerate/v1.16.0/pt/package_reference/accelerator#accelerate.Accelerator.on_main_process).

```py
@accelerator.on_main_process
def do_my_thing():
    "Something done once per server"
    do_thing_once()
```

## Executar em um processo específico

O Accelerate também pode ajudar você a executar funções que devem ser executadas apenas em um processo específico ou em um índice de processo local.

Use o método [on_process()](/docs/accelerate/v1.16.0/pt/package_reference/accelerator#accelerate.Accelerator.on_process) e especifique o índice do processo em que a função deve ser executada.

```py
@accelerator.on_process(process_index=0)
def do_my_thing():
    "Something done on process index 0"
    do_thing_on_index_zero()
```

Use o método [on_local_process()](/docs/accelerate/v1.16.0/pt/package_reference/accelerator#accelerate.Accelerator.on_local_process) e especifique o índice do processo local em que a função deve ser executada.

```py
@accelerator.on_local_process(local_process_idx=0)
def do_my_thing():
    "Something done on process index 0 on each server"
    do_thing_on_index_zero_on_each_server()
```

## Adiar a execução

Quando você executa seu script em várias GPUs ao mesmo tempo, algumas partes do código podem ser executadas mais rápido do que outras. Você pode precisar esperar que todos os processos alcancem um determinado ponto antes de executar o próximo conjunto de instruções. Por exemplo, você não deve salvar um modelo antes de garantir que todos os processos tenham concluído o treinamento.

Para fazer isso, adicione [wait_for_everyone()](/docs/accelerate/v1.16.0/pt/package_reference/accelerator#accelerate.Accelerator.wait_for_everyone) no seu código. Isso impede que todos os processos que terminaram primeiro continuem até que todos os processos restantes tenham alcançado o mesmo ponto (isso não tem efeito se você estiver executando em uma única GPU ou CPU).

```py
accelerator.wait_for_everyone()
```

