Guia rápido do Modal para Ultralytics

Este guia oferece uma introdução abrangente à execução Ultralytics no Modal, abordando GPU sem servidor e o treino de modelos.

O Modal é uma plataforma de computação em nuvem sem servidor destinada a cargas de trabalho de IA e aprendizagem automática. Trata automaticamente do aprovisionamento, do dimensionamento e da execução — basta escrever Python localmente e o Modal executa-o na nuvem com GPU . Isto torna-o ideal para executar modelos de aprendizagem profunda, como o YOLO26, sem necessidade de gerir a infraestrutura.

O Que Você Irá Aprender

Configurar o Modal e efetuar a autenticação
Executar a inferência do YOLO26 no Modal
Utilização de GPUs para uma inferência mais rápida
Treinar modelos YOLO26 no Modal

Pré-requisitos

Uma conta Modal (registe-se gratuitamente em modal.com)
Python .9 ou posterior instalado no seu computador

Instalação

Instale o Python Modal Python e efetue a autenticação:

pip install modal

modal token new

Autenticação

O modal token new O comando irá abrir uma janela do navegador para autenticar a sua conta Modal. Após a autenticação, poderá executar comandos Modal a partir do terminal.

Executar a inferência do YOLO26

Crie um novo Python chamado modal_yolo.py com o seguinte código:

"""
Modal + Ultralytics YOLO26 Quickstart
Run: modal run modal_yolo.py.
"""

import modal

app = modal.App("ultralytics-yolo")

image = modal.Image.debian_slim(python_version="3.11").apt_install("libgl1", "libglib2.0-0").pip_install("ultralytics")


@app.function(image=image)
def predict(image_url: str):
    """Run YOLO26 inference on an image URL."""
    from ultralytics import YOLO

    model = YOLO("yolo26n.pt")
    results = model(image_url)

    for r in results:
        print(f"Detected {len(r.boxes)} objects:")
        for box in r.boxes:
            print(f"  - {model.names[int(box.cls)]}: {float(box.conf):.2f}")


@app.local_entrypoint()
def main():
    """Test inference with sample image."""
    predict.remote("https://ultralytics.com/images/bus.jpg")

Execute a inferência:

modal run modal_yolo.py

Resultado esperado:

✓ Initialized. View run at https://modal.com/apps/your-username/main/ap-xxxxxxxx
✓ Created objects.
├── 🔨 Created mount modal_yolo.py
└── 🔨 Created function predict.
Downloading https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt to 'yolo26n.pt'...
Downloading https://ultralytics.com/images/bus.jpg to 'bus.jpg'...
image 1/1 /root/bus.jpg: 640x480 4 persons, 1 bus, 377.8ms
Speed: 5.8ms preprocess, 377.8ms inference, 0.3ms postprocess per image at shape (1, 3, 640, 480)

Detected 5 objects:
  - bus: 0.92
  - person: 0.91
  - person: 0.91
  - person: 0.87
  - person: 0.53
✓ App completed.

Pode monitorizar a execução da sua função no painel do Modal:

Chamadas de função do painel modal

Utilização GPU uma inferência mais rápida

Adicione uma GPU sua função especificando o gpu parâmetro:

@app.function(image=image, gpu="T4")  # Options: "T4", "A10G", "A100", "H100"
def predict_gpu(image_url: str):
    """Run YOLO26 inference on GPU."""
    from ultralytics import YOLO

    model = YOLO("yolo26n.pt")
    results = model(image_url)
    print(results[0].boxes)

GPU	Memória	Ideal Para
T4	16 GB	Inferência, treino de modelos pequenos
A10G	24 GB	Cursos de formação de nível médio
A100	40 GB	Formação em grande escala
H100	80 GB	Desempenho máximo

Para o treino, utilize uma GPU o Modal Volumes para armazenamento persistente. Crie um novo Python chamado train_yolo.py:

import modal

app = modal.App("ultralytics-training")

volume = modal.Volume.from_name("yolo-training-vol", create_if_missing=True)

image = modal.Image.debian_slim(python_version="3.11").apt_install("libgl1", "libglib2.0-0").pip_install("ultralytics")


@app.function(image=image, gpu="T4", timeout=3600, volumes={"/data": volume})
def train():
    """Train YOLO26 model on Modal."""
    from ultralytics import YOLO

    model = YOLO("yolo26n.pt")
    model.train(data="coco8.yaml", epochs=3, imgsz=640, project="/data/runs")


@app.local_entrypoint()
def main():
    train.remote()

Treino de corrida:

modal run train_yolo.py

Persistência do volume

Os volumes modais mantêm os dados entre execuções da função. Os pesos treinados são guardados em /data/runs/detect/train/weights/.

Parabéns! Configurou com sucesso Ultralytics no Modal. Para saber mais:

Explore a documentaçãoUltralytics para conhecer as funcionalidades avançadas
Saiba como treinar modelos personalizados com os seus próprios conjuntos de dados
Consulte a documentação do Modal para conhecer as funcionalidades avançadas da plataforma

FAQ

Como escolho a GPU adequada GPU a minha carga de trabalho YOLO26?

Para inferência, uma NVIDIA (16 GB) é normalmente suficiente e económica. Para treino ou modelos de maior dimensão, como o YOLO26x, considere as GPUs A10G ou A100.

O Modal utiliza um modelo de preços de pagamento por segundo. Preços aproximados: CPU 0,05 $/hora, T4 ~0,59 $/hora, A10G ~1,10 $/hora, A100 ~2,10 $/hora. Consulte os preços do Modal para conhecer as tarifas atuais.

Posso utilizar YOLO meu próprio YOLO treinado à medida?

Sim! Carregar modelos personalizados a partir de um Modal Volume:

model = YOLO("/data/my_custom_model.pt")

Para mais informações sobre o treino de modelos personalizados, consulte o guia de treino.

📅 Criado há 0 dias ✏️ Atualizado há 0 dias

Guia rápido do Modal para Ultralytics

O que é o Modal?