Google LiteRT 내보내기

LiteRT는 Google의 온디바이스 AI 런타임이며 TensorFlow Lite(TFLite)의 새로운 이름입니다. format="litert"를 사용해 Ultralytics YOLO26 모델을 내보내면 FP32 또는 세 가지 INT8 양자화 방식 중 하나로 Android 및 iOS 휴대폰, 임베디드 Linux 보드, 웹 브라우저용 단일 .tflite 파일이 생성됩니다.

한눈에 보기#

속성세부 정보
format 인수litert. 이전 tflite 및 tfjs 값도 계속 사용할 수 있습니다. 이 값은 사용 중단 경고를 기록하고 동일한 LiteRT 파일을 내보냅니다.
출력yolo26n.tflite. 클래스 이름, 작업, 이미지 크기가 메타데이터로 파일 내부에 저장된 단일 파일입니다. 양자화된 내보내기 파일의 이름은 yolo26n_w8a32.tflite, yolo26n_int8.tflite, yolo26n_w8a16.tflite입니다.
실행 환경Android 및 iOS 기기, 임베디드 Linux 보드, 데스크톱 CPU, LiteRT.js를 통한 웹 브라우저, Intel GPU 및 NPU
런타임LiteRT: ai-edge-litert Python 패키지(2.1.4 이상), Android 및 iOS용 LiteRT 라이브러리 또는 LiteRT.js
정밀도FP32, w8a32, INT8, w8a16. YOLO26n은 FP32에서 10.0 MB, w8a32 사용 시 2.9 MB, INT8에서 3.1 MB, w8a16 사용 시 3.0 MB입니다.
내보내기 호스트Python 3.10 이상을 사용하는 Linux x86-64 또는 Apple silicon 기반 macOS입니다. 내보내기는 CPU에서 실행되며 GPU가 필요하지 않습니다.
클라우드에서 내보내기

Ultralytics Platform에서 학습된 모델을 LiteRT로 내보낼 수 있으므로 로컬 내보내기 환경이 필요하지 않습니다.

빠른 시작#

LiteRT 내보내기 종속 항목과 함께 Ultralytics 패키지를 설치합니다:

pip install "ultralytics[export-litert]"

이 명령은 litert-torch, ai-edge-litert, ai-edge-quantizer를 설치합니다. 일반 pip install ultralytics 환경에서는 첫 내보내기 시 누락된 패키지가 설치되며, 이 과정에서 PyTorch가 대체되면 오류와 함께 중단될 수 있습니다. 내보내기에는 다음 버전 요구 사항이 있습니다:

패키지필수 버전
Python3.10 이상
litert-torch0.10.0 이상
torch설치된 litert-torch에서 허용하는 범위: 0.10.0의 경우 2.4.0 이상, 2.15.0 미만
ai-edge-litert내보내기에는 2.3.0 이상이 필요합니다. 내보낸 모델을 실행하려면 Python 3.10 이상에서 2.1.4 이상이 필요합니다.
ai-edge-quantizerquantize="w8a32", quantize=8, "w8a16"에는 0.10.0 이상이 필요합니다.

다른 설치 방법은 설치 가이드를 참조하세요. 그런 다음 모델을 내보내고 내보낸 파일을 로드하여 추론을 실행하거나 정확도를 검증합니다.

내보내기
from ultralytics import YOLO

# YOLO26 모델 로드
model = YOLO("yolo26n.pt")

# 모델을 LiteRT 형식으로 내보내기
model.export(format="litert")  # 'yolo26n.tflite'를 생성합니다.

# INT8 가중치와 FP32 활성화를 사용해 내보냅니다. 보정 데이터는 필요하지 않습니다.
model.export(format="litert", quantize="w8a32")  # 'yolo26n_w8a32.tflite' 생성
예측
from ultralytics import YOLO

# 내보낸 LiteRT 모델 로드
model = YOLO("yolo26n.tflite")

# 추론 실행
results = model("https://ultralytics.com/images/bus.jpg")
검증
from ultralytics import YOLO

# 내보낸 LiteRT 모델 로드
model = YOLO("yolo26n.tflite")

# COCO8 데이터셋에서 정확도 검증
metrics = model.val(data="coco8.yaml")

지원 작업#

LiteRT 내보내기는 YOLOv8, YOLO11, YOLO26 모델에서 Ultralytics의 7가지 작업(탐지, 분할, 시맨틱 분할, 깊이 추정, 분류, 포즈 추정, OBB)을 모두 지원합니다. 시맨틱 분할과 깊이 추정은 해당 헤드를 제공하는 유일한 모델 계열인 YOLO26에서만 사용할 수 있습니다.

내보내기 인수#

