Começar

Exportação de modelos YOLO26 para TorchScript para implantação rápida

PyTorch está descontinuando o TorchScript

O PyTorch tornou o TorchScript obsoleto e está removendo gradualmente seus recursos. Para novas implantações móveis e de borda, use a integração ExecuTorch, que tem suporte ativo. A Ultralytics mantém a exportação regular para TorchScript para garantir compatibilidade com código C++ legado.

A implantação de modelos de visão computacional em ambientes C++ sem Python exige uma representação serializada portátil. O TorchScript oferece essa compatibilidade para aplicações legadas do LibTorch.

Exporte para TorchScript para serializar seus modelos Ultralytics YOLO26 e obter compatibilidade entre plataformas e implantação simplificada. Este guia mostra como exportar seus modelos YOLO26 para o formato TorchScript para que você possa usá-los em uma variedade maior de aplicações.

Por que exportar para TorchScript?#

Visão geral do fluxo de serialização e implantação de modelos TorchScript

Desenvolvido pelos criadores do PyTorch, o TorchScript é uma ferramenta para otimizar e implantar modelos PyTorch em várias plataformas. Exportar modelos YOLO26 para TorchScript ajuda a levá-los da pesquisa para aplicações do mundo real. O TorchScript, parte da estrutura PyTorch, facilita essa transição ao permitir o uso de modelos PyTorch em ambientes que não oferecem suporte a Python.

O processo envolve duas técnicas: rastreamento e criação de scripts. O rastreamento registra as operações durante a execução do modelo, enquanto a criação de scripts permite definir modelos usando um subconjunto de Python. Essas técnicas permitem que modelos como YOLO26 sejam executados fora do ambiente Python habitual.

Comparação entre criação de scripts e rastreamento no TorchScript

Os modelos TorchScript também podem ser otimizados com técnicas como fusão de operadores e melhorias no uso da memória, garantindo uma execução eficiente. Outra vantagem de exportar para TorchScript é o potencial de acelerar a execução do modelo em diversas plataformas de hardware. O TorchScript cria uma representação autônoma, pronta para produção, do seu modelo PyTorch, que pode ser integrada a ambientes C++.

Principais recursos dos modelos TorchScript#

O TorchScript, uma parte essencial do ecossistema PyTorch, oferece recursos para otimizar e implantar modelos de aprendizado profundo.

Visão geral dos principais recursos do TorchScript

Veja os principais recursos que fazem do TorchScript uma ferramenta valiosa para desenvolvedores:

  • Execução com grafo estático: o TorchScript usa uma representação em grafo estático dos cálculos do modelo, diferente da execução com grafo dinâmico do PyTorch. Na execução com grafo estático, o grafo computacional é definido e compilado uma vez antes da execução propriamente dita, o que melhora o desempenho durante a inferência.

  • Serialização de modelos: o TorchScript permite serializar modelos PyTorch em um formato independente de plataforma. Os modelos serializados podem ser carregados sem o código Python original, permitindo a implantação em diferentes ambientes de execução.

  • Compilação JIT: o TorchScript usa compilação Just-In-Time (JIT) para converter modelos PyTorch em uma representação intermediária otimizada. O JIT compila o grafo computacional do modelo, permitindo uma execução eficiente nos dispositivos de destino.

  • Conversão gradual: o TorchScript oferece uma abordagem de conversão gradual, permitindo converter partes do modelo PyTorch para TorchScript de forma incremental. Essa flexibilidade é especialmente útil ao lidar com modelos complexos ou ao otimizar partes específicas do código.

Opções de implantação no TorchScript#

Antes de ver o código para exportar modelos YOLO26 para o formato TorchScript, confira onde os modelos TorchScript são normalmente usados.

