Tích hợp thuật toán phân loại hình ảnh

Phân loại hình ảnh là một cách sử dụng phổ biến của công nghệ học máy để xác định hình ảnh đại diện. Ví dụ: chúng ta có thể muốn biết loài động vật nào xuất hiện trong một bức ảnh cụ thể. Nhiệm vụ dự đoán tên gọi của một hình ảnh phân loại hình ảnh. Một thuật toán phân loại hình ảnh được huấn luyện để nhận dạng nhiều lớp hình ảnh. Ví dụ: một mô hình có thể được huấn luyện để nhận dạng ảnh đại diện cho ba loại động vật khác nhau: thỏ, chuột đồng và chó. Xem thời gian ví dụ về phân loại hình ảnh để biết thêm thông tin về thuật toán phân loại hình ảnh.

Sử dụng API ImageClassifier của Thư viện tác vụ để triển khai hình ảnh tuỳ chỉnh thuật toán phân loại hoặc thuật toán được huấn luyện trước vào ứng dụng dành cho thiết bị di động.

Các tính năng chính của ImageClassifier API

Xử lý hình ảnh đầu vào, bao gồm xoay, đổi kích thước và hệ màu chuyển đổi.
Khu vực quan tâm của hình ảnh nhập vào.
Ngôn ngữ bản đồ của nhãn.
Ngưỡng điểm để lọc kết quả.
Kết quả phân loại hàng đầu.
Hãng nhạc được cho phép và danh sách từ chối.

Các mô hình phân loại hình ảnh được hỗ trợ

Các mô hình sau đây được đảm bảo tương thích với ImageClassifier API.

Mô hình được tạo bởi Trình tạo mô hình TensorFlow Lite để phân loại hình ảnh.
Chiến lược phát hành đĩa đơn các mô hình phân loại hình ảnh được huấn luyện trước trên TensorFlow Hub.
Mô hình được tạo bởi Phân loại hình ảnh AutoML Vision Edge.
Mô hình tuỳ chỉnh đáp ứng yêu cầu về khả năng tương thích với mô hình.

Chạy dự đoán trong Java

Xem Ứng dụng tham khảo Phân loại hình ảnh ví dụ về cách sử dụng ImageClassifier trong ứng dụng Android.

Bước 1: Nhập phần phụ thuộc Gradle và các chế độ cài đặt khác

Sao chép tệp mô hình .tflite vào thư mục thành phần của mô-đun Android nơi mô hình sẽ chạy. Chỉ định rằng tệp không được nén và thêm thư viện TensorFlow Lite vào tệp build.gradle của mô-đun:

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'
}

Bước 2: Sử dụng mô hình

// 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);

Xem mã nguồn và javadoc để có thêm lựa chọn để định cấu hình ImageClassifier.

Chạy dự đoán trong iOS

Bước 1: Cài đặt phần phụ thuộc

Thư viện Tác vụ hỗ trợ cài đặt bằng CocoaPods. Đảm bảo rằng CocoaPods được cài đặt trên hệ thống của bạn. Vui lòng xem Hướng dẫn cài đặt CocoaPods để được hướng dẫn.

Vui lòng xem Hướng dẫn của CocoaPods cho chi tiết về cách thêm nhóm vào dự án Xcode.

Thêm nhóm TensorFlowLiteTaskVision trong Podfile.

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

Hãy đảm bảo rằng mô hình .tflite mà bạn sẽ dùng để suy luận có mặt trong gói ứng dụng của bạn.

Bước 2: Sử dụng mô hình

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];

Xem mã nguồn để có thêm lựa chọn để định cấu hình TFLImageClassifier.

Chạy suy luận trong Python

Bước 1: Cài đặt gói pip

pip install tflite-support

Bước 2: Sử dụng mô hình

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

Xem mã nguồn để có thêm lựa chọn để định cấu hình ImageClassifier.

Chạy dự đoán trong 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();

Xem mã nguồn để có thêm lựa chọn để định cấu hình ImageClassifier.

Kết quả mẫu

Dưới đây là ví dụ về kết quả phân loại của một trình phân loại chim.

chim sẻ

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

Thử mẹo đơn giản Công cụ minh hoạ CLI cho ImageClassifier thông qua mô hình và dữ liệu thử nghiệm của riêng bạn.

Yêu cầu về khả năng tương thích với mô hình

API ImageClassifier yêu cầu một mô hình TFLite với Siêu dữ liệu mô hình TFLite. Xem ví dụ về cách tạo siêu dữ liệu cho thuật toán phân loại hình ảnh bằng TensorFlow Lite Metadata Writer API.

Các mô hình thuật toán phân loại hình ảnh tương thích phải đáp ứng các yêu cầu sau:

Nhập tensor hình ảnh (kTfLiteUInt8/kTfLiteFloat32)
- hình ảnh đầu vào có kích thước [batch x height x width x channels].
- không hỗ trợ suy luận theo lô (batch phải là 1).
- chỉ hỗ trợ đầu vào RGB (bắt buộc phải có channels là 3).
- nếu loại là kTfLiteFloat32, thì NormalizationOptions bắt buộc phải là được đính kèm với siêu dữ liệu để chuẩn hoá đầu vào.
Tensor điểm đầu ra (kTfLiteUInt8/kTfLiteFloat32)
- có các lớp N và 2 hoặc 4 phương diện, tức là [1 x N] hoặc [1 x 1 x 1 x N]
- (các) bản đồ nhãn không bắt buộc(nhưng nên dùng) dưới dạng AssociatedFile-s có loại TENSOR_AXIS_LABEL, chứa một nhãn trên mỗi dòng. Xem ví dụ về tệp nhãn. AssociatedFile đầu tiên như vậy (nếu có) được dùng để điền vào trường label (có tên là class_name trong C++) của kết quả. Trường display_name được điền từ AssociatedFile (nếu có) có ngôn ngữ khớp với Trường display_names_locale của ImageClassifierOptions được sử dụng tại thời gian tạo ("en" theo mặc định, tức là tiếng Anh). Nếu không có phương pháp nào nêu trên có sẵn, thì hệ thống sẽ chỉ điền trường index của kết quả.