인수유형기본값설명
formatstr'litert'내보낸 모델의 대상 형식으로, 다양한 배포 환경과의 호환성을 정의합니다.
imgszint 또는 tuple640모델 입력 이미지 크기입니다. 정사각형 이미지에는 정수를 사용하고, 그 외에는 튜플 (height, width)을 사용합니다. 이 값을 전달하지 않으면 내보내기에 체크포인트의 학습 이미지 크기가 사용됩니다. 공식 YOLO26 체크포인트는 detect, segment, pose 모델과 ADE20K로 사전 학습된 semantic 모델에 640, OBB 모델과 Cityscapes로 사전 학습된 semantic 모델에 1024, depth 모델에 768, classify 모델에 224를 사용합니다.
quantizeint 또는 strNone양자화 방식: 'w8a32'(INT8 가중치, FP32 활성화, 보정 불필요), 8(INT8 가중치 및 활성화, data로 보정), 또는 'w8a16'(INT8 가중치, INT16 활성화, data로 보정)입니다. 32/미설정은 FP32입니다. 16을 사용하면 오류가 발생하며, quantize=8로 학습된 체크포인트는 LiteRT로 내보낼 수 없습니다. 제한 사항 및 문제 해결을 참조하세요. 사용 중단된 half/int8 플래그를 대체합니다.
datastrNonequantize=8 및 'w8a16'로 보정할 때 사용하는 데이터셋 YAML입니다. 분류 작업에는 대신 데이터셋 디렉터리 또는 기본 제공 데이터셋 이름을 지정합니다. split을 설정하지 않으면 보정에는 val 분할을 사용합니다. 생략하면 Ultralytics는 모델 작업에 해당하는 소규모 기본 데이터셋을 사용합니다. 예를 들어 탐지에는 coco8.yaml를 사용합니다.
fractionfloat, int 또는 list1.0보정 하위 집합: 비율, 이미지 개수(1보다 큰 정수) 또는 [train, val, test] 목록을 지정할 수 있으며, 이 경우 보정 분할에 해당하는 항목이 사용됩니다.
nmsbool, 선택 사항None원시 출력(None, 기본값) 또는 NMS가 없는 헤드(False, FP32 및 'w8a32' 내보내기만 해당)를 선택합니다. LiteRT에서는 내장 NMS(True)를 사용할 수 없습니다. 출력 형식을 참조하세요.
batchint1내보낸 모델의 배치 크기이며 입력 형상에 고정됩니다. 보정에 사용되는 배치 크기이기도 합니다.
devicestrNone전달된 값과 관계없이 내보내기는 항상 CPU에서 실행됩니다.

모든 형식에 공통으로 적용되는 인수는 내보내기 모드 문서를 참조하세요.

공식 모바일 및 웹 모델의 이미지 크기

공식 LiteRT, Core ML, QNN 모바일 모델은 imgsz=640 크기로 내보내며, 분류 모델은 imgsz=224 크기로 내보냅니다. Cityscapes 시맨틱, 깊이, OBB 체크포인트는 기본적으로 더 큰 크기로 내보내므로 imgsz=640를 전달해 크기를 맞추세요.

양자화#

quantize은 세 가지 INT8 방식 중 하나를 선택합니다. 세 방식 모두 가중치를 8비트 정수로 저장하며, 레이어 사이를 전달하는 값인 활성화를 저장하는 방식에서 차이가 있습니다:

quantize가중치활성화보정 데이터YOLO26n 파일크기
설정 해제 또는 32FP32FP32아니요yolo26n.tflite10.0 MB
'w8a32'INT8FP32아니요yolo26n_w8a32.tflite2.9 MB
8INT8INT8예yolo26n_int8.tflite3.1 MB
'w8a16'INT8INT16예yolo26n_w8a16.tflite3.0 MB
  • 입력 및 출력: 네 가지 정밀도 모두 입력과 출력은 float32으로 유지되므로 FP32 모델용으로 작성된 추론 코드는 동일한 nms 레이아웃으로 내보낸 양자화 모델에서도 변경 없이 실행됩니다.
  • 'w8a32': 동적 범위 양자화입니다. 보정 데이터가 필요하지 않으며 nms=False와 함께 NMS가 없는 헤드를 지원합니다. 또한 성능 측정 결과의 CPU 및 GPU 열에 표시된 공식 모바일 모델의 정밀도입니다.
  • 8 및 'w8a16': 정적 양자화입니다. 내보내기는 data의 val 분할 또는 split로 지정한 분할에서 각 전체 배치를 보정에 사용하며, 이미지가 300장 미만이면 경고합니다. 이미지 수를 제한하려면 fraction를 사용하세요.
  • 헤드 출력과 quantize=8: detect, segment, classify, pose 및 OBB 모델의 경우, INT8은 클래스 점수를 클리핑하고 박스 좌표를 거칠게 양자화하므로 헤드의 출력 레이어와 해당 출력을 디코딩하는 연산은 부동 소수점으로 유지됩니다. 'w8a16'은 이러한 레이어도 양자화하며, 활성화 값은 16비트로 처리됩니다.
  • NMS가 없는 헤드: YOLO26 또는 YOLOv10 모델의 quantize=8 및 'w8a16' 내보내기는 one-to-many 헤드를 사용하며 NMS가 필요한 원시 예측값을 반환합니다. nms=False를 사용하는 경우에도 마찬가지입니다.
  • FP16: FP16 내보내기는 없습니다. LiteRT GPU delegate는 기본적으로 FP32 모델을 반정밀도로 실행하므로 quantize=16은 필요하지 않으며 지정하면 오류가 발생합니다.