O TorchScript oferece várias opções para implantar modelos de machine learning, como:

  • API C++: o caso de uso mais comum do TorchScript é sua API LibTorch para C++, que permite carregar e executar modelos TorchScript otimizados diretamente em aplicações C++. Essa opção é ideal para ambientes de produção nos quais Python pode não ser adequado ou estar disponível. A API C++ proporciona execução eficiente de modelos TorchScript com baixa sobrecarga, maximizando o potencial de desempenho.

  • Implantação móvel: para inferência de baixa latência e offline, além de privacidade dos dados em dispositivos móveis, use o ExecuTorch, que substitui o TorchScript Mobile no PyTorch.

  • Implantação na nuvem: os modelos TorchScript podem ser implantados em servidores na nuvem com soluções como o NVIDIA Triton Inference Server. Essa solução oferece funcionalidades como controle de versões de modelos, processamento em lotes e monitoramento de métricas para uma implantação escalável em ambientes de produção. A implantação na nuvem com TorchScript pode disponibilizar os teus modelos por meio de APIs ou outros serviços Web.

Tarefas suportadas#

A exportação para TorchScript é compatível com todas as sete tarefas da Ultralytics. A segmentação semântica e a estimativa de profundidade estão disponíveis apenas com YOLO26, a única família que inclui essas cabeças.

TarefaYOLOv8YOLO11YOLO26
Detetar✅✅✅
Segmentar✅✅✅
Semântica❌❌✅
Profundidade❌❌✅
Classificar✅✅✅
Pose✅✅✅
OBB✅✅✅

Exportar para TorchScript: convertendo seu modelo YOLO26#

Exportar modelos YOLO26 para TorchScript facilita sua execução fora do Python, por exemplo, em aplicações C++ criadas com LibTorch.

Instalação#

Para instalar o pacote necessário, executa:

Instalação
# Install the required package for YOLO26
pip install ultralytics

Para obter instruções detalhadas e boas práticas relacionadas ao processo de instalação, consulte nosso guia de instalação da Ultralytics. Se tiver dificuldades ao instalar os pacotes necessários para YOLO26, consulte nosso guia de problemas comuns para ver soluções e dicas.

Uso#

Todos os modelos Ultralytics YOLO26 foram concebidos para suportar a exportação de origem, o que facilita a integração no fluxo de trabalho de implementação que preferires. Podes consultar a lista completa de formatos de exportação suportados e opções de configuração para escolheres a melhor configuração para a tua aplicação.

O formato TorchScript é compatível com os modos Export, Predict e Validate. Exporte o modelo e, em seguida, carregue o modelo exportado para executar inferências ou validar a precisão.

Exportar
from ultralytics import YOLO

# Carrega um modelo YOLO26
model = YOLO("yolo26n.pt")

# Exporte o modelo para o formato TorchScript
model.export(format="torchscript")  # cria 'yolo26n.torchscript'
Prever
from ultralytics import YOLO

# Carregue o modelo TorchScript exportado
model = YOLO("yolo26n.torchscript")

# Executar inferência
results = model("https://ultralytics.com/images/bus.jpg")
Validar
from ultralytics import YOLO

# Carregue o modelo TorchScript exportado
model = YOLO("yolo26n.torchscript")

# Validar a precisão no conjunto de dados COCO8
metrics = model.val(data="coco8.yaml")

Argumentos de exportação#

ArgumentoTipoPadrãoDescrição
formatstr'torchscript'Formato de destino do modelo exportado, que define a compatibilidade com vários ambientes de implantação.
imgszint ou tuple640Tamanho de imagem desejado para a entrada do modelo. Pode ser um inteiro para imagens quadradas ou uma tupla (height, width) para dimensões específicas.
dynamicboolFalsePermite tamanhos de entrada dinâmicos, aumentando a flexibilidade para processar imagens com dimensões variáveis.
quantizeint ou strNonePrecisão da quantização: 16 (FP16) exige exportação com GPU e device=0; 32/não definido corresponde a FP32. Substitui a flag obsoleta half.
nmsbool, opcionalNoneSeleciona a saída bruta (None, padrão), NMS incorporado (True) ou a cabeça sem NMS (False).
batchint1Especifica o tamanho do lote de inferência do modelo exportado ou o número máximo de imagens que o modelo exportado processará em simultâneo no modo predict.
devicestrNoneEspecifica o dispositivo para exportação: GPU (device=0), CPU (device=cpu), MPS para Apple Silicon (device=mps).

