Exportar modelos YOLO26 a TorchScript para una implementación rápida
PyTorch ha marcado TorchScript como obsoleto y está retirando gradualmente sus funciones. Para las nuevas implementaciones móviles y en el borde, utiliza la integración compatible con ExecuTorch. Ultralytics mantiene la exportación habitual a TorchScript para garantizar la compatibilidad con código C++ heredado.
Implementar modelos de visión artificial en entornos C++ sin Python requiere una representación serializada y portable. TorchScript ofrece esa compatibilidad para aplicaciones heredadas de LibTorch.
Exporta a TorchScript para serializar tus modelos Ultralytics YOLO26 y conseguir compatibilidad multiplataforma y un despliegue más sencillo. En esta guía se explica cómo exportar tus modelos YOLO26 al formato TorchScript para utilizarlos en una gama más amplia de aplicaciones.
¿Por qué deberías exportar a TorchScript?#

Desarrollado por los creadores de PyTorch, TorchScript es una herramienta para optimizar y desplegar modelos PyTorch en distintas plataformas. Exportar modelos YOLO26 a TorchScript facilita su paso de la investigación a las aplicaciones del mundo real. TorchScript, que forma parte del marco de PyTorch, simplifica esta transición al permitir usar modelos PyTorch en entornos que no admiten Python.
El proceso utiliza dos técnicas: trazado y scripting. El trazado registra las operaciones durante la ejecución del modelo, mientras que el scripting permite definir modelos mediante un subconjunto de Python. Estas técnicas permiten que modelos como YOLO26 se ejecuten fuera de su entorno Python habitual.

Los modelos TorchScript también se pueden optimizar mediante técnicas como la fusión de operadores y el uso más eficiente de la memoria, lo que garantiza una ejecución eficaz. Otra ventaja de exportar a TorchScript es que puede acelerar la ejecución del modelo en distintas plataformas de hardware. Crea una representación independiente, lista para producción, de tu modelo PyTorch que se puede integrar en entornos C++.
Características principales de los modelos TorchScript#
TorchScript, una parte fundamental del ecosistema PyTorch, ofrece funciones para optimizar y desplegar modelos de aprendizaje profundo.