예제
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# COCO 검증 이미지의 10%(이미지 500개)로 보정합니다. coco.yaml을 자체 데이터셋으로 바꾸세요.
model.export(format="litert", quantize=8, data="coco.yaml", fraction=0.1)  # 'yolo26n_int8.tflite' 생성

# 내보낸 INT8 모델을 로드하고 추론을 실행합니다
model = YOLO("yolo26n_int8.tflite")
results = model("https://ultralytics.com/images/bus.jpg")

양자화는 정확도에 영향을 미치며, 그 영향은 모델, 작업, 보정 이미지에 따라 다릅니다. 배포하기 전에 자체 데이터로 양자화된 모델을 검증하세요.

출력 형식#

내보내기는 단일 .tflite 파일을 생성합니다. 모델은 (batch, 3, height, width) 형상의 입력 하나를 받습니다. 입력은 RGB, 채널 우선(NCHW), float32이며 값은 0~1로 정규화됩니다. 이는 채널 후순위(NHWC) 이미지를 입력으로 받았던 이전 format="tflite" 내보내기의 TFLite 파일과 다릅니다. nms 인수와 작업에 따라 출력이 결정됩니다. 아래 형상은 기본 내보내기 크기를 사용하는 공식 YOLO26n 체크포인트 기준이며, 시맨틱 분할에는 Cityscapes 체크포인트 yolo26n-sem.pt를 사용합니다:

작업기본 imgsznms=None을 사용한 출력nms=False을 사용한 출력
감지640(1, 84, 8400)(1, 300, 6)
분할640(1, 116, 8400) 및 (1, 32, 160, 160)(1, 300, 38) 및 (1, 32, 160, 160)
의미론적1024(1, 19, 1024, 1024): 클래스와 픽셀마다 점수 하나씩 출력합니다.nms=None과 동일합니다
깊이768(1, 1, 768, 768): 깊이 맵nms=None과 동일합니다
분류224(1, 1000): 클래스 확률nms=None과 동일합니다
포즈640(1, 56, 8400)(1, 300, 57): 박스 값 6개, 이어서 키포인트 17개 x 3
OBB1024(1, 20, 21504)(1, 300, 7): 박스 값 4개, 점수, 클래스, 각도
  • 원시 출력(nms=None): 형상은 (batch, values, anchors)입니다. 각 앵커에 대해 박스 중심 x, 중심 y, 너비, 높이, 클래스 점수, 작업 값(마스크 계수 32개, 키포인트 값 17개 x 3 또는 OBB 각도(라디안))이 순서대로 표시됩니다. 박스 값과 키포인트 x 및 y는 0~1로 정규화되므로 입력 너비와 높이를 곱하세요. NMS를 직접 적용해야 합니다.
  • NMS가 없는 출력(nms=False): 입력 픽셀 단위의 x1, y1, x2, y2, score, class 행이 max_det개(기본값 300) 반환되며 NMS 단계는 없습니다. OBB 행은 center x, center y, width, height, score, class, angle이며 각도는 라디안입니다. 점수에 따라 행을 필터링하세요. NMS가 없는 헤드를 사용하는 모델의 FP32 및 'w8a32' 내보내기에서 사용할 수 있습니다.
  • 분할: 32개의 마스크 계수는 각 앵커 또는 행의 마지막 32개 값이며, 두 번째 출력에는 마스크 프로토타입이 들어 있습니다.
  • 시맨틱 분할: 출력에는 ONNX 내보내기의 클래스 맵이 아니라 클래스 점수가 들어 있으므로 자체 코드에서 클래스 축을 따라 argmax를 계산하세요.

YOLO("yolo26n.tflite")은 파일 메타데이터에서 레이아웃을 읽고 좌표를 스케일링하므로 자체 코드로 모델을 실행할 때만 이러한 세부 정보를 알아야 합니다. 메타데이터는 내보내기가 ZIP 아카이브로 파일에 추가하는 metadata.json 항목이며, ZIP 라이브러리로 읽을 수 있습니다. 키에는 names, task, imgsz, stride, batch, end2end, args이 포함되며, 포즈 모델에는 kpt_shape도 포함됩니다.

LiteRT Interpreter로 실행#

Ultralytics 패키지 외부에서 모델을 실행하려면 ai-edge-litert 패키지의 interpreter로 모델을 로드하세요. 텐서 이름에 의존하지 말고 모델에서 입력 및 출력 형상을 읽으세요. 분할 모델에는 출력이 두 개 있습니다. 3차원 출력에는 탐지 결과가, 4차원 출력에는 마스크 프로토타입이 들어 있습니다.

# 먼저 내보냅니다: yolo export model=yolo26n.pt format=litert nms=False
import json
import zipfile

import numpy as np
from ai_edge_litert.interpreter import Interpreter

interpreter = Interpreter(model_path="yolo26n.tflite")
interpreter.allocate_tensors()

image = np.zeros((1, 3, 640, 640), dtype=np.float32)  # 사전 처리된 이미지: RGB, NCHW, 0-1
interpreter.set_tensor(interpreter.get_input_details()[0]["index"], image)
interpreter.invoke()
detections = interpreter.get_tensor(interpreter.get_output_details()[0]["index"])[0]  # shape (300, 6)
assert detections.shape == (300, 6), "export the model with nms=False"
detections = detections[detections[:, 4] > 0.25]  # 신뢰도 임계값보다 높은 행 유지