Para mais detalhes sobre o processo de exportação, visita a página da documentação da Ultralytics sobre exportação.

Implantar modelos YOLO26 TorchScript exportados#

Depois de exportar com sucesso os modelos Ultralytics YOLO26 para o formato TorchScript, você já pode implantá-los. A primeira etapa recomendada para executar um modelo TorchScript é usar o método YOLO("model.torchscript"), conforme mostrado no trecho de código de uso anterior. Para ver instruções detalhadas sobre como implantar seus modelos TorchScript em outros contextos, consulte os seguintes recursos:

  • Explore a implantação móvel: use o pipeline separado torch.export() → .pte do ExecuTorch para as implantações móveis atuais do PyTorch.

  • Domina a implantação no lado do servidor: aprende a disponibilizar modelos TorchScript com o backend PyTorch do NVIDIA Triton Inference Server para oferecer modelos de forma escalável e eficiente.

  • Implemente a implantação em C++: consulte o tutorial sobre como carregar um modelo TorchScript em C++, que facilita a integração dos seus modelos TorchScript em aplicações C++ para obter mais desempenho e versatilidade.

Resumo#

Este guia abordou a exportação de modelos Ultralytics YOLO26 para o formato TorchScript. Seguindo as instruções fornecidas, você pode otimizar o desempenho dos modelos YOLO26 e ganhar flexibilidade para implantá-los em várias plataformas e ambientes.

Para mais detalhes sobre o uso, acesse a documentação oficial do TorchScript.

Perguntas frequentes#

  • Exportar um modelo Ultralytics YOLO26 para TorchScript permite uma implantação flexível e multiplataforma. O TorchScript, parte do ecossistema PyTorch, facilita a serialização de modelos, que podem ser executados em ambientes sem suporte a Python. Isso torna o TorchScript útil para implantar modelos em ambientes C++.

  • Para exportar um modelo YOLO26 para TorchScript, você pode usar o seguinte código de exemplo:

    Uso
    from ultralytics import YOLO
    
    # Carrega um modelo YOLO26
    model = YOLO("yolo26n.pt")
    
    # Exporte o modelo para o formato TorchScript
    model.export(format="torchscript")  # cria 'yolo26n.torchscript'
    
    # Carregue o modelo TorchScript exportado
    torchscript_model = YOLO("yolo26n.torchscript")
    
    # Executar inferência
    results = torchscript_model("https://ultralytics.com/images/bus.jpg")

    Para mais detalhes sobre o processo de exportação, consulte a documentação da Ultralytics sobre exportação.

  • Usar TorchScript para implantar modelos YOLO26 oferece várias vantagens:

    • Portabilidade: os modelos exportados podem ser executados em aplicações C++ sem Python.
    • Otimização: o TorchScript é compatível com execução com grafo estático e compilação Just-In-Time (JIT), que podem otimizar o desempenho dos modelos.
    • Integração entre linguagens: os modelos TorchScript podem ser integrados a outras linguagens de programação, ampliando a flexibilidade e a capacidade de expansão.
    • Serialização: os modelos podem ser serializados, permitindo carregamento e inferência independentes de plataforma.

    Para saber mais sobre implantação, consulta o Guia de implantação em C++. Para a implantação em dispositivos móveis, o PyTorch agora recomenda o ExecuTorch, que utiliza o seu próprio pipeline separado torch.export() → .pte, em vez do TorchScript.

  • Para instalar o pacote necessário para exportar modelos YOLO26, usa o seguinte comando:

    Instalação
    # Install the required package for YOLO26
    pip install ultralytics

    Para obter instruções detalhadas, visita o guia de instalação da Ultralytics. Se surgir algum problema durante a instalação, consulta o guia de problemas comuns.

  • Depois de exportares os modelos YOLO26 para o formato TorchScript, podes implementá-los em várias plataformas:

    • API C++: usa o LibTorch para ambientes de produção altamente eficientes e com baixa sobrecarga.
    • Implementação móvel: usa o ExecuTorch, a substituição compatível com PyTorch, com um pipeline de exportação separado .pte.
    • Implantação na nuvem: utiliza serviços como o NVIDIA Triton Inference Server para uma implantação escalável no lado do servidor.

