YOLO26 là gì? Nhận diện vật thể bằng Python và xuất TFLite cho Android (2026)

AIAndroid

Trong bài này
  1. Cần chuẩn bị
  2. Bước 1: YOLO26 là gì và vì sao chọn nó
  3. Bước 2: Cài PyTorch bản CPU và Ultralytics
  4. Bước 3: Chạy thử một lệnh với ảnh mẫu
  5. Bước 4: Đọc kết quả bằng Python
  6. Bước 5: Thử với ảnh khó: giao thông Hà Nội ban đêm
  7. Bước 6: Chỉnh ngưỡng tin cậy conf
  8. Bước 7: Chọn cỡ model n, s hay m
  9. Bước 8: Cài gói xuất LiteRT
  10. Bước 9: Xuất YOLO26n ra file .tflite
  11. Bước 10: Kiểm tra file .tflite trước khi đưa vào app
  12. Bước 11: Đưa file .tflite vào project Android
  13. Lỗi thường gặp
  14. ImportError: libGL.so.1: cannot open shared object file
  15. Cài gói xuất LiteRT làm đổi PyTorch và venv phình to
  16. quantize=16 (FP16) is not supported
  17. Câu hỏi thường gặp
  18. Có cần GPU để học YOLO không?
  19. Muốn nhận diện vật thể không có trong 80 lớp (biển số, quả xoài…) thì sao?
  20. YOLO26 khác YOLOv8, YOLO11 thế nào?
  21. Dùng YOLO trong sản phẩm thương mại có được không?
  22. Nguồn tham khảo

YOLO26 là model nhận diện vật thể (object detection) mới nhất của Ultralytics: đưa vào một tấm ảnh, nó trả về khung bao quanh từng người, xe máy, ô tô… kèm tên và độ tin cậy. Trong bài này mình sẽ cùng các bạn chạy YOLO26 bằng Python ngay trên CPU, viết vài dòng code để đếm xe trên ảnh giao thông Hà Nội, so sánh các cỡ model, rồi xuất model ra file .tflite (LiteRT) để đưa vào app Android.

Mọi lệnh và kết quả trong bài là mình chạy thật ngày 18/11/2026 với ultralytics 8.4.215 (bản phát hành ngày 16/11/2026), Python 3.12 trên Linux, chỉ dùng CPU. Làm theo hết bài mất khoảng 30–45 phút, phần lớn là thời gian tải thư viện.

Ảnh giao thông Hà Nội có khung nhận diện người và xe máy của YOLO26n, bên cạnh là kết quả xuất file tflite
Kết quả cuối bài: YOLO26n nhận diện trên ảnh thật, rồi xuất thành file .tflite cho Android.
Video demo trên kênh Huy Nguyen - Android A - Z.

Cần chuẩn bị

  • Máy có Python 3.10 trở lên (Windows, macOS hoặc Linux). Không cần GPU. Riêng bước xuất LiteRT, trang tài liệu ghi chỉ hỗ trợ Linux x86-64 hoặc macOS chip Apple, nên bạn dùng Windows thì làm bước đó trong WSL.
  • Vài GB ổ đĩa trống (phần xuất .tflite tốn nhiều, xem mục Lỗi thường gặp) và biết Python cơ bản.
  • Android Studio nếu muốn làm app. Bài này dừng ở file .tflite và cách thêm vào project, mình chưa chạy trên điện thoại.

Bước 1: YOLO26 là gì và vì sao chọn nó

YOLO (You Only Look Once) là họ model nhìn ảnh một lần là ra tất cả các khung vật thể, nên chạy được thời gian thực. Trang tài liệu Ultralytics hiện ghi YOLO26 là bản mới nhất và khuyên dùng cho dự án mới, YOLO11 là lựa chọn ổn định đi kèm, còn YOLO27 đang ở trạng thái "Coming Soon". Mỗi bản có nhiều cỡ: n (nano, nhỏ nhất), s, m, l, x.

Trang Models của Ultralytics với biểu đồ so sánh YOLO26 và đoạn khuyên dùng YOLO26 cho dự án mới
Bước 1: trang docs.ultralytics.com/models, đoạn khoanh đỏ khuyên bắt đầu với YOLO26.

Bước 2: Cài PyTorch bản CPU và Ultralytics

Các bạn tạo môi trường ảo rồi cài PyTorch bản CPU trước, để pip không tải bản CUDA nặng vài GB. Sau đó cài ultralytics và opencv-python-headless, rồi gọi ultralytics.checks() để kiểm tra.

python -m venv venv
source venv/bin/activate          # Windows: venv\Scripts\activate
pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu
pip install ultralytics opencv-python-headless
python -c "import ultralytics; ultralytics.checks()"
Terminal cài torch bản CPU và ultralytics, lệnh checks báo Ultralytics 8.4.215 Setup complete
Bước 2: Ultralytics 8.4.215 với torch 2.15.0+cpu, báo "Setup complete".