with zipfile.ZipFile("yolo26n.tflite") as z:
    names = json.loads(z.read("metadata.json"))["names"]  # {'0': 'person', '1': 'bicycle', ...}

배포#

YOLO("yolo26n.tflite")은 CPU에서 ai-edge-litert interpreter를 사용해 최대 8개 스레드로 모델을 실행합니다. 0 또는 mps와 같은 다른 device 값도 CPU에서 실행되며, xpu 및 npu은 Intel 하드웨어를 선택합니다. 추론 장치 표에서 형식별 이름을 비교할 수 있습니다.

모델은 항상 내보내기 시점의 imgsz 및 batch로 실행되며, Ultralytics는 파일 메타데이터에서 해당 값을 읽습니다. predict 또는 val에 전달된 imgsz는 무시됩니다. 더 큰 배치는 내보내기 배치 크기의 청크로 나뉘고, 더 작은 배치는 패딩되므로 이미지 개수에 관계없이 처리할 수 있습니다.

Intel GPU 및 NPU 추론#

내보낸 .tflite 모델은 LiteRT Intel OpenVINO 플러그인을 통해 Intel 하드웨어에서 실행됩니다. GPU에는 device=xpu, NPU에는 device=npu을 전달하세요. 처음 사용할 때 Ultralytics가 ai-edge-litert>=2.3.0와 ai-edge-litert-sdk-intel를 설치합니다. 플러그인은 자체 openvino 버전에 종속되므로, 다른 버전의 OpenVINO 모델도 실행한다면 별도의 환경을 사용하세요. NPU를 사용하려면 Intel NPU 드라이버가 설치된 Intel Core Ultra 프로세서가 필요합니다. Core Ultra X7 358H에서 측정한 지연 시간을 참조하세요. 요청한 Intel 장치가 없는 컴퓨터에서는 OpenVINO 플러그인이 모델 컴파일에 실패하고 LiteRT는 OpenVINO가 아닌 자체 CPU 백엔드(XNNPACK)에서 모델을 실행합니다. AMD 서버 CPU에서 YOLO26n은 device=xpu 및 device=npu을 사용했을 때 이미지당 29~30ms가 걸렸으며, device=cpu를 사용했을 때는 18ms가 걸렸습니다. 이 경우 Ultralytics는 경고를 기록하지 않으므로, 장치가 사용 중인지 확인하려면 device=cpu으로 지연 시간을 비교하세요.

예측
from ultralytics import YOLO

model = YOLO("yolo26n.tflite")
results = model("https://ultralytics.com/images/bus.jpg", device="npu")  # 또는 "xpu"

배포 가이드#

제한 사항 및 문제 해결#

  • 내보내기 호스트: Windows 및 Raspberry Pi와 같은 Linux ARM64에서는 LiteRT export only supported on Linux x86 and macOS으로 인해 내보내기가 실패합니다. 지원되는 호스트에서 내보낸 다음 .tflite 파일을 기기로 복사하세요.
  • 일반 설치 후 첫 내보내기: 첫 내보내기에서 설치된 PyTorch 버전을 지원하지 않는 litert-torch이 설치되면(0.10.0은 2.4.0 이상, 2.15.0 미만 버전을 지원), pip가 PyTorch를 대체하고 Ultralytics는 Restart runtime or rerun command for updates to take effect을 기록합니다. 이 내보내기는 PyTorch 2.15.0에서 RuntimeError: duplicate registrations for aten.miopen_batch_norm.default와 함께 실패할 수 있습니다. 내보내기를 다시 실행하세요.
  • FP16: quantize=16은 quantize=16 (FP16) is not supported; format='litert' supports quantize=8 (INT8), 'w8a16' (INT8 weights + INT16 activations), 'w8a32' (dynamic INT8), 32 or None (FP32).로 인해 실패합니다. FP32로 내보낸 다음 GPU delegate가 반정밀도로 실행하도록 하세요.
  • quantize=8으로 학습한 체크포인트: 양자화 인식 학습으로 미세 조정한 체크포인트는 format='litert' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends로 내보내면 실패합니다. 대신 quantize=8을 사용해 미세 조정의 기반이 된 체크포인트를 내보내거나, 미세 조정한 체크포인트를 ONNX 또는 TensorRT로 내보내세요.
  • quantize=8 또는 'w8a16'을 사용하는 NMS가 없는 헤드: nms=False를 사용하면 내보내기에서 LiteRT INT8 export does not support end2end models, disabling end2end branch.을 기록하고 NMS가 필요한 원시 예측값을 기록합니다. NMS가 없는 헤드를 유지하려면 FP32 또는 'w8a32'를 사용하세요.
  • 내장 NMS: nms=True은 format=litert does not support embedded NMS; exporting native outputs for external NMS.을 기록하고 원시 출력을 기록합니다.
  • 다른 모델의 NMS가 없는 헤드: nms=False에는 YOLO26 또는 YOLOv10과 같이 NMS가 없는 헤드를 갖춘 모델이 필요합니다. 예를 들어 YOLO11 등 다른 모델에서는 내보내기 시 This model has no one-to-one head; using one-to-many outputs. 경고가 표시되고 원시 (1, 84, 8400) 출력이 기록됩니다.
  • 고정 입력 형태: dynamic=True은 argument 'dynamic' is not supported for format='litert' 오류와 함께 실패합니다. 이미지 크기나 배치 크기를 변경하려면 다시 내보내세요.
  • data 없이 보정하기: quantize=8 또는 'w8a16' 내보내기는 INT8 export requires a missing 'data' arg for calibration. Using default 'data=coco8.yaml'.을 기록하고 작업의 소규모 기본 데이터셋으로 보정합니다. 배포 데이터를 대표하는 이미지를 사용해 data를 전달하세요.
  • 보정 데이터 크기: 보정 분할에 이미지가 300장 미만이면 내보내기에서 >300 images recommended for INT8 calibration, found 4 images.을 기록합니다. coco8.yaml에는 검증 이미지가 4장뿐이므로 내보내기 테스트에는 충분하지만 배포용 모델을 보정하기에는 부족합니다.
  • x86 CPU에서 'w8a16' 사용: LiteRT CPU interpreter는 8개 스레드를 사용하는 AMD EPYC 9655 서버 CPU에서 YOLO26n 'w8a16' 모델을 이미지당 약 1초에 실행했습니다. FP32 모델은 약 17ms가 걸렸습니다. 배포할 장치와 delegate에서 'w8a16'를 측정하세요.
  • 파일 이름: 동일한 체크포인트를 같은 quantize 값으로 내보낼 때마다 동일한 파일을 기록합니다. 예를 들어 FP32의 경우 yolo26n.tflite이 생성되며, imgsz, batch, nms 값과 관계없이 이후 내보내기가 이전 파일을 대체합니다.