Comentários9

Faz uma pergunta, partilha os teus resultados ou ajuda alguém.

  1. amarnathreddy0201GitHub

    Load the YOLOv8 model

    model = YOLO("yolov8n.pt")

    Export the model to TorchScript format

    model.export(format="torchscript") # creates 'yolov8n.torchscript'

    Load the exported TorchScript model

    torchscript_model = YOLO("yolov8n.torchscript")

    For loading "yolov8n.torchscript" here yolo is used. is it possible to load the model using pytorch and prediction/Segmentation.

    1. Paula DerrengerUltralytics

      @amarnathreddy0201 yes, you can load and use the exported TorchScript model directly with PyTorch. After exporting your YOLOv8 model to TorchScript format, you can load it using torch.jit.load('yolov8n.torchscript') and then perform inference as usual with PyTorch. For detailed instructions, you can refer to the TorchScript documentation.

    2. amarnathreddy0201GitHub(editado)

      @pderrenger I written small application for person detection but it's not detecting properly nd bounding boxes is some where else.

      import torch import cv2 import numpy as np

      classes = [ "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light", "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch", "potted plant", "bed", "dining table", "toilet", "tv", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush" ]

      model = torch.jit.load("yolov8n.torchscript") image_ori = cv2.imread(r"C:\Users\amarn\OneDrive\Pictures\father mother.jpg") image = cv2.resize(image_ori, (640, 640)) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) image_tensor = torch.from_numpy(image).float() image_tensor = image_tensor.permute(2, 0, 1) # Change from HWC to CHW format image_tensor = image_tensor / 255.0 # Normalize to [0, 1] image_tensor = image_tensor.unsqueeze(0)

      with torch.no_grad(): results = model(image_tensor)

      results = results[0] # Remove the batch dimension if there's only one image

      boxes = results[:, :4]
      print(len(boxes)) object_confidences = results[:, 4] # Objectness score class_confidences = results[:, 5:] # Class scores

      conf_threshold = 0.5 # Example threshold; adjust as necessary predictions = [] for i in range(len(object_confidences)): if object_confidences[i] > conf_threshold: class_id = torch.argmax(class_confidences[i]).item() class_conf = class_confidences[i][class_id].item()

          if class_conf > conf_threshold:
              
              box_np = boxes[i].cpu().numpy() if boxes[i].is_cuda else boxes[i].numpy()
              x, y, w, h = box_np
              x1 = int((x - w / 2) )
              y1 = int((y - h / 2) )
              x2 = int((x + w / 2) )
              y2 = int((y + h / 2))
              cv2.rectangle(image_ori, (int(x1),int( y1)), (int(x1+ w), int(y1 + h)), (0, 255, 0), 2)

      cv2.imshow('image', image_ori) cv2.waitKey(0)

      classes is from yolo only

      1
    3. Paula DerrengerUltralytics

      It looks like there might be an issue with the bounding box coordinates. Ensure that the coordinates are correctly transformed from the model's output format to the image's coordinate system. Also, verify that the model is correctly loaded and that the input image is preprocessed as expected. If the issue persists, please try updating to the latest version of the Ultralytics package and check if the problem is reproducible. For more details on exporting and using TorchScript models, you can refer to the Ultralytics documentation.

    4. clausMekoGitHub(editado)

      @amarnathreddy0201 I could make the boxes work for my One-Item only use case. I guess the tensor structure was not really clear to you as it seemed to me you have profound knowledge. ty for heavy lifting :partying_face:

      @glenn-jocher and @pderrenger if you care what use case I had and could not simply from ultralytics import YOLO: I chain YOLO with other models and have conflicts with imports, especially numpy v1 vs v2. So i figured export all as torchscript and chain them.

      import torch
      import cv2
      
      # Knwoledge: https://github.com/ultralytics/ultralytics/issues/5863
      # Knwoledge: https://github.com/orgs/ultralytics/discussions/9002
      def preprocess_image(image_ori) -> torch.Tensor:
          image = cv2.resize(image_ori, (640, 640))
          image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
          image_tensor = torch.from_numpy(image).float()
          image_tensor = image_tensor.permute(2, 0, 1)  # Change from HWC to CHW format
          image_tensor = image_tensor / 255.0  # Normalize to [0, 1]
          image_tensor = image_tensor.unsqueeze(0)
      
          return image_tensor
      
      def main():
          # Load the TorchScript model
          map_location = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
          model = torch.jit.load('./best.torchscript', map_location=map_location)
      
          cv2_img = cv2.imread("../obj-det/datasets/test/images/00018_png.rf.d602082fdf686063a7d430aba6dfedde.jpg")
          image = preprocess_image(cv2_img)
      
          with torch.no_grad():
              results: torch.Tensor = model(image.to(map_location))
      
          results = results[0]  # Remove the batch dimension if there's only one image
          boxes = results[:4, :]
          object_confidences = results[4, :]
          conf_threshold = 0.5  # Example threshold; adjust as necessary
      
          dominant_item = torch.argmax(object_confidences)
          if object_confidences[dominant_item] < conf_threshold:
              cv2.imshow('nothing found', cv2_img)
              cv2.waitKey(0)
              return
      
          box_np = boxes[:,dominant_item].cpu().numpy() if boxes[:,dominant_item].is_cuda else boxes[:,dominant_item].numpy()
          x, y, w, h = box_np
          x1 = int((x - w / 2))
          y1 = int((y - h / 2))
          x2 = int(x1 + w)
          y2 = int(y1 + h)
          cv2.rectangle(cv2_img, (x1, y1), (x2, y2), (0, 255, 0), 2)
          cv2.imshow('image', cv2_img)
          cv2.waitKey(0)
      
      if __name__ == '__main__':
          main()
      1
    5. Glenn JocherUltralytics

      Thank you for sharing your use case and detailed implementation! Exporting models as TorchScript for chaining is indeed a smart approach, especially when managing dependency conflicts. If adjustments are needed for bounding boxes or results, ensure the coordinate transformations align with the input image dimensions. For additional guidance on TorchScript usage, feel free to reference Ultralytics TorchScript Docs. Let us know if you encounter further issues!

  2. tryprncpGitHub

    hi, I'm implementing yolov8 model in android gallery's search mechanism. the purpose of yolov8 model is to scan media files and return images that has a bounding box label that matches the search query. i can make it work with yolov5s.torchscript.ptl using org.pytorch:pytorch_android_lite:1.10.0 and org.pytorch:pytorch_android_torchvision_lite:1.10.0 but it wont work with yolov8s.torchscript. i really need help with this.

    1. Glenn JocherUltralytics

      Hey there! 😊 It sounds like you've made great progress integrating YOLOv8 into your Android app's search mechanism! If you've successfully used YOLOv5 models but are facing issues with YOLOv8's TorchScript model, let's try to sort this out.

      First, ensure you've exported the YOLOv8 model to TorchScript correctly using the latest YOLOv8 and PyTorch versions. Here's a quick snippet for exporting:

      from ultralytics import YOLO
      
      # Load YOLOv8 model
      model = YOLO('yolov8s.pt')  # Use the appropriate YOLOv8 variant
      
      # Export to TorchScript
      model.export(format='torchscript')

      This creates a file named yolov8s.torchscript. Ensure that this file is what you're trying to load in your Android app.

      If you're still having trouble after confirming the export process, consider checking the PyTorch Android version compatibility. YOLOv8 may require a newer version of PyTorch Android than YOLOv5, so updating org.pytorch:pytorch_android_lite and org.pytorch:pytorch_android_torchvision_lite to the latest versions might help.

      Lastly, since YOLOv8 is more recent, make sure you're using the latest release of the Ultralytics YOLO library for any compatibility fixes or improvements.

      If these steps don't resolve the issue, feel free to share any error messages or more specifics about the problem you're encountering. I'm here to help!