Lần đầu mình chỉ cài ultralytics và bị lỗi libGL.so.1 ngay khi import. Lý do và cách sửa nằm ở mục Lỗi thường gặp, vì vậy lệnh trên cài sẵn bản headless.

Bước 3: Chạy thử một lệnh với ảnh mẫu

Lệnh yolo predict tự tải file yolo26n.pt (5,3 MB) từ GitHub của Ultralytics, nhận diện ảnh và lưu ảnh có vẽ khung vào thư mục runs/detect/predict. Ảnh bus.jpg là ảnh mẫu có sẵn trong gói ultralytics.

yolo predict model=yolo26n.pt source=anh/bus.jpg
Ảnh xe buýt có khung bus 0.88 và bốn khung person, bên phải là log của lệnh yolo predict
Bước 3: tìm ra 4 người và 1 xe buýt, phần suy luận mất 41,3 ms trên CPU.

Số 0.88 cạnh chữ bus là độ tin cậy (confidence) của khung đó.

Bước 4: Đọc kết quả bằng Python

Trong đồ án, các bạn thường cần con số: có bao nhiêu xe, xe nằm ở đâu. Đoạn code dưới đây in tên lớp, độ tin cậy, tọa độ khung và đếm theo từng loại.

from collections import Counter
from ultralytics import YOLO

model = YOLO("yolo26n.pt")                     # model nhỏ nhất, 5,3 MB
results = model("anh/kim-ma.jpg", conf=0.25)   # ngưỡng tin cậy mặc định
r = results[0]

print("Kích thước ảnh:", r.orig_shape)
print("Số vật thể:", len(r.boxes))
for box in r.boxes[:8]:                        # in thử 8 hộp đầu
    ten = model.names[int(box.cls)]
    x1, y1, x2, y2 = box.xyxy[0].tolist()
    print(f"{ten:12s} {float(box.conf):.2f}  ({x1:.0f},{y1:.0f}) -> ({x2:.0f},{y2:.0f})")

dem = Counter(model.names[int(c)] for c in r.boxes.cls)
print("Đếm theo loại:", dict(dem))
r.save(filename="ket-qua-kim-ma.jpg")         # ảnh có vẽ khung
Code Python dem_xe.py bên trái, kết quả bên phải với danh sách motorcycle, car, person và tọa độ khung
Bước 4: kết quả là 10 vật thể gồm 3 xe máy, 1 ô tô, 6 người.

Model có sẵn này nhận ra 80 loại vật thể của bộ dữ liệu COCO (person, bicycle, car, motorcycle, bus, truck, traffic light…). Danh sách nằm trong model.names.

Bước 5: Thử với ảnh khó: giao thông Hà Nội ban đêm

Ảnh mẫu thường rất "dễ". Mình thử ảnh thật trên Wikimedia Commons: ngã tư Kim Mã buổi tối, xe máy chen kín. YOLO26n bỏ sót rất nhiều người và xe ở hàng sau, còn khung motorcycle 0.77 bên phải ôm luôn mấy chiếc xe dính nhau.

Ảnh đêm ngã tư Kim Mã Hà Nội đông xe máy, YOLO26n vẽ khung cho 6 người, 3 xe máy, 1 ô tô
Bước 5: ảnh đông, thiếu sáng, xe che nhau là trường hợp khó với model nano.

Bước 6: Chỉnh ngưỡng tin cậy conf

Tham số conf quyết định khung nào được giữ lại. Mình chạy cùng ảnh với 4 ngưỡng khác nhau:

Bảng số vật thể theo ngưỡng conf 0.1, 0.25, 0.5, 0.7 và hai ảnh so sánh conf 0.1 với conf 0.5
Bước 6: conf=0.1 ra 24 khung, conf=0.25 ra 10, conf=0.5 ra 5, conf=0.7 chỉ còn 1.

Ngưỡng thấp bắt được nhiều hơn nhưng thêm khung chồng và khung sai, ngưỡng cao thì chắc hơn nhưng bỏ sót nhiều. Không có con số đúng cho mọi bài toán, các bạn thử trên ảnh của mình rồi chọn.

Bước 7: Chọn cỡ model n, s hay m

Cách thứ hai để bắt được nhiều hơn là dùng model to hơn. Mình đo ba cỡ trên cùng ảnh, trong container Linux giới hạn 4 nhân CPU, lấy trung bình 5 lần chạy:

Bảng so sánh yolo26n, yolo26s, yolo26m về dung lượng, số tham số, thời gian mỗi ảnh và số vật thể tìm được
Bước 7: yolo26n 72 ms/10 vật thể, yolo26s 247 ms/18, yolo26m 494 ms/22.