그 밖의 오류는 일반적인 문제 가이드를 참조하세요.

측정 성능#

아래 표는 각 작업의 YOLO26n 모델이 Android 휴대폰 4종과 Intel Core Ultra 프로세서에서 이미지 1개를 처리하는 데 걸리는 지연 시간을 보여 줍니다. 각 셀에는 총 시간이 밀리초 단위로 표시되고 그 아래에 전처리/추론/후처리 시간이 나뉘어 표시됩니다. 각 모델에서 가장 빠른 열은 굵게 표시됩니다. PyTorch 체크포인트의 정확도는 YOLO26 모델 페이지에서 확인할 수 있습니다.

Xiaomi 17#

하드웨어: 메모리 12 GB 및 Android 17 / API 37을 탑재한 Xiaomi 17입니다. 3 nm Snapdragon 8 Elite Gen 5(SM8850)는 8코어 Qualcomm Oryon CPU(최대 4.6 GHz의 Prime 코어 2개 및 최대 3.62 GHz의 성능 코어 6개), Adreno GPU, Hexagon NPU로 구성됩니다.

모델작업크기
(픽셀)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT FP32
(ms)
YOLO26n감지64036.9
1.9 / 32.6 / 2.3
10.6
1.8 / 6.2 / 2.6
10.1
3.5 / 4.0 / 2.5
YOLO26n-seg분할64050.5
1.9 / 42.9 / 5.8
18.0
1.9 / 9.5 / 6.6
19.2
3.6 / 5.9 / 9.7
YOLO26n-sem의미론적64045.7
1.9 / 35.7 / 8.2
30.6
1.9 / 20.5 / 8.3
25.8
3.6 / 11.0 / 11.3
YOLO26n-depth깊이64066.8
2.2 / 55.0 / 9.7
21.9
2.1 / 10.1 / 9.8
24.8
4.3 / 6.0 / 14.5
YOLO26n-cls분류2243.6
0.3 / 3.3 / 0.0
2.0
0.4 / 1.4 / 0.2
1.5
0.6 / 0.7 / 0.3
YOLO26n-pose포즈64039.9
2.0 / 36.5 / 1.4
10.0
1.8 / 6.7 / 1.4
11.5
3.5 / 4.2 / 3.8
YOLO26n-obbOBB64036.3
2.0 / 33.2 / 1.2
10.1
2.6 / 5.9 / 1.6
8.2
3.5 / 3.7 / 0.9
  • 속도 값은 단일 이미지 버스트 지연 시간입니다. bus.jpg에서 3회 워밍업 후 15회 실행한 평균이며, Ultralytics Flutter 플러그인 0.7.1와 공식 v0.7.0 에셋(Ultralytics 8.4.188 내보내기)을 사용해 측정했습니다. 하나의 순차 스윕에서 작업 간 CPU/GPU 순서를 번갈아 적용했습니다. 네이티브 로그를 통해 모든 CPU 행이 LiteRT CPU/XNNPACK을 사용하고 모든 GPU 행이 전체 그래프를 LiteRT OpenCL(LITERT_CL)에 위임했음을 확인했습니다.
  • LiteRT 내보내기는 PyTorch 모델을 직접 추적하여 float 입력을 사용하는 NCHW .tflite을 생성합니다. GPU delegate는 전체 그래프를 컴파일하며(여기서는 7개 작업 모두 Adreno GPU에서 실행됨), w8a32에는 보정 데이터가 필요하지 않습니다. 기존 onnx2tf NHWC 레이아웃이나 Identity 출력 이름을 가정하지 말고 텐서 shape와 시그니처 이름을 확인해야 합니다. RGB 데이터는 평면형 CHW 형식으로 바로 패킹하거나 추론 전에 전치합니다. 시맨틱 내보내기는 NCHW 로짓을 반환하므로 호스트 측에서 클래스 argmax를 수행해야 합니다. 공식 Android 에셋은 yolo-flutter-app v0.7.0 릴리스에서 호스팅되며, 자세한 벤치마크 기록은 Flutter 성능 문서에서 확인할 수 있습니다.
  • NPU 열은 LiteRT 자체의 NPU 경로입니다. FP32 내보내기(yolo export format=litert, quantize 없음)를 litert-npu-runtime-qualcomm 및 -mediatek 2.3.0 런타임이 기기에서 컴파일했으며, Flutter 플러그인의 프로토타입 NPU 빌드(아직 출시되지 않음)로 측정했습니다. 최초 로드 시간에는 해당 컴파일 시간이 포함됩니다(n의 경우 약 0.3초, x의 경우 최대 6초). w8a32 에셋은 이 NPU에서 완전히 컴파일되지 않습니다. LiteRT는 그래프를 GPU에서 조용히 실행하는 경우에도 NPU 컴파일을 보고하므로, 모든 NPU 행을 GPU 시간과 대조해 확인했습니다. 폴백된 행은 —로 표시했습니다.
  • 공식 QNN 에셋에 대한 대응하는 Snapdragon Hexagon NPU 수치는 Qualcomm QNN 통합에서 확인할 수 있습니다.
  • Apple CPU/가속기 결과는 CoreML 통합에서 비교해 보세요.

