Commencer

Exporter des modèles YOLO26 au format TFLite Edge TPU

Le déploiement de modèles de vision par ordinateur sur des appareils aux capacités de calcul limitées, comme les systèmes mobiles ou embarqués, peut être complexe. Le recours à un format de modèle optimisé pour de meilleures performances simplifie le processus. Le format de modèle TensorFlow Lite Edge TPU, ou TFLite Edge TPU, est conçu pour consommer peu d’énergie tout en offrant de bonnes performances aux réseaux neuronaux.

L’export au format TFLite Edge TPU permet d’optimiser tes modèles Ultralytics YOLO26 pour une inférence rapide et peu énergivore. Dans ce guide, nous t’expliquerons comment convertir tes modèles au format TFLite Edge TPU afin qu’ils fonctionnent efficacement sur divers appareils mobiles et embarqués.

Pourquoi exporter au format TFLite Edge TPU ?#

L’export de modèles vers TensorFlow Edge TPU accélère et optimise les tâches de machine learning. Cette technologie convient aux applications disposant de peu d’énergie, de ressources de calcul ou de connectivité. L’Edge TPU est l’accélérateur matériel de périphérie de Google, une version de son unité de traitement Tensor (TPU). Il accélère les modèles TensorFlow Lite sur les appareils en périphérie. L’image ci-dessous illustre un exemple du processus.

TensorFlow Lite Edge TPU compilation workflow

L’Edge TPU fonctionne avec des modèles quantifiés. La quantification réduit la taille et accélère les modèles sans trop perdre en précision. Elle est idéale pour les ressources limitées de l’informatique en périphérie : les applications peuvent répondre rapidement grâce à une latence réduite et à un traitement local rapide des données, sans dépendre du cloud. Le traitement local protège également la confidentialité et la sécurité des données des utilisateurs, puisqu’elles ne sont pas envoyées à un serveur distant.

Principales fonctionnalités de TFLite Edge TPU#

Voici les principales caractéristiques qui font de TFLite Edge TPU un excellent choix de format de modèle pour les développeurs :

  • Performances optimisées sur les appareils en périphérie : TFLite Edge TPU assure une inférence rapide des réseaux neuronaux grâce à la quantification, à l’optimisation des modèles, à l’accélération matérielle et à l’optimisation du compilateur. Son architecture minimaliste contribue à réduire sa taille et ses coûts.

  • Débit de calcul élevé : TFLite Edge TPU combine une accélération matérielle spécialisée et une exécution efficace à l’exécution pour atteindre un débit de calcul élevé. Il convient parfaitement au déploiement de modèles d’apprentissage automatique soumis à des exigences de performances strictes sur les appareils périphériques.

  • Calculs matriciels efficaces : TensorFlow Edge TPU est optimisé pour les opérations matricielles, essentielles aux calculs des réseaux neuronaux. Cette efficacité est cruciale pour les modèles d’apprentissage automatique, en particulier ceux qui nécessitent de nombreuses multiplications et transformations matricielles complexes.

Options de déploiement avec TFLite Edge TPU#

Avant d’exporter des modèles YOLO26 au format TFLite Edge TPU, il est utile de comprendre leurs cas d’utilisation habituels.

TFLite Edge TPU propose diverses options de déploiement pour les modèles d’apprentissage automatique, notamment :

  • Déploiement sur l’appareil : les modèles TensorFlow Edge TPU peuvent être déployés directement sur des appareils mobiles et embarqués. Le déploiement sur l’appareil permet aux modèles de s’exécuter directement sur le matériel, sans nécessiter de connexion au cloud, soit en intégrant le modèle au paquet de l’application, soit en le téléchargeant à la demande.

  • Déploiement hybride : une approche hybride combine le déploiement sur l’appareil et dans le cloud, offrant une solution polyvalente et évolutive pour déployer des modèles d’apprentissage automatique. Elle permet notamment le traitement sur l’appareil pour des réponses rapides et le calcul dans le cloud pour des calculs plus complexes.

Tâches prises en charge#

L’export Edge TPU prend en charge six des sept tâches Ultralytics. La segmentation sémantique est disponible uniquement avec YOLO26, la seule famille à inclure cette tête. L’estimation de profondeur n’est pas prise en charge, car son modèle INT8 émet un opérateur EXP v2 que le compilateur Edge TPU ne peut pas analyser.