Model m tìm được gấp đôi số vật thể nhưng chậm gần 7 lần và nặng 44 MB. Với app điện thoại, các bạn nên bắt đầu bằng n, thiếu chính xác thì thử s.

Bước 8: Cài gói xuất LiteRT

Android chạy model qua LiteRT (tên mới của TensorFlow Lite), file vẫn có đuôi .tflite. Theo trang tài liệu Ultralytics, định dạng cũ format="tflite" vẫn chạy nhưng sẽ báo cảnh báo ngừng hỗ trợ, nên các bạn dùng format="litert". Trước hết cần cài thêm các gói xuất:

pip install "ultralytics[export-litert]"
Trang LiteRT Export của Ultralytics, mục Quickstart với lệnh pip install ultralytics export-litert được khoanh đỏ
Bước 8: lệnh cài trong mục Quickstart của trang LiteRT Export.

Lệnh này cài litert-torch, ai-edge-litert và ai-edge-quantizer. Lưu ý: nó đã đổi PyTorch của mình từ 2.15.0 xuống 2.14.1, chi tiết ở mục Lỗi thường gặp.

Bước 9: Xuất YOLO26n ra file .tflite

Mình xuất hai bản: FP32 (giữ nguyên độ chính xác) và w8a32 (trọng số nén xuống INT8, không cần dữ liệu hiệu chỉnh).

import os
from ultralytics import YOLO

model = YOLO("yolo26n.pt")
f1 = model.export(format="litert", imgsz=640)                     # FP32
f2 = model.export(format="litert", imgsz=640, quantize="w8a32")   # trọng số INT8
for f in (f1, f2):
    print("=>", f, f"{os.path.getsize(f)/1e6:.1f} MB")
Log xuất LiteRT: export success cho yolo26n.tflite và yolo26n_w8a32.tflite, file 10.0 MB và 2.9 MB
Bước 9: cả hai lần xuất chạy trên CPU, tổng 22 giây; bản w8a32 nhỏ hơn 3,5 lần.

File FP32 nặng 10,0 MB, bản w8a32 còn 2,9 MB. Hai con số này khớp với bảng trên trang tài liệu Ultralytics.

Bước 10: Kiểm tra file .tflite trước khi đưa vào app

Trước khi mở Android Studio, các bạn nên chạy lại file .tflite bằng Python, chỉ cần YOLO("yolo26n_w8a32.tflite", task="detect"), để chắc nó cho kết quả giống model gốc và xem đầu vào, đầu ra.

So sánh yolo26n.pt, yolo26n.tflite, yolo26n_w8a32.tflite về thời gian và số vật thể, cùng kích thước tensor đầu vào và đầu ra
Bước 10: ba bản cho kết quả gần nhau (10, 12, 11 vật thể); đầu vào [1, 3, 640, 640].

Ba điểm mình rút ra từ lần chạy này:

  • Kết quả lệch nhau một chút, chủ yếu vì bản .pt nhận ảnh chữ nhật 480×640, còn file .tflite cố định 640×640.
  • Trên CPU máy tính, bản INT8 không nhanh hơn (120 ms so với 86 ms của FP32). Lợi ích chính của nó là file nhỏ, còn tốc độ thì phải đo trên điện thoại thật.
  • Đầu vào là ảnh RGB dạng [1, 3, 640, 640] (kênh màu đứng trước, NCHW), kiểu float32, giá trị 0–1. Đầu ra mặc định là [1, 84, 8400]: 4 số tọa độ cộng 80 lớp cho 8.400 vị trí, app phải tự lọc. Xuất thêm nms=False thì đầu ra thành [1, 300, 6], mỗi dòng là x1, y1, x2, y2, score, class, chỉ cần lọc theo score nên viết code Android dễ hơn nhiều.

Bước 11: Đưa file .tflite vào project Android

Trang hướng dẫn LiteRT cho Android (cập nhật bản 2.3.x) dùng API CompiledModel. Các bạn thêm thư viện vào build.gradle của module app:

dependencies {
    implementation 'com.google.ai.edge.litert:litert:2.3.0'
    // Tùy chọn: chạy trên GPU
    implementation 'com.google.ai.edge.litert:litert-gpu:2.3.0'
}
Trang LiteRT Android của Google với khối dependencies litert 2.3.0 và litert-gpu 2.3.0 được khoanh đỏ
Bước 11: khai báo thư viện LiteRT theo trang hướng dẫn chính thức.

Đoạn Kotlin dưới đây rút gọn từ mẫu trên trang đó, mình chỉ sửa tên file và chú thích. Mình chưa chạy đoạn này trên điện thoại, nên các bạn xem nó như khung để bắt đầu:

