Ultralytics YOLO27: Запишись в список ожидания.
Начать

Экспорт моделей YOLO26 в формат TFLite Edge TPU#

Развертывание моделей компьютерного зрения на устройствах с ограниченными вычислительными возможностями, например мобильных или встроенных системах, может быть непростой задачей. Этот процесс упрощает использование формата модели, оптимизированного для более высокой производительности. Формат модели TensorFlow Lite Edge TPU, или TFLite Edge TPU, разработан для эффективной работы нейронных сетей при минимальном энергопотреблении.

Экспорт в формат TFLite Edge TPU позволяет оптимизировать модели Ultralytics YOLO26 для высокоскоростного инференса с низким энергопотреблением. В этом руководстве мы покажем, как преобразовать модели в формат TFLite Edge TPU, чтобы их было проще эффективно запускать на различных мобильных и встроенных устройствах.

Зачем экспортировать модель в TFLite Edge TPU?#

Экспорт моделей в TensorFlow Edge TPU ускоряет и оптимизирует задачи машинного обучения. Эта технология подходит для приложений с ограниченным энергопотреблением, вычислительными ресурсами и подключением к сети. Edge TPU — это периферийный вариант аппаратного ускорителя Google Tensor Processing Unit (TPU). Он ускоряет модели TensorFlow Lite на периферийных устройствах. На изображении ниже показан пример соответствующего процесса.

TensorFlow Lite Edge TPU compilation workflow

Edge TPU работает с квантованными моделями. Квантование уменьшает размер моделей и ускоряет их работу практически без потери точности. Это идеальный вариант для ограниченных ресурсов периферийных вычислений: приложения быстро реагируют благодаря снижению задержки и быстрой локальной обработке данных без зависимости от облака. Локальная обработка также обеспечивает конфиденциальность и безопасность данных пользователей, поскольку они не отправляются на удаленный сервер.

Ключевые возможности TFLite Edge TPU#

Вот основные особенности, благодаря которым TFLite Edge TPU — отличный формат моделей для разработчиков:

  • Оптимизированная производительность на периферийных устройствах: TFLite Edge TPU обеспечивает быстрый инференс нейронных сетей благодаря квантованию, оптимизации моделей, аппаратному ускорению и оптимизации компилятора. Минималистичная архитектура делает его компактнее и экономичнее.

  • Высокая вычислительная производительность: TFLite Edge TPU сочетает специализированное аппаратное ускорение и эффективное выполнение во время работы, обеспечивая высокую вычислительную производительность. Это решение хорошо подходит для развертывания моделей машинного обучения на периферийных устройствах с жесткими требованиями к производительности.

  • Эффективные матричные вычисления: TensorFlow Edge TPU оптимизирован для матричных операций, критически важных для вычислений нейронных сетей. Эта эффективность особенно важна для моделей машинного обучения, которым требуется выполнять множество сложных матричных умножений и преобразований.

Варианты развертывания с TFLite Edge TPU#

Перед экспортом моделей YOLO26 в формат TFLite Edge TPU полезно разобраться, где их обычно используют.

TFLite Edge TPU предлагает различные варианты развертывания моделей машинного обучения, в том числе:

  • Развертывание на устройстве: модели TensorFlow Edge TPU можно напрямую развертывать на мобильных и встраиваемых устройствах. При развертывании на устройстве модели выполняются непосредственно на аппаратном обеспечении, поэтому подключение к облаку не требуется. Модель можно встроить в пакет приложения или загружать по запросу.

  • Гибридное развертывание: гибридный подход сочетает развертывание на устройстве и в облаке, предлагая универсальное и масштабируемое решение для развертывания моделей машинного обучения. Среди преимуществ — обработка на устройстве для быстрого ответа и облачные вычисления для более сложных вычислений.

Поддерживаемые задачи#

Экспорт на Edge TPU поддерживает шесть из семи задач Ultralytics. Семантическая сегментация доступна только в YOLO26 — единственном семействе, в котором есть соответствующая голова. Оценка глубины не поддерживается, поскольку INT8-модель генерирует оператор v2 EXP, который компилятор Edge TPU не может обработать.

ЗадачаYOLOv8YOLO11YOLO26
Обнаружение✅✅✅
Сегментация✅✅✅
Семантическая сегментация❌❌✅
Глубина❌❌❌
Классификация✅✅✅
Оценка позы✅✅✅
OBB✅✅✅

Компилятор Edge TPU сопоставляет поддерживаемые операции с ускорителем, а остальные оставляет для CPU, поэтому поддержка задачи не означает, что все операции выполняются на TPU.

