Memperkenalkan LiteRT: Runtime Google berperforma tinggi untuk AI di perangkat, yang sebelumnya dikenal sebagai TensorFlow Lite.

Halaman ini diterjemahkan oleh Cloud Translation API.

Mengintegrasikan detektor objek

Pendeteksi objek dapat mengidentifikasi sekumpulan objek mana yang mungkin ditemukan dan memberikan informasi tentang posisi mereka dalam gambar atau video yang diberikan feed Anda. Detektor objek dilatih untuk mendeteksi kehadiran dan lokasi beberapa kelas objek. Misalnya, model mungkin dilatih dengan gambar yang berisi berbagai potongan buah, bersama dengan label yang menentukan kelas buah yang mereka wakili (mis. apel, pisang, atau stroberi), dan data yang menentukan tempat munculnya setiap objek dalam gambar. Lihat contoh deteksi objek untuk mengetahui informasi selengkapnya tentang detektor objek.

Menggunakan Task Library ObjectDetector API untuk men-deploy detektor objek kustom Anda atau yang telah dilatih sebelumnya ke dalam aplikasi seluler Anda.

Fitur utama ObjectDetector API

Input pemrosesan gambar, termasuk rotasi, perubahan ukuran, dan ruang warna konversi.
Beri label lokalitas peta.
Nilai minimum skor untuk memfilter hasil.
Hasil deteksi Top-K.
Beri label daftar yang diizinkan dan tolak.

Model detektor objek yang didukung

Model berikut dijamin akan kompatibel dengan ObjectDetector Compute Engine API.

Tujuan model deteksi objek yang telah dilatih sebelumnya di TensorFlow Hub.
Model yang dibuat oleh Deteksi Objek Edge AutoML Vision.
Model yang dibuat oleh TensorFlow Lite Model Maker untuk detektor objek.
Model kustom yang memenuhi persyaratan kompatibilitas model.

Menjalankan inferensi di Java

Lihat Aplikasi referensi Deteksi Objek untuk contoh cara menggunakan ObjectDetector di aplikasi Android.

Langkah 1: Impor dependensi Gradle dan setelan lainnya

Salin file model .tflite ke direktori aset modul Android tempat model akan dijalankan. Tentukan bahwa file tidak boleh dikompresi, dan tambahkan library TensorFlow Lite ke file build.gradle modul:

android {
    // Other settings

    // Specify tflite file should not be compressed for the app apk
    aaptOptions {
        noCompress "tflite"
    }
}

dependencies {
    // Other dependencies

    // Import the Task Vision Library dependency
    implementation 'org.tensorflow:tensorflow-lite-task-vision'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin'
}

Langkah 2: Menggunakan model

// Initialization
ObjectDetectorOptions options =
    ObjectDetectorOptions.builder()
        .setBaseOptions(BaseOptions.builder().useGpu().build())
        .setMaxResults(1)
        .build();
ObjectDetector objectDetector =
    ObjectDetector.createFromFileAndOptions(
        context, modelFile, options);

// Run inference
List<Detection> results = objectDetector.detect(image);

Lihat kode sumber dan javadoc guna mendapatkan opsi selengkapnya untuk mengonfigurasi ObjectDetector.

Menjalankan inferensi di iOS

Langkah 1: Instal dependensi

Task Library mendukung penginstalan menggunakan CocoaPods. Pastikan CocoaPods diinstal di sistem Anda. Lihat Panduan pemasangan CocoaPods untuk melihat petunjuk.

Lihat Panduan CocoaPods untuk detail tentang cara menambahkan pod ke project Xcode.

Tambahkan pod TensorFlowLiteTaskVision di Podfile.

target 'MyAppWithTaskAPI' do
  use_frameworks!
  pod 'TensorFlowLiteTaskVision'
end

Pastikan bahwa model .tflite yang akan Anda gunakan untuk inferensi ada di app bundle Anda.

Langkah 2: Menggunakan model

Swift

// Imports
import TensorFlowLiteTaskVision

// Initialization
guard let modelPath = Bundle.main.path(forResource: "ssd_mobilenet_v1",
                                            ofType: "tflite") else { return }

let options = ObjectDetectorOptions(modelPath: modelPath)

// Configure any additional options:
// options.classificationOptions.maxResults = 3

let detector = try ObjectDetector.detector(options: options)

// Convert the input image to MLImage.
// There are other sources for MLImage. For more details, please see:
// https://developers.google.com/ml-kit/reference/ios/mlimage/api/reference/Classes/GMLImage
guard let image = UIImage (named: "cats_and_dogs.jpg"), let mlImage = MLImage(image: image) else { return }

// Run inference
let detectionResult = try detector.detect(mlImage: mlImage)

Objective-C

// Imports
#import <TensorFlowLiteTaskVision/TensorFlowLiteTaskVision.h>

// Initialization
NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"ssd_mobilenet_v1" ofType:@"tflite"];

TFLObjectDetectorOptions *options = [[TFLObjectDetectorOptions alloc] initWithModelPath:modelPath];

// Configure any additional options:
// options.classificationOptions.maxResults = 3;