다음 기기 스윕에서는 동일한 공식 v0.7.0 에셋을 사용합니다.

Google Pixel 10#

하드웨어: 메모리 12 GB 및 Android 17 / API 37을 탑재한 Google Pixel 10입니다. 3 nm Google Tensor G5는 8코어 CPU(최대 3.78 GHz의 Prime 코어 1개, 최대 3.05 GHz의 성능 코어 5개, 최대 2.25 GHz의 효율 코어 2개), PowerVR D-Series GPU, Google TPU로 구성됩니다. Google이 링크된 사양에 코어 클럭과 GPU 드라이버 이름을 공개하지 않아 벤치마크 기기에서 해당 정보를 확인했습니다.

모델작업크기
(픽셀)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
YOLO26n감지64036.6
1.5 / 33.5 / 1.6
36.5
3.5 / 28.4 / 4.6
YOLO26n-seg분할64053.1
1.5 / 45.8 / 5.7
51.5
1.6 / 40.1 / 9.9
YOLO26n-sem의미론적64057.2
1.5 / 47.7 / 8.0
75.9
1.8 / 63.4 / 10.8
YOLO26n-depth깊이64075.0
1.6 / 65.1 / 8.3
50.1
1.7 / 33.5 / 14.9
YOLO26n-cls분류2246.1
0.3 / 5.5 / 0.3
12.1
0.9 / 11.0 / 0.1
YOLO26n-pose포즈64035.2
1.5 / 31.9 / 1.8
38.2
3.5 / 29.3 / 5.4
YOLO26n-obbOBB64032.7
1.5 / 29.3 / 1.9
38.8
3.8 / 29.6 / 5.4

벤치마크: bus.jpg에서 3회 워밍업 후 predict()을 15회 호출한 평균이며, ultralytics_yolo 0.7.1 및 공식 v0.7.0 에셋을 사용했습니다. 하나의 순차 스윕에서 작업 간 CPU/GPU 순서를 번갈아 적용했습니다. 네이티브 로그를 통해 모든 CPU 행이 LiteRT CPU/XNNPACK을 사용하고 모든 GPU 행이 전체 그래프를 LiteRT OpenCL(LITERT_CL)에 위임했음을 확인했습니다. Tensor NPU는 LiteRT 행이 없습니다. Google의 EdgeTPU 서비스가 허용 목록에 없는 앱을 거부하며, 이 경우 LiteRT는 모델을 GPU에서 실행합니다.

Samsung Galaxy S26#

하드웨어: 메모리 12 GB 및 Android 17 / API 37을 탑재한 Samsung Galaxy S26(SM-S942B)입니다. 2 nm Exynos 2600은 10코어 Armv9.3 CPU(최대 3.8 GHz의 C1-Ultra 코어 1개, 최대 3.26 GHz의 성능 C1-Pro 코어 3개, 최대 2.76 GHz의 효율 C1-Pro 코어 6개), Xclipse 960 GPU, Samsung NPU로 구성됩니다.