TâcheYOLOv8YOLO11YOLO26
Détecter✅✅✅
Segmenter✅✅✅
Sémantique❌❌✅
Profondeur❌❌❌
Classifier✅✅✅
Pose✅✅✅
OBB✅✅✅

Le compilateur Edge TPU associe les opérations qu’il prend en charge à l’accélérateur et laisse les autres s’exécuter sur le CPU ; la prise en charge d’une tâche ne signifie donc pas que toutes les opérations s’exécutent sur le TPU.

Exporter des modèles YOLO26 vers TFLite Edge TPU#

Tu peux élargir la compatibilité des modèles et la flexibilité du déploiement en convertissant les modèles YOLO26 au format TensorFlow Edge TPU.

Installation#

Pour installer le package requis, exécute :

Installation
# Install the required package for YOLO26
pip install ultralytics

Pour obtenir des instructions détaillées et connaître les bonnes pratiques liées à l’installation, consulte notre guide d’installation Ultralytics. Si tu rencontres des difficultés lors de l’installation des packages requis pour YOLO26, consulte notre guide des problèmes courants, qui propose des solutions et des conseils.

Utilisation#

Tous les modèles Ultralytics YOLO26 sont conçus pour prendre en charge l’exportation dès leur installation, ce qui facilite leur intégration à ton flux de déploiement préféré. Tu peux consulter la liste complète des formats d’exportation pris en charge et des options de configuration pour choisir la configuration la mieux adaptée à ton application.

Le format TFLite Edge TPU prend en charge les modes Export, Predict et Validate. L’inférence et la validation s’exécutent sur du matériel Coral Edge TPU. Exporte ton modèle, puis charge le modèle exporté pour effectuer l’inférence ou valider sa précision.

Export
from ultralytics import YOLO

# Charger un modèle YOLO26
model = YOLO("yolo26n.pt")

# Exporter le modèle au format TFLite Edge TPU
model.export(format="edgetpu")  # crée 'yolo26n_saved_model/yolo26n_full_integer_quant_edgetpu.tflite'
Prédiction
from ultralytics import YOLO

# Charger le modèle TFLite Edge TPU exporté
model = YOLO("yolo26n_saved_model/yolo26n_full_integer_quant_edgetpu.tflite")

# Exécuter l’inférence
results = model("https://ultralytics.com/images/bus.jpg")
Valider
from ultralytics import YOLO

# Charger le modèle TFLite Edge TPU exporté
model = YOLO("yolo26n_saved_model/yolo26n_full_integer_quant_edgetpu.tflite")

# Valider la précision sur le jeu de données COCO8
metrics = model.val(data="coco8.yaml")

Arguments d’exportation#

ArgumentTypeValeur par défautDescription
formatstr'edgetpu'Format cible du modèle exporté, qui définit sa compatibilité avec différents environnements de déploiement.
imgszint ou tuple640Taille d’image souhaitée pour l’entrée du modèle. Peut être un entier pour les images carrées ou un tuple (height, width) pour définir des dimensions spécifiques.
quantizeint ou str8/autoPrécision de quantification. 8 (INT8) est requis et activé automatiquement pour Edge TPU ; il compresse le modèle et accélère l’inférence avec une perte de précision minimale sur les appareils en périphérie. Remplace les indicateurs obsolètes half/int8.
opsetintNoneIndique la version de l'opset ONNX pour le graphe ONNX intermédiaire. Si elle n'est pas définie, utilise l'opset 18 (une version inférieure avec PyTorch < 2.4), sans dépasser la version onnx installée.
datastrNoneChemin vers le fichier YAML du jeu de données, indispensable à la quantification ; pour la classification, un répertoire de jeu de données ou le nom d’un jeu de données intégré est requis. Si quantize=8 n’est pas indiqué, Ultralytics sélectionne le jeu de données de calibration par défaut correspondant à la tâche du modèle.
fractionfloat, int ou list1.0Sous-ensemble de calibration exprimé en ratio, en nombre d’images ou en listes [train, val, test] de ratios/de nombres. Les listes de deux éléments laissent test complet, tandis que 0 l’ignore.
devicestrNoneIndique l’appareil utilisé pour l’exportation : CPU (device=cpu).
Conseil