Экспорт моделей YOLO26 в TFLite Edge TPU#

Преобразуя модели YOLO26 в TensorFlow Edge TPU, ты можешь расширить совместимость моделей и гибкость их развертывания.

Установка#

Чтобы установить необходимый пакет, выполни команду:

Установка
# Install the required package for YOLO26
pip install ultralytics

Подробные инструкции и рекомендации по установке смотри в руководстве по установке Ultralytics. Если при установке пакетов, необходимых для YOLO26, возникнут сложности, решения и советы найдешь в руководстве по распространенным проблемам.

Использование#

Все модели Ultralytics YOLO26 изначально поддерживают экспорт, поэтому их легко интегрировать в предпочтительный процесс развёртывания. Чтобы выбрать оптимальную конфигурацию для своего приложения, посмотри полный список поддерживаемых форматов экспорта и параметров конфигурации.

Формат TFLite Edge TPU поддерживает режимы экспорта, предсказания и валидации. Инференс и валидация выполняются на оборудовании Coral Edge TPU. Экспортируй модель, а затем загрузи экспортированную модель, чтобы запустить инференс или проверить точность.

Экспорт
from ultralytics import YOLO

# Загрузи модель YOLO26
model = YOLO("yolo26n.pt")

# Экспорт модели в формат TFLite Edge TPU
model.export(format="edgetpu")  # создает 'yolo26n_saved_model/yolo26n_full_integer_quant_edgetpu.tflite'
Предсказание
from ultralytics import YOLO

# Загрузка экспортированной модели TFLite Edge TPU
model = YOLO("yolo26n_saved_model/yolo26n_full_integer_quant_edgetpu.tflite")

# Выполнить инференс
results = model("https://ultralytics.com/images/bus.jpg")
Проверка
from ultralytics import YOLO

# Загрузка экспортированной модели TFLite Edge TPU
model = YOLO("yolo26n_saved_model/yolo26n_full_integer_quant_edgetpu.tflite")

# Проверить точность на наборе данных COCO8
metrics = model.val(data="coco8.yaml")

Аргументы экспорта#

АргументТипПо умолчаниюОписание
formatstr'edgetpu'Целевой формат экспортируемой модели, определяющий совместимость с различными средами развертывания.
imgszint или tuple640Заданный размер изображения на входе модели. Можно указать целое число для квадратных изображений или кортеж (height, width) для конкретных размеров.
quantizeint или str8/автоТочность квантования. Для Edge TPU требуется 8 (INT8); этот режим включается автоматически, сжимая модель и ускоряя инференс на периферийных устройствах с минимальной потерей точности. Заменяет устаревшие флаги half/int8.
opsetintNoneЗадаёт версию ONNX opset для промежуточного графа ONNX. Если параметр не задан, используется opset 18 (более низкий для PyTorch < 2.4), но не выше установленной версии onnx.
datastrNoneПуть к YAML-файлу набора данных, необходимому для квантования; для классификации вместо него укажи каталог набора данных или название встроенного набора данных. Если не указать этот параметр вместе с quantize=8, Ultralytics выберет набор данных для калибровки по умолчанию для соответствующей задачи модели.
fractionfloat, int или list1.0Подмножество для калибровки, заданное как доля, количество изображений или [train, val, test] отношения/количества. Если список содержит два элемента, test остаётся без изменений, а 0 пропускает его.
devicestrNoneЗадает устройство для экспорта: CPU (device=cpu).
Совет

Для экспорта в Edge TPU используй компьютер с Linux и архитектурой x86.

Подробнее о процессе экспорта смотри на странице документации Ultralytics об экспорте.

Развертывание экспортированных моделей YOLO26 TFLite Edge TPU#

После успешного экспорта моделей Ultralytics YOLO26 в формат TFLite Edge TPU их можно развернуть. Основной и рекомендуемый первый шаг для запуска модели TFLite Edge TPU — использовать метод YOLO("model_edgetpu.tflite"), описанный в предыдущем примере кода.

Подробные инструкции по развертыванию моделей TFLite Edge TPU смотри в следующих материалах:

  • Coral Edge TPU на Raspberry Pi с Ultralytics YOLO26: узнай, как интегрировать Coral Edge TPU с Raspberry Pi, чтобы расширить возможности машинного обучения.

  • Компилятор Edge TPU: узнай, как компилятор Edge TPU преобразует модели TensorFlow Lite для работы на ускорителе и какие операции он поддерживает.

  • Запуск инференса на Edge TPU с Python: узнай, как использовать TensorFlow Lite Python API в приложениях для Edge TPU, включая инструкции по настройке и применению.