모델작업크기
(픽셀)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT w8a32 AOT
(ms)
YOLO26n감지64030.2
1.3 / 27.3 / 1.6
15.9
1.4 / 11.5 / 2.9
12.2
1.3 / 8.6 / 2.2
YOLO26n-seg분할64045.6
1.3 / 39.1 / 5.2
30.5
1.3 / 23.6 / 5.6
17.0
1.4 / 9.7 / 5.8
YOLO26n-sem의미론적64038.1
1.3 / 28.6 / 8.2
26.1
1.3 / 16.8 / 7.9
28.3
1.7 / 15.1 / 11.5
YOLO26n-depth깊이64063.5
1.4 / 53.6 / 8.4
37.3
1.4 / 24.6 / 11.3
28.4
2.1 / 12.9 / 13.4
YOLO26n-cls분류2243.8
0.2 / 3.4 / 0.2
2.8
0.2 / 2.6 / 0.0
6.1
0.5 / 5.2 / 0.4
YOLO26n-pose포즈64031.1
1.3 / 28.4 / 1.4
18.4
1.6 / 13.0 / 3.8
13.5
1.8 / 9.5 / 2.2
YOLO26n-obbOBB64027.9
1.3 / 25.7 / 0.9
15.3
1.9 / 11.4 / 2.1
11.4
1.7 / 8.3 / 1.4

벤치마크: bus.jpg에서 3회 워밍업 후 predict()을 15회 호출한 평균이며, ultralytics_yolo 0.7.1 및 공식 v0.7.0 에셋을 사용했습니다. 하나의 순차 스윕에서 작업 간 CPU/GPU 순서를 번갈아 적용했습니다. 네이티브 로그를 통해 모든 CPU 행이 LiteRT CPU/XNNPACK을 사용하고 모든 GPU 행이 전체 그래프를 LiteRT OpenCL(LITERT_CL)에 위임했음을 확인했습니다. NPU 열은 Exynos 2600용으로 사전 컴파일된 w8a32 에셋(E9965)을 LiteRT의 Samsung 컴파일러 플러그인과 함께 사용합니다. Samsung은 LiteRT 2.3에 온디바이스 컴파일러를 제공하지 않으며 Google도 아직 Samsung NPU 런타임을 공개하지 않았으므로, 이 행에서는 LiteRT 2.3 소스로 빌드한 디스패치 라이브러리를 사용했습니다.

Xiaomi 17T Pro#

하드웨어: 12 GB LPDDR5X 메모리와 Android 16 / API 36을 탑재한 Xiaomi 17T Pro(2602EPTC0G). 3 nm MediaTek Dimensity 9500(MT6993)에는 8코어 Armv9.3 CPU(최대 4.21 GHz의 C1-Ultra 코어 1개, 최대 3.5 GHz의 C1-Premium 코어 3개, 최대 2.7 GHz의 C1-Pro 코어 4개), Mali-G1 Ultra MC12 GPU 및 MediaTek NPU 990이 탑재되어 있습니다.

모델작업크기
(픽셀)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT FP32
(ms)
YOLO26n감지64031.4
1.5 / 28.0 / 1.9
25.6
1.4 / 22.2 / 2.0
11.0
1.3 / 7.8 / 1.8
YOLO26n-seg분할64077.8
2.6 / 65.3 / 9.9
47.4
2.6 / 33.6 / 11.3
36.5
2.6 / 23.4 / 10.4
YOLO26n-sem의미론적64081.3
2.6 / 62.2 / 16.5
79.3
2.6 / 59.5 / 17.1
87.6
2.6 / 68.3 / 16.7
YOLO26n-depth깊이640111.3
3.4 / 91.1 / 16.8
55.3
2.8 / 36.3 / 16.1
—
YOLO26n-cls분류2246.3
0.5 / 5.4 / 0.4
8.1
0.5 / 7.5 / 0.1
3.2
0.5 / 2.2 / 0.5
YOLO26n-pose포즈64053.9
2.6 / 49.5 / 1.8
32.8
2.7 / 26.7 / 3.4
16.2
2.9 / 11.1 / 2.3
YOLO26n-obbOBB64049.5
2.7 / 44.4 / 2.4
29.4
2.8 / 22.7 / 3.9
—

벤치마크: bus.jpg에서 ultralytics_yolo 0.7.1 및 공식 v0.7.0 에셋을 사용해 predict() 호출을 3회 워밍업한 후 15회 측정한 평균입니다. 하나의 순차 스윕에서 작업마다 CPU/GPU 순서를 번갈아 적용했습니다. 네이티브 로그를 통해 모든 CPU 행은 LiteRT CPU/XNNPACK을 사용하고, 모든 GPU 행은 전체 그래프를 LiteRT OpenCL(LITERT_CL)에 위임한 것을 확인했습니다. Depth 및 OBB는 NPU 결과가 없습니다. MediaTek NPU 컴파일러가 해당 작업의 지수 및 삼각 함수 연산을 거부하며, LiteRT는 해당 그래프를 GPU에서 실행합니다.

Android 배포 워크플로와 NPU 제한 사항은 MediaTek Dimensity 가이드를 참조하세요.

Intel Core Ultra X7 358H#

하드웨어: Intel Core Ultra X7 358H (Panther Lake) 및 Intel AI Boost NPU 5010, Fedora Linux, NPU 드라이버 1.38.0, ai-edge-litert 2.3.0.