Utilise une machine Linux x86 pour l’export vers Edge TPU.

Pour en savoir plus sur le processus d’export, consulte la page de la documentation Ultralytics consacrée à l’export.

Déployer des modèles YOLO26 TFLite Edge TPU exportés#

Après avoir exporté tes modèles Ultralytics YOLO26 au format TFLite Edge TPU, tu peux maintenant les déployer. La première étape recommandée pour exécuter un modèle TFLite Edge TPU consiste à utiliser la méthode YOLO("model_edgetpu.tflite"), comme indiqué dans l’extrait de code précédent.

Pour obtenir des instructions détaillées sur le déploiement de tes modèles TFLite Edge TPU, consulte les ressources suivantes :

Résumé#

Dans ce guide, nous avons appris à exporter des modèles Ultralytics YOLO26 au format TFLite Edge TPU. En suivant les étapes ci-dessus, tu peux exécuter tes applications de vision par ordinateur plus rapidement et avec moins d’énergie sur des appareils en périphérie.

Pour en savoir plus sur l’utilisation, consulte le site officiel de Coral Edge TPU.

FAQ#

  • Pour exporter un modèle YOLO26 au format TFLite Edge TPU, suis les étapes suivantes :

    Utilisation
    from ultralytics import YOLO
    
    # Charger un modèle YOLO26
    model = YOLO("yolo26n.pt")
    
    # Exporter le modèle au format TFLite Edge TPU
    model.export(format="edgetpu")  # crée 'yolo26n_saved_model/yolo26n_full_integer_quant_edgetpu.tflite'
    
    # Charger le modèle TFLite Edge TPU exporté
    edgetpu_model = YOLO("yolo26n_saved_model/yolo26n_full_integer_quant_edgetpu.tflite")
    
    # Exécuter l’inférence
    results = edgetpu_model("https://ultralytics.com/images/bus.jpg")

    Pour obtenir tous les détails sur l’exportation de modèles vers d’autres formats, consulte notre guide d’exportation.

  • L’export de modèles YOLO26 au format TFLite Edge TPU offre plusieurs avantages :

    • Performances optimisées : obtiens des performances élevées pour les réseaux neuronaux avec une consommation électrique minimale.
    • Latence réduite : traite rapidement les données localement, sans dépendre du cloud.
    • Confidentialité renforcée : le traitement local garantit la confidentialité et la sécurité des données utilisateur.

    Cela en fait un choix idéal pour les applications d’informatique en périphérie, où les appareils disposent de peu d’énergie et de ressources de calcul.

  • Oui, les modèles TensorFlow Lite Edge TPU peuvent être déployés directement sur des appareils mobiles et embarqués. Cette approche permet aux modèles de s’exécuter directement sur le matériel, pour une inférence plus rapide et plus efficace. Pour des exemples d’intégration, consulte notre guide de déploiement de Coral Edge TPU sur Raspberry Pi.

  • Les cas d’utilisation courants des modèles TFLite Edge TPU comprennent :

    • Caméras intelligentes : amélioration de l’analyse des images et des vidéos en temps réel.
    • Appareils IoT : automatisation intelligente des maisons et des installations industrielles.
    • Santé : accélération de l’imagerie médicale et du diagnostic.
    • Commerce de détail : amélioration de la gestion des stocks et de l’analyse du comportement des clients.

    Ces applications tirent parti des performances élevées et de la faible consommation électrique des modèles TFLite Edge TPU. Découvre d’autres scénarios d’utilisation.

  • Si tu rencontres des problèmes lors de l’exportation ou du déploiement de modèles TFLite Edge TPU, consulte notre guide des problèmes courants pour obtenir des conseils de dépannage. Ce guide présente les problèmes fréquents et leurs solutions afin de t’aider à garantir un fonctionnement sans heurts. Pour obtenir de l’aide supplémentaire, consulte notre Centre d’aide.

Commentaires30