Estas son las características principales que hacen de TorchScript una herramienta valiosa para los desarrolladores:
-
Ejecución con grafo estático: TorchScript utiliza una representación de grafo estático para los cálculos del modelo, a diferencia de la ejecución con grafo dinámico de PyTorch. En la ejecución con grafo estático, el grafo computacional se define y compila una sola vez antes de la ejecución propiamente dicha, lo que mejora el rendimiento durante la inferencia.
-
Serialización de modelos: TorchScript permite serializar modelos PyTorch en un formato independiente de la plataforma. Los modelos serializados se pueden cargar sin necesitar el código Python original, lo que permite implementarlos en distintos entornos de ejecución.
-
Compilación JIT: TorchScript utiliza la compilación en tiempo de ejecución (JIT) para convertir modelos PyTorch en una representación intermedia optimizada. JIT compila el grafo computacional del modelo para permitir una ejecución eficiente en los dispositivos de destino.
-
Conversión gradual: TorchScript ofrece un enfoque de conversión gradual que permite convertir progresivamente partes de un modelo PyTorch a TorchScript. Esta flexibilidad resulta especialmente útil con modelos complejos o cuando quieres optimizar partes concretas del código.
Opciones de implementación en TorchScript#
Antes de ver el código para exportar modelos YOLO26 al formato TorchScript, veamos dónde se suelen utilizar los modelos TorchScript.
TorchScript ofrece varias opciones para implementar modelos de aprendizaje automático, como las siguientes:
-
API de C++: El caso de uso más habitual de TorchScript es su API de C++ de LibTorch, que permite cargar y ejecutar modelos TorchScript optimizados directamente en aplicaciones C++. Es ideal para entornos de producción en los que Python puede no ser adecuado o no estar disponible. La API de C++ permite ejecutar modelos TorchScript de forma eficiente y con poca sobrecarga, para aprovechar al máximo el rendimiento.
-
Implementación en móviles: Para obtener inferencias de baja latencia y sin conexión, así como privacidad de los datos en dispositivos móviles, utiliza ExecuTorch, el sustituto de TorchScript Mobile de PyTorch.
-
Despliegue en la nube: Los modelos TorchScript se pueden desplegar en servidores en la nube con soluciones como NVIDIA Triton Inference Server. Ofrece funciones como el control de versiones de modelos, el procesamiento por lotes y la supervisión de métricas para desplegar modelos de forma escalable en entornos de producción. El despliegue en la nube con TorchScript puede hacer que tus modelos estén disponibles a través de API u otros servicios web.
Tareas compatibles#
La exportación a TorchScript es compatible con las siete tareas de Ultralytics. La segmentación semántica y la estimación de profundidad solo están disponibles con YOLO26, la única familia que incluye esas cabezas.
| Tarea | YOLOv8 | YOLO11 | YOLO26 |
|---|---|---|---|
| Detectar | ✅ | ✅ | ✅ |
| Segmentar | ✅ | ✅ | ✅ |
| Semántica | ❌ | ❌ | ✅ |
| Profundidad | ❌ | ❌ | ✅ |
| Clasificar | ✅ | ✅ | ✅ |
| Pose | ✅ | ✅ | ✅ |
| OBB | ✅ | ✅ | ✅ |
Exportar a TorchScript: convertir tu modelo YOLO26#
Exportar modelos YOLO26 a TorchScript facilita su ejecución fuera de Python, por ejemplo, en aplicaciones C++ basadas en LibTorch.
Instalación#
Para instalar el paquete necesario, ejecuta:
# Install the required package for YOLO26
pip install ultralyticsPara obtener instrucciones detalladas y buenas prácticas relacionadas con el proceso de instalación, consulta nuestra guía de instalación de Ultralytics. Si tienes dificultades al instalar los paquetes necesarios para YOLO26, consulta nuestra guía sobre problemas habituales, donde encontrarás soluciones y consejos.
Uso#
Todos los modelos Ultralytics YOLO26 están diseñados para admitir la exportación desde el primer momento, lo que facilita su integración en el flujo de trabajo de implementación que prefieras. Puedes consultar la lista completa de formatos de exportación y opciones de configuración compatibles para elegir la configuración más adecuada para tu aplicación.
El formato TorchScript es compatible con los modos Exportar, Predecir y Validar. Exporta tu modelo y, a continuación, carga el modelo exportado para ejecutar inferencias o validar su precisión.
from ultralytics import YOLO
# Carga un modelo YOLO26
model = YOLO("yolo26n.pt")
# Exporta el modelo al formato TorchScript
model.export(format="torchscript") # crea 'yolo26n.torchscript'from ultralytics import YOLO
# Carga el modelo TorchScript exportado
model = YOLO("yolo26n.torchscript")
# Ejecutar inferencia
results = model("https://ultralytics.com/images/bus.jpg")from ultralytics import YOLO
# Carga el modelo TorchScript exportado
model = YOLO("yolo26n.torchscript")
# Valida la precisión con el conjunto de datos COCO8
metrics = model.val(data="coco8.yaml")Argumentos de exportación#
| Argumento | Tipo | Predeterminado | Descripción |
|---|---|---|---|
format | str | 'torchscript' | Formato de destino del modelo exportado, que define su compatibilidad con distintos entornos de implementación. |
imgsz | int o tuple | 640 | Tamaño de imagen deseado para la entrada del modelo. Puede ser un número entero para imágenes cuadradas o una tupla (height, width) para dimensiones específicas. |
dynamic | bool | False | Permite tamaños de entrada dinámicos, lo que aumenta la flexibilidad para trabajar con imágenes de distintas dimensiones. |
quantize | int o str | None | Precisión de cuantización: 16 (FP16) requiere exportar con GPU y device=0; 32/sin definir corresponde a FP32. Sustituye a la marca half, obsoleta. |
nms | bool, opcional | None | Selecciona la salida sin procesar (None, predeterminada), NMS integrada (True) o el cabezal sin NMS (False). |
batch | int | 1 | Especifica el tamaño del lote de inferencia del modelo exportado o el número máximo de imágenes que el modelo exportado procesará simultáneamente en el modo predict. |
device | str | None | Especifica el dispositivo para la exportación: GPU (device=0), CPU (device=cpu), MPS para Apple silicon (device=mps). |
Para obtener más información sobre el proceso de exportación, visita la página de documentación de Ultralytics sobre exportación.
Implementar modelos YOLO26 TorchScript exportados#
Tras exportar correctamente tus modelos Ultralytics YOLO26 al formato TorchScript, ya puedes implementarlos. El primer paso recomendado para ejecutar un modelo TorchScript es utilizar el método YOLO("model.torchscript"), tal como se muestra en el fragmento de código de uso anterior. Si necesitas instrucciones detalladas para implementar tus modelos TorchScript en otros entornos, consulta los siguientes recursos:
-
Descubre la implementación en móviles: Utiliza la canalización independiente
torch.export()→.ptede ExecuTorch para las implementaciones móviles actuales de PyTorch. -
Domina el despliegue en el servidor: Aprende a servir modelos TorchScript con el backend PyTorch de NVIDIA Triton Inference Server para ofrecer modelos de forma eficiente y escalable.
-
Implementa en C++: Consulta el tutorial sobre cómo cargar un modelo TorchScript en C++, que facilita la integración de tus modelos TorchScript en aplicaciones C++ para mejorar el rendimiento y la versatilidad.
Resumen#
En esta guía hemos explicado cómo exportar modelos Ultralytics YOLO26 al formato TorchScript. Si sigues las instrucciones, podrás optimizar el rendimiento de los modelos YOLO26 y desplegarlos con flexibilidad en distintas plataformas y entornos.
Para obtener más información sobre el uso, visita la documentación oficial de TorchScript.
Preguntas frecuentes#
Exportar un modelo Ultralytics YOLO26 a TorchScript permite implementarlo de forma flexible y multiplataforma. TorchScript, que forma parte del ecosistema PyTorch, facilita la serialización de modelos para ejecutarlos después en entornos sin compatibilidad con Python. Por eso resulta útil para implementar modelos en entornos C++.
Para exportar un modelo YOLO26 a TorchScript, puedes utilizar el siguiente código de ejemplo:
Usofrom ultralytics import YOLO # Carga un modelo YOLO26 model = YOLO("yolo26n.pt") # Exporta el modelo al formato TorchScript model.export(format="torchscript") # crea 'yolo26n.torchscript' # Carga el modelo TorchScript exportado torchscript_model = YOLO("yolo26n.torchscript") # Ejecutar inferencia results = torchscript_model("https://ultralytics.com/images/bus.jpg")Para obtener más información sobre el proceso de exportación, consulta la documentación de Ultralytics sobre exportación.
Usar TorchScript para implementar modelos YOLO26 ofrece varias ventajas:
- Portabilidad: Los modelos exportados se pueden ejecutar en aplicaciones C++ sin Python.
- Optimización: TorchScript es compatible con la ejecución con grafo estático y la compilación en tiempo de ejecución (JIT), que pueden optimizar el rendimiento de los modelos.
- Integración entre lenguajes: Los modelos TorchScript se pueden integrar en otros lenguajes de programación, lo que aumenta la flexibilidad y la capacidad de ampliación.
- Serialización: Los modelos se pueden serializar para cargarlos y ejecutar inferencias de forma independiente de la plataforma.
Para obtener más información sobre el despliegue, consulta la Guía de despliegue en C++. Para el despliegue en dispositivos móviles, PyTorch recomienda ahora ExecuTorch, que utiliza su propia canalización independiente
torch.export()→.pteen lugar de TorchScript.Para instalar el paquete necesario para exportar modelos YOLO26, utiliza el siguiente comando:
Instalación# Install the required package for YOLO26 pip install ultralyticsPara obtener instrucciones detalladas, visita la guía de instalación de Ultralytics. Si surge algún problema durante la instalación, consulta la guía de problemas habituales.
Después de exportar los modelos YOLO26 al formato TorchScript, puedes desplegarlos en distintas plataformas:
- API de C++: Utiliza LibTorch en entornos de producción que requieran una sobrecarga baja y una gran eficiencia.
- Despliegue móvil: Utiliza ExecuTorch, la alternativa compatible con PyTorch que cuenta con un proceso de exportación independiente
.pte. - Despliegue en la nube: Usa servicios como NVIDIA Triton Inference Server para desplegar modelos en servidores de forma escalable.
Comentarios9
Haz una pregunta, comparte tus resultados o ayuda a otra persona.
amarnathreddy0201
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.
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.amarnathreddy0201
Model = torch.jit.load('yolov8n.torchscript') results = Model(image)
It will predict the boxes, classes
amarnathreddy0201(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 scoresconf_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
Paula DerrengerUltralyticsIt 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.
clausMeko(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
Glenn JocherUltralyticsThank 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!
tryprncp
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.
Glenn JocherUltralyticsHey 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_liteandorg.pytorch:pytorch_android_torchvision_liteto 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!