모델작업크기
(픽셀)
CPU
w8a32 LiteRT
(ms)
CPU
w8a32 Intel
(ms)
NPU
w8a32 Intel
(ms)
YOLO26n감지64017.5
0.8 / 16.1 / 0.6
22.6
1.2 / 20.6 / 0.8
4.8
1.0 / 3.3 / 0.4
YOLO26n-seg분할64024.2
0.9 / 22.1 / 1.3
32.6
1.0 / 30.1 / 1.5
6.2
0.8 / 4.2 / 1.2
YOLO26n-sem의미론적64025.2
1.0 / 14.2 / 10.0
33.1
1.1 / 21.9 / 10.2
16.5
1.0 / 5.5 / 10.0
YOLO26n-depth깊이64031.7
0.9 / 30.2 / 0.5
76.6
0.9 / 75.2 / 0.5
9.1
1.0 / 7.5 / 0.5
YOLO26n-cls분류2244.6
2.8 / 1.7 / 0.0
7.3
3.3 / 3.9 / 0.0
4.1
3.2 / 0.9 / 0.0
YOLO26n-pose포즈64020.3
0.8 / 19.0 / 0.5
28.6
1.1 / 26.8 / 0.8
6.3
0.8 / 4.9 / 0.5
YOLO26n-obbOBB64017.2
0.8 / 16.1 / 0.3
22.1
1.2 / 20.5 / 0.4
4.6
0.9 / 3.4 / 0.3

벤치마크: bus.jpg에서 ultralytics 8.4.174 및 ai-edge-litert 2.3.0을 사용하고 w8a32 내보내기를 적용해, 워밍업 3회 후 predict() 호출 15회의 평균을 계산했습니다. 각 셀에는 총 시간이 표시되며, 아래에 전처리 / 추론 / 후처리 시간이 구분되어 있습니다.

LiteRT 소개#

LiteRT는 Lite Runtime의 약칭으로, 이름만 바뀐 TensorFlow Lite이며 동일한 .tflite 모델 형식을 실행합니다. CPU에서는 XNNPACK을 사용하고 GPU 및 NPU에서는 하드웨어 delegate를 통해 모델을 실행합니다. LiteRT.js는 동일한 파일을 브라우저 및 Node.js에서 사용할 수 있게 합니다. 전체 참조 문서는 LiteRT 문서를 참조하세요.

LiteRT edge deployment framework



시청: Ultralytics YOLO26을 Google LiteRT로 내보내는 방법 | Android 및 iOS에 Vision AI 배포하기 | 모바일 AI 📱🚀

자주 묻는 질문#

  • LiteRT는 TensorFlow Lite의 새 이름이며 동일한 .tflite 모델 형식을 사용합니다. Ultralytics에서 format="litert"은 이전 내보내기 형식 두 가지를 대체합니다. 모바일, 임베디드 및 엣지 기기용 tflite와 브라우저 및 Node.js용 tfjs입니다. 이제 LiteRT.js는 동일한 .tflite 파일을 실행합니다. 이전 두 값은 모두 사용 중단 경고와 함께 LiteRT 파일을 계속 내보냅니다. 이전 형식에 대한 설명은 TFLite 및 TF.js 페이지를 참조하세요.

  • 먼저 quantize="w8a32"을 사용해 보세요. 보정 데이터가 필요하지 않고 파일 크기가 FP32의 3분의 1 미만이며, YOLO26의 NMS가 없는 헤드를 nms=False과 함께 지원합니다. 또한 CPU 및 GPU용 공식 Ultralytics 모바일 모델의 정밀도입니다. 대상 장치에 정수 활성화가 필요하면 quantize=8를 사용하세요. 예를 들어 NXP i.MX95 내보내기는 보정된 INT8 LiteRT 모델을 컴파일합니다. 'w8a16'는 8보다 활성화 정밀도를 더 높게 유지합니다. 두 방식 모두 대표성 있는 보정 데이터가 필요하며 NMS가 필요한 원시 예측값을 반환합니다. 각 방식의 지원 여부는 CPU, GPU, NPU delegate마다 다르므로 선택하기 전에 대상 장치에서 지연 시간과 정확도를 측정하세요.

  • 아니요. 내보내기는 Linux x86-64와 Apple silicon 기반 macOS에서만 실행됩니다. 이러한 호스트 중 하나 또는 Ultralytics Platform에서 모델을 내보낸 다음 .tflite 파일을 기기로 복사하세요. 보드에서 모델을 실행하는 방법은 Raspberry Pi 가이드를 참조하세요. Coral Edge TPU로 추론을 가속할 수 있습니다.

  • 예. LiteRT.js는 내보낸 .tflite 파일을 WebGPU 또는 WASM을 사용해 브라우저나 Node.js에서 실행하므로 브라우저용으로 별도 내보내기를 할 필요가 없습니다. @ultralytics/yolo npm 패키지는 이를 래핑해 detect, segment, semantic, classify, pose, OBB 작업의 웹캠 및 단일 이미지 추론을 지원합니다.

  • Android에서 LiteRT .tflite 내보내기를 로드하고 YOLO26의 7가지 작업을 모두 지원하는 Ultralytics YOLO Flutter 플러그인을 사용하세요. 공식 모델과 크기를 맞추려면 imgsz=640로 내보내고, 분류의 경우 imgsz=224으로 내보내세요. 네이티브 앱에서는 LiteRT Android 가이드를 따르고 출력 형식에 설명된 대로 모델을 입력하세요. iPhone에서는 Core ML이 네이티브 형식입니다.

댓글

질문을 하거나 결과를 공유하거나 다른 사람을 도와주세요.