Entrenamiento Multi-GPU con YOLOv5
Esta guía explica cómo utilizar correctamente múltiples GPU para entrenar un conjunto de datos con YOLOv5 🚀 en una o varias máquinas.
Antes de empezar
Clona el repositorio e instala requirements.txt en un entorno Python>=3.8.0, incluyendo PyTorch>=1.8. Los modelos y los conjuntos de datos se descargan automáticamente desde la última versión de YOLOv5.
git clone https://github.com/ultralytics/yolov5 # clone
cd yolov5
pip install -r requirements.txt # install
¡ProTip!
Imagen Docker se recomienda para todos los entrenamientos Multi-GPU. Ver Guía de inicio rápido de Docker
¡ProTip!
torch.distributed.run
reemplaza torch.distributed.launch
en PyTorch>=1.9. Consulte Documentación distribuida de PyTorch para obtener más detalles.
Entrenamiento
Seleccione un modelo preentrenado para comenzar el entrenamiento. Aquí seleccionamos YOLOv5s, el modelo más pequeño y rápido disponible. Consulte nuestra tabla README para obtener una comparación completa de todos los modelos. Entrenaremos este modelo con Multi-GPU en el conjunto de datos COCO.
GPU única
python train.py --batch 64 --data coco.yaml --weights yolov5s.pt --device 0
Modo DataParallel Multi-GPU (⚠️ no recomendado)
Puede aumentar el device
para usar múltiples GPU en modo DataParallel.
python train.py --batch 64 --data coco.yaml --weights yolov5s.pt --device 0,1
Este método es lento y apenas acelera el entrenamiento en comparación con el uso de solo 1 GPU.
Modo DistributedDataParallel Multi-GPU (✅ recomendado)
Tendrá que pasar python -m torch.distributed.run --nproc_per_node
, seguido de los argumentos habituales.
python -m torch.distributed.run --nproc_per_node 2 train.py --batch 64 --data coco.yaml --weights yolov5s.pt --device 0,1
--nproc_per_node
especifica cuántas GPUs le gustaría usar. En el ejemplo anterior, es 2.--batch
es el tamaño total del lote. Se dividirá uniformemente en cada GPU. En el ejemplo anterior, es 64/2=32 por GPU.
El código anterior utilizará GPUs 0... (N-1)
.
Utiliza GPUs específicas (haz clic para expandir)
Puede hacerlo simplemente pasando `--device` seguido de sus GPU específicas. Por ejemplo, en el código siguiente, utilizaremos las GPU `2,3`.python -m torch.distributed.run --nproc_per_node 2 train.py --batch 64 --data coco.yaml --cfg yolov5s.yaml --weights '' --device 2,3
Utiliza SyncBatchNorm (haz clic para expandir)
[SyncBatchNorm](https://docs.pytorch.org/docs/master/generated/torch.nn.SyncBatchNorm.html) could increase [accuracy](https://www.ultralytics.com/glossary/accuracy) for multiple GPU training, however, it will slow down training by a significant factor. It is **only** available for Multiple GPU DistributedDataParallel training. It is best used when the batch-size on **each** GPU is small (<= 8). To use SyncBatchNorm, simply pass `--sync-bn` to the command like below:python -m torch.distributed.run --nproc_per_node 2 train.py --batch 64 --data coco.yaml --cfg yolov5s.yaml --weights '' --sync-bn
Utiliza varias máquinas (haz clic para expandir)
Esto **solo** está disponible para el entrenamiento DistributedDataParallel con múltiples GPU. Antes de continuar, asegúrese de que los archivos en todas las máquinas sean los mismos, el conjunto de datos, la base de código, etc. Después, asegúrese de que las máquinas puedan comunicarse entre sí. Tendrá que elegir una máquina maestra (la máquina con la que hablarán las demás). Anote su dirección (`master_addr`) y elija un puerto (`master_port`). Utilizaré `master_addr = 192.168.1.1` y `master_port = 1234` para el siguiente ejemplo. Para usarlo, puede hacer lo siguiente:# On master machine 0
python -m torch.distributed.run --nproc_per_node G --nnodes N --node_rank 0 --master_addr "192.168.1.1" --master_port 1234 train.py --batch 64 --data coco.yaml --cfg yolov5s.yaml --weights ''
# On machine R
python -m torch.distributed.run --nproc_per_node G --nnodes N --node_rank R --master_addr "192.168.1.1" --master_port 1234 train.py --batch 64 --data coco.yaml --cfg yolov5s.yaml --weights ''
Notas
- La compatibilidad con Windows no está probada, se recomienda Linux.
--batch
debe ser un múltiplo del número de GPUs.- La GPU 0 consumirá ligeramente más memoria que las otras GPU, ya que mantiene EMA y es responsable de la creación de puntos de control, etc.
-
Si obtiene
RuntimeError: Address already in use
, podría deberse a que está ejecutando varios entrenamientos a la vez. Para solucionar esto, simplemente use un número de puerto diferente agregando--master_port
como se muestra a continuación:python -m torch.distributed.run --master_port 1234 --nproc_per_node 2 ...
Resultados
Resultados de la creación de perfiles DDP en una instancia AWS EC2 P4d con 8x A100 SXM4-40GB para YOLOv5l para 1 época COCO.
Perfilado de código
# prepare
t=ultralytics/yolov5:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus all -v "$(pwd)"/coco:/usr/src/coco $t
pip3 install torch==1.9.0+cu111 torchvision==0.10.0+cu111 -f https://download.pytorch.org/whl/torch_stable.html
cd .. && rm -rf app && git clone https://github.com/ultralytics/yolov5 -b master app && cd app
cp data/coco.yaml data/coco_profile.yaml
# profile
python train.py --batch-size 16 --data coco_profile.yaml --weights yolov5l.pt --epochs 1 --device 0
python -m torch.distributed.run --nproc_per_node 2 train.py --batch-size 32 --data coco_profile.yaml --weights yolov5l.pt --epochs 1 --device 0,1
python -m torch.distributed.run --nproc_per_node 4 train.py --batch-size 64 --data coco_profile.yaml --weights yolov5l.pt --epochs 1 --device 0,1,2,3
python -m torch.distributed.run --nproc_per_node 8 train.py --batch-size 128 --data coco_profile.yaml --weights yolov5l.pt --epochs 1 --device 0,1,2,3,4,5,6,7
GPUs A100 |
tamaño-del-lote | CUDA_mem device0 (G) |
COCO train |
COCO val |
---|---|---|---|---|
1x | 16 | 26 GB | 20:39 | 0:55 |
2x | 32 | 26 GB | 11:43 | 0:57 |
4x | 64 | 26 GB | 5:57 | 0:55 |
8x | 128 | 26 GB | 3:09 | 0:57 |
Como se muestra en los resultados, el uso de DistributedDataParallel con múltiples GPU proporciona un escalado casi lineal en la velocidad de entrenamiento. Con 8 GPU, el entrenamiento se completa aproximadamente 6.5 veces más rápido que con una sola GPU, manteniendo el mismo uso de memoria por dispositivo.
Preguntas frecuentes
Si se produce un error, ¡lea primero la siguiente lista de verificación! (Podría ahorrarle tiempo)
Lista de verificación (haga clic para expandir)
- ¿Ha leído correctamente esta publicación? - ¿Ha intentado volver a clonar la base de código? El código cambia **diariamente**. - ¿Ha intentado buscar su error? Es posible que alguien ya lo haya encontrado en este repositorio o en otro y tenga la solución. - ¿Ha instalado todos los requisitos que se enumeran en la parte superior (incluidas las versiones correctas de Python y PyTorch)? - ¿Lo ha intentado en otros entornos enumerados en la sección "Entornos" a continuación? - ¿Ha probado con otro conjunto de datos como coco128 o coco2017? Facilitará la búsqueda de la causa raíz. Si ha revisado todo lo anterior, no dude en plantear un problema proporcionando la mayor cantidad de detalles posible siguiendo la plantilla.Entornos Compatibles
Ultralytics proporciona una gama de entornos listos para usar, cada uno preinstalado con dependencias esenciales como CUDA, CUDNN, Python y PyTorch, para poner en marcha sus proyectos.
- Notebooks GPU gratuitos:
- Google Cloud: Guía de inicio rápido de GCP
- Amazon: Guía de inicio rápido de AWS
- Azure: Guía de inicio rápido de AzureML
- Docker: Guía de inicio rápido de Docker
Estado del Proyecto
Esta insignia indica que todas las pruebas de Integración Continua (CI) de YOLOv5 GitHub Actions están pasando exitosamente. Estas pruebas de CI verifican rigurosamente la funcionalidad y el rendimiento de YOLOv5 en varios aspectos clave: entrenamiento, validación, inferencia, exportación y benchmarks. Aseguran un funcionamiento consistente y confiable en macOS, Windows y Ubuntu, con pruebas realizadas cada 24 horas y con cada nuevo commit.
Créditos
Nos gustaría agradecer a @MagicFrogSJTU, quien hizo todo el trabajo pesado, y a @glenn-jocher por guiarnos en el camino.
Ver También
- Modo de entrenamiento: aprenda a entrenar modelos YOLO con Ultralytics
- Ajuste de hiperparámetros - Optimiza el rendimiento de tu modelo
- Guía de inicio rápido de Docker - Configure su entorno Docker para el entrenamiento