Pose une question, partage tes résultats ou aide quelqu’un d’autre.

  1. faizaanscnzGitHub

    I am running a float32 TFLite model on Pixel 8a using the GPU. How can I run an Edge TPU model on the hardware to get faster FPS? I’m currently getting 8 FPS, but I need 20+. (Kivy app)

  2. walissongGitHub

    I would like to know if this tutorial works with yolov8n. I've been trying for many days and I'm not able to convert it to edgetpu.tflite.

  3. dbroGitHub

    Hello. This seems to be broken for yolo11, although it works for yolov8. After running these two commands in Google colab, the output file is less than 1kb and it generates an error.

    ! pip install ultralytics ! yolo mode=export model=yolo11n.pt format=edgetpu imgsz=320

    The final step to run the EdgeTPU compiler seems to be where the problem is:

    ... TensorFlow SavedModel: export success ✅ 112.9s, saved as 'yolo11n_saved_model' (33.8 MB)

    Edge TPU: starting export with Edge TPU compiler 16.0.384591198... Edge TPU: running 'edgetpu_compiler --out_dir "yolo11n_saved_model" --show_operations --search_delegate --delegate_search_step 30 --timeout_sec 180 "yolo11n_saved_model/yolo11n_full_integer_quant.tflite"' Edge TPU Compiler version 16.0.384591198 Searching for valid delegate with step 30 Try to compile segment with 677 ops ERROR: Didn't find op for builtin opcode 'CONV_2D' version '6'. An older version of this builtin might be supported. Are you using an old TFLite binary with a newer model?

    ERROR: Registration failed.

    Invalid model: yolo11n_saved_model/yolo11n_full_integer_quant.tflite Model could not be parsed Edge TPU: export success ✅ 0.0s, saved as 'yolo11n_saved_model/yolo11n_full_integer_quant_edgetpu.tflite' (0.0 MB) ...

  4. manu13008GitHub

    Hi, Once I exported my best.pt model into edgetpu tflite, I tried to run an inference on an image as the code above but I got the following error :

    OSError: libedgetpu.so.1: cannot open shared object file: No such file or directory

    Do you have any insights of how resolving this ?

    Thanks :)

    1. Glenn JocherUltralytics

      @manu13008 it seems like the error is due to the missing Edge TPU runtime library. Please ensure you have installed the Edge TPU runtime on your device. You can find installation instructions in the Edge TPU documentation. If you need further assistance, feel free to check the resources there.

  5. Abdullah-OryGitHub

    Hi friends, i am using google colap to compile yolo11n.pt into edgetpu format, since i have orange pi 5 pro which is arm, so when i am trying to do it in my laptop i got this Ultralytics 8.3.9 🚀 Python-3.10.12 torch-2.4.1+cu121 CPU (Intel Xeon 2.20GHz) YOLO11n summary (fused): 238 layers, 2,616,248 parameters, 0 gradients, 6.5 GFLOPs

    PyTorch: starting from '/content/yolo11n.pt' with input shape (1, 3, 640, 640) BCHW and output shape(s) (1, 84, 8400) (5.4 MB)

    TensorFlow SavedModel: starting export with tensorflow 2.17.0...

    ONNX: starting export with onnx 1.17.0 opset 19... ONNX: slimming with onnxslim 0.1.34... ONNX: export success ✅ 3.0s, saved as '/content/yolo11n.onnx' (10.3 MB) TensorFlow SavedModel: starting TFLite export with onnx2tf 1.22.3...

    Automatic generation of each OP name started ======================================== Automatic generation of each OP name complete!

    Model loaded ========================================================================

    Model conversion started ============================================================ saved_model output started ========================================================== saved_model output complete! Float32 tflite output complete! Float16 tflite output complete! Dynamic Range Quantization tflite output complete! Input signature information for quantization signature_name: serving_default input_name.0: images shape: (1, 640, 640, 3) dtype: <dtype: 'float32'> INT8 Quantization tflite output complete! Full INT8 Quantization tflite output complete! Traceback (most recent call last): File "/usr/local/lib/python3.10/dist-packages/onnx2tf/onnx2tf.py", line 1566, in convert tflite_model = converter.convert() File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/lite.py", line 1231, in wrapper return self._convert_and_export_metrics(convert_func, *args, **kwargs) File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/lite.py", line 1183, in _convert_and_export_metrics result = convert_func(self, *args, **kwargs) File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/lite.py", line 1562, in convert return self._convert_from_saved_model(graph_def) File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/lite.py", line 1424, in _convert_from_saved_model return self._optimize_tflite_model( File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/convert_phase.py", line 215, in wrapper raise error from None # Re-throws the exception. File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/convert_phase.py", line 205, in wrapper return func(*args, **kwargs) File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/lite.py", line 1127, in _optimize_tflite_model model = self._quantize( File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/lite.py", line 767, in _quantize return calibrate_quantize.calibrate_and_quantize( File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/convert_phase.py", line 215, in wrapper raise error from None # Re-throws the exception. File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/convert_phase.py", line 205, in wrapper return func(*args, **kwargs) File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/optimize/calibrator.py", line 194, in calibrate_and_quantize return self._calibrator.QuantizeModel( RuntimeError: Quantized dimension for tensor property and quantization parameters do not match. Got 3 and 0 respectively.

    WARNING: INT8 Quantization with int16 activations tflite output failed. Traceback (most recent call last): File "/usr/local/lib/python3.10/dist-packages/onnx2tf/onnx2tf.py", line 1597, in convert tflite_model = converter.convert() File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/lite.py", line 1231, in wrapper return self._convert_and_export_metrics(convert_func, *args, **kwargs) File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/lite.py", line 1183, in _convert_and_export_metrics result = convert_func(self, *args, **kwargs) File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/lite.py", line 1562, in convert return self._convert_from_saved_model(graph_def) File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/lite.py", line 1424, in _convert_from_saved_model return self._optimize_tflite_model( File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/convert_phase.py", line 215, in wrapper raise error from None # Re-throws the exception. File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/convert_phase.py", line 205, in wrapper return func(*args, **kwargs) File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/lite.py", line 1127, in _optimize_tflite_model model = self._quantize( File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/lite.py", line 767, in _quantize return calibrate_quantize.calibrate_and_quantize( File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/convert_phase.py", line 215, in wrapper raise error from None # Re-throws the exception. File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/convert_phase.py", line 205, in wrapper return func(*args, **kwargs) File "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/optimize/calibrator.py", line 194, in calibrate_and_quantize return self._calibrator.QuantizeModel( RuntimeError: Quantized dimension for tensor property and quantization parameters do not match. Got 3 and 0 respectively.

    WARNING: Full INT8 Quantization with int16 activations tflite output failed. TensorFlow SavedModel: export success ✅ 248.1s, saved as '/content/yolo11n_saved_model' (36.1 MB) Edge TPU: WARNING ⚠️ Edge TPU known bug https://github.com/ultralytics/ultralytics/issues/1185

    Edge TPU: starting export with Edge TPU compiler 16.0.384591198... Edge TPU: running 'edgetpu_compiler -s -d -k 10 --out_dir "/content/yolo11n_saved_model" "/content/yolo11n_saved_model/yolo11n_full_integer_quant.tflite"' Edge TPU: export success ✅ 3.9s, saved as '/content/yolo11n_saved_model/yolo11n_full_integer_quant_edgetpu.tflite' (3.5 MB)

    Export complete (252.6s) Results saved to /content Predict: yolo predict task=detect model=/content/yolo11n_saved_model/yolo11n_full_integer_quant_edgetpu.tflite imgsz=640 int8 Validate: yolo val task=detect model=/content/yolo11n_saved_model/yolo11n_full_integer_quant_edgetpu.tflite imgsz=640 data=/usr/src/ultralytics/ultralytics/cfg/datasets/coco.yaml int8 Visualize: https://netron.app /content/yolo11n_saved_model/yolo11n_full_integer_quant_edgetpu.tflite

    1. Glenn JocherUltralytics

      @Abdullah-Ory it seems you're encountering an issue with INT8 quantization during the TFLite Edge TPU export. Please ensure your model is compatible with Edge TPU requirements, and consider checking the Ultralytics documentation for detailed guidance on exporting models to TFLite Edge TPU format. If the issue persists, reviewing the quantization parameters might help.

  6. MECHAAMERGitHub

    Hi,

    I trained a YOLOv8l model with VisDrone dataset, and attempted to convert the best weights.pt to Edge TPU TFlite format using:

    model = YOLO("best.pt") model.export(format="edgetpu")

    my board is Coral dev board.

    The conversion completed successfully, but the results indicate that 164 of operations will run on the CPU instead of the Edge TPU. only 223 operation will run using Edge TPU This CPU usage will likely cause performance delays.

    I'm wondering if there are any strategies or techniques to improve Edge TPU utilization and minimize CPU usage during inference for this model. Any suggestions or insights would be greatly appreciated.

    Thanks,

    1. Glenn JocherUltralytics

      @MECHAAMER to improve Edge TPU utilization, ensure your model is fully quantized and compatible with Edge TPU operations. Consider simplifying the model architecture or using supported operations. For detailed guidance, please refer to the Ultralytics Edge TPU documentation.

    2. MECHAAMERGitHub

      Hi, thank you for your support, I follow the attached link, and apply it using: model.export(format="edgetpu") , and I get this output:

      Number of operations that will run on Edge TPU: 133 Number of operations that will run on CPU: 364

      more details in the attached photo.

      I think with this big percent of ops that runs on the CPU, the model will be very slow and I will suffer from large latency.

      Do you have any suggestions?

    3. MECHAAMERGitHub

      Hi there,

      I'm following the Ultralytics Edge TPU documentation to train a YOLO model for object detection. However, I'm encountering suboptimal results.

      I suspect that the issue might lie in the model's compatibility with the TPU. It's possible that certain operations within the model are not optimized for the TPU, leading to delays.

      To address this, I'm considering using a YOLO model that is specifically designed to run efficiently on the Edge TPU. Do you have any recommendations for such models?

    4. Glenn JocherUltralytics

      For optimal Edge TPU performance, consider using a smaller YOLO model like YOLOv8n, which is more compatible with Edge TPU operations. Simplifying the model architecture can also help.

    5. MECHAAMERGitHub

      I'm encountering a "Segmentation fault" error while trying to run a segmented YOLOv5s model on my Coral Dev Board with an external Coral ML Accelerator (USB). I followed the recommended steps to export, compile, and segment the model using edgetpu_compiler.

      I follow these steps:

      I trained Yolov5su model, then I exported the model as tflite - 8int by using:
      model.export()
      
      then I use the edgetpu_compiler to compile the tflite model and segmented it into 2 models:
      edgetpu_compiler model.tflite --num_segments=2
      
      then I get 12 files, 8 models and 4 logs, the models are:
      1- best_float32_segment_0_of_2.tflite
      2- best_float32_segment_1_of_2.tflite
      3- best_float32_segment_0_of_2_edgetpu.tflite
      4- best_float32_segment_1_of_2_edgetpu.tflite
      5- best_full_integer_quant_segment_0_of_2.tflite
      6- best_full_integer_quant_segment_1_of_2.tflite
      7- best_full_integer_quant_segment_0_of_2_edgetpu.tflite
      8- best_full_integer_quant_segment_1_of_2_edgetpu.tflite

      I transfer the "best_full_integer_quant_segment_0_of_2_edgetpu.tflite" and "best_full_integer_quant_segment_1_of_2_edgetpu.tflite" to the coral board and I tried to run the models to detect object in a video, the code:

      
      import argparse
      import re
      import threading
      import time
      
      import numpy as np
      import cv2
      
      from pycoral.adapters import classify
      from pycoral.adapters import common
      import pycoral.pipeline.pipelined_model_runner as pipeline
      from pycoral.utils.dataset import read_label_file
      from pycoral.utils.edgetpu import list_edge_tpus
      from pycoral.utils.edgetpu import make_interpreter
      
      
      def _get_devices(num_devices):
        edge_tpus = list_edge_tpus()
      
        if len(edge_tpus) < num_devices:
          raise RuntimeError(
              'Not enough Edge TPUs detected, expected %d, detected %d.' %
              (num_devices, len(edge_tpus)))
      
        num_pci_devices = sum(1 for device in edge_tpus if device['type'] == 'pci')
      
        return ['pci:%d' % i for i in range(min(num_devices, num_pci_devices))] + [
            'usb:%d' % i for i in range(max(0, num_devices - num_pci_devices))
        ]
      
      
      def _make_runner(model_paths, devices):
        """Constructs PipelinedModelRunner given model paths and devices."""
        print('Using devices: ', devices)
        print('Using models: ', model_paths)
         
        print("  hey runner   1")
        if len(model_paths) != len(devices):
          raise ValueError('# of devices and #of model_paths should match')
        
        print("  hey runner   2", model_paths[0], devices[1])
       
        interpreters = []
        interpreter = make_interpreter(model_paths[0], devices[0])
        print("  hey runner   3")
        interpreter.allocate_tensors()
        print("  hey runner   4")
        interpreters.append(interpreter)
        print("  hey runner   5", model_paths[1], devices[0])
        
        interpreter2 = make_interpreter(model_paths[1], devices[1])
        print("  hey runner   6")
        interpreter.allocate_tensors()
        interpreter2.allocate_tensors()
        print("  hey runner   7")
        interpreters.append(interpreter2)
        print("  hey runner   8")
      
        return pipeline.PipelinedModelRunner(interpreters)
      
      
      def main():
        parser = argparse.ArgumentParser(
            formatter_class=argparse.ArgumentDefaultsHelpFormatter)
        parser.add_argument(
            '-m',
            '--models',
            required=True,
            help=('File path template of .tflite model segments, e.g.,'
                  'inception_v3_299_quant_segment_%d_of_2_edgetpu.tflite'))
        parser.add_argument(
            '-i', '--input', required=True, help='Image to be classified.')
        parser.add_argument('-l', '--labels', help='File path of labels file.')
        parser.add_argument(
            '-k',
            '--top_k',
            type=int,
            default=1,
            help='Max number of classification results')
        parser.add_argument(
            '-t',
            '--threshold',
            type=float,
            default=0.0,
            help='Classification score threshold')
        parser.add_argument(
            '-c',
            '--count',
            type=int,
            default=1,
            help='Number of times to run inference')
        args = parser.parse_args()
        labels = {0:"pedestrian", 1:"people", 2:"bicycle", 3:"car", 4:"van", 5:"truck", 6:"tricycle", 7:"awning-tricycle", 8:"bus", 9:"motor"}
        print("hey lets begin   1")
        result = re.search(r'^.*_segment_%d_of_(?P<num_segments>[0-9]+)_.*.tflite',
                           args.models)
        print("hey lets begin   2")
      
        if not result:
          print("hey lets begin    3")
      
          raise ValueError(
              '--models should follow *_segment%d_of_[num_segments]_*.tflite pattern')
        print("hey lets begin    4")
      
        num_segments = int(result.group('num_segments'))
        model_paths = [args.models % i for i in range(num_segments)]
        print("hey lets begin    5")
      
        devices = _get_devices(num_segments)
      
        print("hey lets begin    6")
      
        runner = _make_runner(model_paths, devices)
        
        print("hey lets begin      7")
      
      
        # Get the input name and size
        size = common.input_size(runner.interpreters()[0])
        
        print("hey lets begin     8")
      
        name = common.input_details(runner.interpreters()[0], 'name')
       
        print("hey lets begin    9")
      
        cap = cv2.VideoCapture(args.input)
        
        print("hey lets begin    10")
      
        if not cap.isOpened():
            print("Error opening video capture device")
            return
        
        print("hey lets begin    11")
      
        while True:
            ret, frame = cap.read()
            if not ret:
                break
      
            # Preprocess the frame
            height, width, _ = frame.shape
            new_height = int(640 * height / width)
            image = cv2.resize(frame, (640, new_height))
      
            # Run inference
            runner.push({name: image})
            
            output_details = runner.interpreters()[-1].get_output_details()[0]
            scale, zero_point = output_details['quantization']
        
            result = runner.pop()
      
            if result:
                # Process the results
                values, = result.values()
                scores = scale * (values[0].astype(np.int64) - zero_point)
                classes, scores = classify.get_classes_from_scores(result[0], args.top_k, args.threshold)
                
                for klass in classes:
                    print('%s: %.5f' % (labels.get(klass.id, klass.id), klass.score))
                
                print('-------RESULTS--------')
            else:
                print("No results")
      
      if __name__ == '__main__':
        main()
      then I try execute the python file:

      python3 test2tpu.py -m best_full_integer_quant_segment_%d_of_2_edgetpu.tflite -i "/coral/720p/Busy Road.mp4"

      the output that I get:

      hey lets begin 1 hey lets begin 2 hey lets begin 4 hey lets begin 5 hey lets begin 6 Using devices: ['pci:0', 'usb:0'] Using models: ['best_full_integer_quant_segment_0_of_2_edgetpu.tflite', 'best_full_integer_quant_segment_1_of_2_edgetpu.tflite'] hey runner 1 hey runner 2 best_full_integer_quant_segment_0_of_2_edgetpu.tflite usb:0 hey runner 3 hey runner 4 hey runner 5 best_full_integer_quant_segment_1_of_2_edgetpu.tflite pci:0 Segmentation fault

      Note: pycoral version: 2.0.0

    6. Glenn JocherUltralytics

      It seems like the segmentation fault might be due to compatibility issues with the model operations on the Edge TPU. Consider simplifying the model architecture or ensuring all operations are supported by the Edge TPU. You can also check the Common Issues guide for additional troubleshooting tips.

    7. MECHAAMERGitHub

      Can you help me to know more about: simplifying the model architecture or ensuring all operations are supported by the Edge TPU.

      I don't have access now to the records because I am outside office, as I remember In yolov5su, there are more than 200 process depends in TPU and only 25 process use CPU, Also the model working well on 1 TPU (with no segmentation).

    8. Glenn JocherUltralytics

      @MECHAAMER to improve Edge TPU compatibility, consider using a smaller model like YOLOv8n, which is more likely to use supported operations, or simplify the architecture by reducing layers and operations that are not TPU-optimized.

  7. Taufiq-AhmedGitHub

    Hi, I have train my custom dataset for detect fire and smoke with yolov8 nano. it's best model size is around 6MB and after exporting it using "yolo export model=yolov8n.pt format=edgetpu". it's size reduced to 3MB. But have to integrate this model in XIAO RP2040 MCU. So I need more light weight model for my edge device. In this case what I should? Please give me a solution.

    1. Glenn JocherUltralytics

      @Taufiq-Ahmed hi! It's great to hear that you've successfully trained your custom dataset with YOLOv8 nano. For further reducing the model size for your XIAO RP2040 MCU, you might want to explore additional quantization techniques. The TFLite Edge TPU format already applies full integer quantization, but you can experiment with pruning or other model compression techniques to further reduce the size. If you haven't already, ensure you're using the latest version of the Ultralytics package for the best optimization features. For more detailed guidance, you can check out our Edge TPU integration guide. Good luck with your deployment!

  8. samphonicGitHub

    So I have a tflite model and object detection is working, but I can't seem to figure out how to tell if (and how effectively) the model is actually using the Edge TPU hardware. Is there some way to confirm that the hardware is actually being used? Can I manually enable/disable it to compare inference time?

    1. Glenn JocherUltralytics

      @Sammy1Am to confirm if your model is utilizing the Edge TPU hardware, you can check the inference time and compare it with and without the Edge TPU. Typically, when the Edge TPU is in use, you should see a significant reduction in inference time. You can manually enable or disable the Edge TPU by using the edgetpu interpreter for the Edge TPU and the standard TFLite interpreter otherwise. For more details on setting this up, you might find the Edge TPU documentation helpful. If you need further assistance, feel free to explore our Ultralytics documentation.

    1. Glenn JocherUltralytics

      @FearL0rd thank you for your suggestion! Streamlining segmentation during export is indeed a valuable enhancement. For detailed guidance on exporting YOLOv8 models to TFLite Edge TPU format, you can refer to our documentation. This will help you optimize your models for high-speed, low-power inferencing on devices with limited computational power.

      For more information on using YOLO with a Dual TPU card, you can leverage the APEX_0 and APEX_1 devices to distribute the workload effectively. This setup can significantly boost performance and efficiency in your machine learning tasks.

      Feel free to explore the provided resources and let us know if you have any further questions! 🚀

    2. Glenn JocherUltralytics

      Hi @FearL0rd,

      For documentation on segmentation using APEX_0 and APEX_1, you can refer to the guide on exporting YOLOv8 models to TFLite Edge TPU format. This guide covers optimizing your models for high-speed, low-power inferencing on devices like the Coral Edge TPU.

      To utilize both APEX_0 and APEX_1 devices, you can distribute the workload effectively across the dual TPU setup, enhancing performance and efficiency. For more detailed instructions, please visit the relevant sections in our documentation.

      Feel free to reach out if you have any more questions! 😊