TFLObjectDetector *detector = [TFLObjectDetector objectDetectorWithOptions:options
                                                                     error:nil];

// Convert the input image to MLImage.
UIImage *image = [UIImage imageNamed:@"dogs.jpg"];

// There are other sources for GMLImage. For more details, please see:
// https://developers.google.com/ml-kit/reference/ios/mlimage/api/reference/Classes/GMLImage
GMLImage *gmlImage = [[GMLImage alloc] initWithImage:image];

// Run inference
TFLDetectionResult *detectionResult = [detector detectWithGMLImage:gmlImage error:nil];

Lihat kode sumber guna mendapatkan opsi selengkapnya untuk mengonfigurasi TFLObjectDetector.

Menjalankan inferensi di Python

Langkah 1: Instal paket pip

pip install tflite-support

Langkah 2: Menggunakan model

# Imports
from tflite_support.task import vision
from tflite_support.task import core
from tflite_support.task import processor

# Initialization
base_options = core.BaseOptions(file_name=model_path)
detection_options = processor.DetectionOptions(max_results=2)
options = vision.ObjectDetectorOptions(base_options=base_options, detection_options=detection_options)
detector = vision.ObjectDetector.create_from_options(options)

# Alternatively, you can create an object detector in the following manner:
# detector = vision.ObjectDetector.create_from_file(model_path)

# Run inference
image = vision.TensorImage.create_from_file(image_path)
detection_result = detector.detect(image)

Lihat kode sumber guna mendapatkan opsi selengkapnya untuk mengonfigurasi ObjectDetector.

Menjalankan inferensi di C++

// Initialization
ObjectDetectorOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_path);
std::unique_ptr<ObjectDetector> object_detector = ObjectDetector::CreateFromOptions(options).value();

// Create input frame_buffer from your inputs, `image_data` and `image_dimension`.
// See more information here: tensorflow_lite_support/cc/task/vision/utils/frame_buffer_common_utils.h
std::unique_ptr<FrameBuffer> frame_buffer = CreateFromRgbRawBuffer(
      image_data, image_dimension);

// Run inference
const DetectionResult result = object_detector->Detect(*frame_buffer).value();

Lihat kode sumber guna mendapatkan opsi selengkapnya untuk mengonfigurasi ObjectDetector.

Hasil contoh

Berikut contoh hasil deteksi mobilenet ssd v1 dari TensorFlow Hub.

anjing

Results:
 Detection #0 (red):
  Box: (x: 355, y: 133, w: 190, h: 206)
  Top-1 class:
   index       : 17
   score       : 0.73828
   class name  : dog
 Detection #1 (green):
  Box: (x: 103, y: 15, w: 138, h: 369)
  Top-1 class:
   index       : 17
   score       : 0.73047
   class name  : dog

Render kotak pembatas ke gambar input:

output deteksi

Cobalah yang Alat demo CLI untuk ObjectDetector dengan model dan data uji Anda sendiri.

Persyaratan kompatibilitas model

ObjectDetector API mengharapkan model TFLite dengan Metadata Model TFLite. Lihat contoh pembuatan metadata untuk detektor objek menggunakan TensorFlow Lite Metadata Writer API.

Model detektor objek yang kompatibel harus memenuhi persyaratan berikut:

Input tensor gambar: (kTfLiteUInt8/kTfLiteFloat32)
- input gambar berukuran [batch x height x width x channels].
- inferensi batch tidak didukung (batch harus 1).
- hanya input RGB yang didukung (channels harus 3).
- jika tipenya kTfLiteFloat32, NormalizationOptions diperlukan yang dilampirkan ke metadata untuk normalisasi input.
Tensor output harus berupa 4 output dari operasi DetectionPostProcess, yaitu:
- Tensor lokasi (kTfLiteFloat32)
  - tensor ukuran [1 x num_results x 4], array dalam yang mewakili kotak pembatas dalam bentuk [atas, kiri, kanan, bawah].
  - BoundingBoxProperties harus dilampirkan ke metadata dan harus menentukan type=BOUNDARIES serta `koordinat_type=RATIO.
- Tensor class (kTfLiteFloat32)
  - tensor ukuran [1 x num_results], setiap nilai yang mewakili indeks bilangan bulat dari suatu class.
  - peta label opsional (tapi direkomendasikan) dapat dilampirkan sebagai AssociatedFile-s dengan jenis TENSOR_VALUE_LABEL, yang berisi satu label per baris. Lihat contoh file label. AssociatedFile pertama tersebut (jika ada) digunakan untuk mengisi Kolom class_name hasil. Kolom display_name diisi dari AssociatedFile (jika ada) yang lokalnya cocok dengan Kolom display_names_locale dari ObjectDetectorOptions yang digunakan di waktu pembuatan ("en" secara default, yaitu bahasa Inggris). Jika tidak satu pun dari tersedia, hanya kolom index dari hasil yang akan diisi.
- Tensor Score (kTfLiteFloat32)
  - tensor ukuran [1 x num_results], setiap nilai yang mewakili skor objek yang terdeteksi.
- Jumlah tensor deteksi (kTfLiteFloat32)
  - integer num_results sebagai tensor ukuran [1].