Mengintegrasikan pengklasifikasi gambar

Klasifikasi gambar adalah penggunaan machine learning yang umum untuk mengidentifikasi diwakili oleh gambar tersebut. Misalnya, kita mungkin ingin tahu jenis hewan apa yang muncul dalam gambar tertentu. Tugas memprediksi apa yang diwakili oleh gambar disebut klasifikasi gambar. Pengklasifikasi gambar dilatih untuk mengenali berbagai gambar yang berbeda. Misalnya, model bisa dilatih untuk mengenali foto merepresentasikan tiga jenis hewan yang berbeda: kelinci, hamster, dan. Lihat tindakan contoh klasifikasi gambar untuk informasi lebih lanjut tentang pengklasifikasi gambar.

Menggunakan Task Library ImageClassifier API untuk men-deploy image kustom pengklasifikasi atau yang telah dilatih sebelumnya ke dalam aplikasi seluler Anda.

Fitur utama ImageClassifier API

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

Model pengklasifikasi gambar yang didukung

Model berikut dijamin akan kompatibel dengan ImageClassifier Compute Engine API.

Model yang dibuat oleh Pembuat Model TensorFlow Lite untuk Klasifikasi Gambar.
Tujuan model klasifikasi gambar terlatih di TensorFlow Hub.
Model yang dibuat oleh Klasifikasi Gambar AutoML Vision Edge.
Model kustom yang memenuhi persyaratan kompatibilitas model.

Menjalankan inferensi di Java

Lihat Aplikasi referensi Klasifikasi Gambar untuk contoh cara menggunakan ImageClassifier 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
ImageClassifierOptions options =
    ImageClassifierOptions.builder()
        .setBaseOptions(BaseOptions.builder().useGpu().build())
        .setMaxResults(1)
        .build();
ImageClassifier imageClassifier =
    ImageClassifier.createFromFileAndOptions(
        context, modelFile, options);

// Run inference
List<Classifications> results = imageClassifier.classify(image);

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

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: "birds_V1",
                                            ofType: "tflite") else { return }

let options = ImageClassifierOptions(modelPath: modelPath)

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

let classifier = try ImageClassifier.classifier(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: "sparrow.jpg"), let mlImage = MLImage(image: image) else { return }

// Run inference
let classificationResults = try classifier.classify(mlImage: mlImage)

Objective C

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

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

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

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

TFLImageClassifier *classifier = [TFLImageClassifier imageClassifierWithOptions:options
                                                                          error:nil];

// Convert the input image to MLImage.
UIImage *image = [UIImage imageNamed:@"sparrow.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
TFLClassificationResult *classificationResult =
    [classifier classifyWithGMLImage:gmlImage error:nil];

Lihat kode sumber guna mendapatkan opsi selengkapnya untuk mengonfigurasi TFLImageClassifier.

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)
classification_options = processor.ClassificationOptions(max_results=2)
options = vision.ImageClassifierOptions(base_options=base_options, classification_options=classification_options)
classifier = vision.ImageClassifier.create_from_options(options)

# Alternatively, you can create an image classifier in the following manner:
# classifier = vision.ImageClassifier.create_from_file(model_path)

# Run inference
image = vision.TensorImage.create_from_file(image_path)
classification_result = classifier.classify(image)

Lihat kode sumber guna mendapatkan opsi selengkapnya untuk mengonfigurasi ImageClassifier.

Menjalankan inferensi di C++

// Initialization
ImageClassifierOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_path);
std::unique_ptr<ImageClassifier> image_classifier = ImageClassifier::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 ClassificationResult result = image_classifier->Classify(*frame_buffer).value();

Lihat kode sumber guna mendapatkan opsi selengkapnya untuk mengonfigurasi ImageClassifier.

Hasil contoh

Berikut adalah contoh hasil klasifikasi dari pengklasifikasi burung.

burung pipit

Results:
  Rank #0:
   index       : 671
   score       : 0.91406
   class name  : /m/01bwb9
   display name: Passer domesticus
  Rank #1:
   index       : 670
   score       : 0.00391
   class name  : /m/01bwbt
   display name: Passer montanus
  Rank #2:
   index       : 495
   score       : 0.00391
   class name  : /m/0bwm6m
   display name: Passer italiae

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

Persyaratan kompatibilitas model

ImageClassifier API mengharapkan model TFLite dengan Metadata Model TFLite. Lihat contoh pembuatan metadata untuk pengklasifikasi gambar menggunakan TensorFlow Lite Metadata Writer API.

Model pengklasifikasi gambar yang kompatibel harus memenuhi persyaratan berikut:

Memasukkan 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 skor output (kTfLiteUInt8/kTfLiteFloat32)
- dengan class N dan 2 atau 4 dimensi, yaitu [1 x N] atau [1 x 1 x 1 x N]
- peta label opsional (tetapi direkomendasikan) sebagai AssociatedFile-s dengan jenis TENSOR_AXIS_LABEL, berisi satu label per baris. Lihat contoh file label. AssociatedFile pertama tersebut (jika ada) digunakan untuk mengisi kolom label (dinamai sebagai class_name dalam C++) dari hasil tersebut. Kolom display_name diisi dari AssociatedFile (jika ada) yang lokalnya cocok dengan Kolom display_names_locale dari ImageClassifierOptions 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.