val compiledModel = CompiledModel.create(
    "/path/to/yolo26n.tflite",
    CompiledModel.Options(Accelerator.CPU))
val inputBuffers = compiledModel.createInputBuffers()
val outputBuffers = compiledModel.createOutputBuffers()
inputBuffers.get(0).writeFloat(input)   // FloatArray 1*3*640*640, RGB, giá trị 0..1
compiledModel.run(inputBuffers, outputBuffers)
val output = outputBuffers.get(0).readFloat()   // 300*6 nếu xuất với nms=False

Nếu các bạn làm app bằng Flutter thì đơn giản hơn: Ultralytics có plugin chính thức (repo ultralytics/yolo-flutter-app), theo tài liệu thì plugin này đọc thẳng file LiteRT .tflite và có sẵn phần camera.

Lỗi thường gặp

ImportError: libGL.so.1: cannot open shared object file

Lỗi này xuất hiện khi import ultralytics trên máy Linux không có giao diện đồ họa (server, container Docker như máy mình dùng). Gói opencv-python mà ultralytics kéo về cần thư viện đồ họa. Cách sửa: gỡ nó và cài bản headless.

pip uninstall -y opencv-python
pip install opencv-python-headless
Terminal báo ImportError libGL.so.1 khi import ultralytics, sau đó cài opencv-python-headless và checks báo Setup complete
Lỗi 1: thiếu libGL.so.1, sửa bằng opencv-python-headless.

Sau khi cài ultralytics[export-litert] ở bước 8, opencv-python bị cài lại và lỗi này xuất hiện lần nữa. Mình phải chạy lại hai lệnh trên.

Cài gói xuất LiteRT làm đổi PyTorch và venv phình to

litert-torch đòi PyTorch dưới 2.15, nên pip đã gỡ torch 2.15.0+cpu và cài torch 2.14.1 bản có CUDA, kéo theo hàng loạt gói nvidia-*. Venv của mình tăng lên 7,0 GB, trong đó riêng thư mục nvidia là 3,2 GB. Việc xuất vẫn chạy được trên CPU, nhưng nếu ổ đĩa ít chỗ thì các bạn nên tạo một venv riêng chỉ để xuất model, giữ venv nhận diện gọn nhẹ.

quantize=16 (FP16) is not supported

Nhiều hướng dẫn cũ cho TFLite dùng FP16 để giảm một nửa dung lượng. Với format=litert thì không còn lựa chọn này. Các giá trị hợp lệ là 32 hoặc bỏ trống (FP32), "w8a32", 8 và "w8a16" (hai lựa chọn sau cần thêm dữ liệu hiệu chỉnh qua tham số data).

Terminal báo AssertionError quantize=16 FP16 is not supported khi xuất format litert
Lỗi 2: LiteRT không hỗ trợ quantize=16, dùng w8a32 thay thế.

Câu hỏi thường gặp

Có cần GPU để học YOLO không?

Không. Toàn bộ bài này chạy trên 4 nhân CPU: YOLO26n mất khoảng 70–110 ms cho một ảnh, xuất .tflite mất 22 giây. GPU chỉ thật sự cần khi các bạn huấn luyện model trên bộ dữ liệu lớn.

Muốn nhận diện vật thể không có trong 80 lớp (biển số, quả xoài…) thì sao?

Các bạn cần huấn luyện tiếp (fine-tune) YOLO26 trên ảnh đã gán nhãn của mình, xem mục Train trong tài liệu Ultralytics. Bài này chưa làm phần đó. Model có sẵn chỉ biết 80 lớp COCO.

YOLO26 khác YOLOv8, YOLO11 thế nào?

Theo trang Models, YOLO26 là bản mới nhất và là bản duy nhất có đủ bảy loại tác vụ, còn YOLO11 là lựa chọn ổn định. Code Python gần như giữ nguyên, chỉ đổi tên file model.

Dùng YOLO trong sản phẩm thương mại có được không?

Gói ultralytics khai báo giấy phép AGPL-3.0 (mình xem bằng pip show ultralytics). Làm đồ án, nghiên cứu thì thoải mái. Nếu đưa vào app thương mại mà không công khai mã nguồn thì các bạn cần đọc kỹ giấy phép trên GitHub của Ultralytics.

Nguồn tham khảo

Ảnh chụp và thử nghiệm ngày 18/11/2026.

Ảnh Nguyễn Hữu Huy

Tác giả

Giảng viên Khoa Công nghệ Thông tin, Cao đẳng FPT Polytechnic

Thầy Huy dạy lập trình tại Cao đẳng FPT Polytechnic, chia sẻ kiến thức về Android, Unity/C#, AI và lập trình backend qua blog dotplays và kênh YouTube Thầy Huy One Champ. Tác giả các ứng dụng dotsave, getvidfb và taptik.