Итоги#

В этом руководстве мы рассмотрели экспорт моделей Ultralytics YOLO26 в формат TFLite Edge TPU. Следуя приведенным выше инструкциям, ты сможешь запускать приложения компьютерного зрения на периферийных устройствах быстрее и с меньшим энергопотреблением.

Дополнительную информацию об использовании смотри на официальном сайте Coral Edge TPU.

Часто задаваемые вопросы#

  • Чтобы экспортировать модель YOLO26 в формат TFLite Edge TPU, выполни следующие действия:

    Использование
    from ultralytics import YOLO

# Загрузи модель YOLO26
model = YOLO("yolo26n.pt")

# Экспорт модели в формат TFLite Edge TPU
model.export(format="edgetpu")  # создает 'yolo26n_saved_model/yolo26n_full_integer_quant_edgetpu.tflite'

# Загрузка экспортированной модели TFLite Edge TPU
edgetpu_model = YOLO("yolo26n_saved_model/yolo26n_full_integer_quant_edgetpu.tflite")

# Выполнить инференс
results = edgetpu_model("https://ultralytics.com/images/bus.jpg")

    Полную информацию об экспорте моделей в другие форматы смотри в нашем руководстве по экспорту.

  • Экспорт моделей YOLO26 в TFLite Edge TPU дает несколько преимуществ:

    • Оптимизированная производительность: высокая скорость работы нейронных сетей при минимальном энергопотреблении.
    • Снижение задержки: быстрая локальная обработка данных без необходимости подключения к облаку.
    • Повышенная конфиденциальность: локальная обработка позволяет сохранять конфиденциальность и безопасность пользовательских данных.

    Благодаря этому формат идеально подходит для периферийных вычислений, где устройства ограничены в энергии и вычислительных ресурсах.

  • Да, модели TensorFlow Lite Edge TPU можно напрямую развертывать на мобильных и встраиваемых устройствах. При таком подходе модели выполняются непосредственно на аппаратном обеспечении, обеспечивая более быстрый и эффективный инференс. Примеры интеграции смотри в нашем руководстве по развертыванию Coral Edge TPU на Raspberry Pi.

  • К типичным сценариям использования моделей TFLite Edge TPU относятся:

    • Умные камеры: улучшение анализа изображений и видео в реальном времени.
    • Устройства IoT: автоматизация умного дома и промышленности.
    • Здравоохранение: ускорение обработки медицинских изображений и диагностики.
    • Розничная торговля: улучшение управления запасами и анализа поведения покупателей.

    Эти приложения выигрывают от высокой производительности и низкого энергопотребления моделей TFLite Edge TPU. Узнай больше о сценариях использования.

  • Если при экспорте или развертывании моделей TFLite Edge TPU возникли проблемы, воспользуйся нашим руководством «Распространенные проблемы», чтобы найти советы по их устранению. В руководстве описаны распространенные проблемы и решения, которые помогут обеспечить бесперебойную работу. За дополнительной помощью обращайся в наш центр поддержки.

Участники
GLglenn-jocher25RAraimbekovm5LAlakshanthad4FCfcakyon2AMamanharshx1ONonuralpszr1MAMatthewNoyce1RIRizwanMunawar1BUBurhan-Q1ABabirami-vina1

Комментарии30

Задай вопрос, поделись результатами или помоги кому-нибудь.

  1. faizaanscnzfaizaanscnzGitHub

    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. walissongwalissongGitHub

    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. dbrodbroGitHub

    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) ...

  5. manu13008manu13008GitHub

    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 JocherGlenn 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.

  6. Abdullah-OryAbdullah-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 JocherGlenn 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.

  7. MECHAAMERMECHAAMERGitHub

    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,

    2. MECHAAMERMECHAAMERGitHub

      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?

    4. MECHAAMERMECHAAMERGitHub

      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?

    5. Glenn JocherGlenn 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.

    6. MECHAAMERMECHAAMERGitHub

      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

    7. Glenn JocherGlenn 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.

    8. MECHAAMERMECHAAMERGitHub

      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).

    9. Glenn JocherGlenn 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.

  8. Taufiq-AhmedTaufiq-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 JocherGlenn 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!

  9. samphonicsamphonicGitHub

    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 JocherGlenn 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.

    2. Glenn JocherGlenn 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! 🚀

    4. Glenn JocherGlenn 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! 😊