Integracja klasyfikatorów obrazów

Klasyfikacja obrazów to powszechne zastosowanie uczenia maszynowego do identyfikowania tego, co przedstawia obraz. Możemy na przykład chcieć wiedzieć, jakie zwierzę znajduje się na danym zdjęciu. Zadanie polegające na przewidywaniu, co przedstawia obraz, nazywa się klasyfikacją obrazów. Klasyfikator obrazów jest trenowany w celu rozpoznawania różnych klas obrazów. Na przykład model może być wytrenowany do rozpoznawania zdjęć przedstawiających 3 różne rodzaje zwierząt: króliki, chomiki i psy. Więcej informacji o klasyfikatorach obrazów znajdziesz w przykładzie klasyfikacji obrazów.

Użyj interfejsu API biblioteki zadań ImageClassifier, aby wdrożyć w aplikacjach mobilnych własne lub wstępnie wytrenowane klasyfikatory obrazów.

Kluczowe funkcje interfejsu ImageClassifier API

  • Przetwarzanie obrazu wejściowego, w tym obracanie, zmiana rozmiaru i konwersja przestrzeni kolorów.

  • Obszar zainteresowań na obrazie wejściowym.

  • Etykieta lokalizacji na mapie.

  • Próg wyniku do filtrowania wyników.

  • Wyniki klasyfikacji k najlepszych wyników.

  • Lista dozwolonych i odrzuconych etykiet.

Obsługiwane modele klasyfikatorów obrazów

Te modele są zgodne z ImageClassifierAPI.

Uruchamianie wnioskowania w Javie

Przykład użycia ImageClassifier w aplikacji na Androida znajdziesz w przykładowej aplikacji do klasyfikacji obrazów.

Krok 1. Zaimportuj zależność Gradle i inne ustawienia

Skopiuj plik modelu .tflite do katalogu zasobów modułu Androida, w którym będzie uruchamiany model. Określ, że plik nie powinien być kompresowany, i dodaj bibliotekę TensorFlow Lite do pliku build.gradle modułu:

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

Krok 2. Korzystanie z modelu

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

Więcej opcji konfigurowania ImageClassifier znajdziesz w kodzie źródłowym i dokumentacji Javadoc.

Uruchamianie wnioskowania na iOS

Krok 1. Zainstaluj zależności

Biblioteka zadań obsługuje instalację za pomocą CocoaPods. Upewnij się, że w systemie jest zainstalowany CocoaPods. Instrukcje znajdziesz w przewodniku instalacji CocoaPods.

Szczegółowe informacje o dodawaniu podów do projektu w Xcode znajdziesz w przewodniku po CocoaPods.

Dodaj pod TensorFlowLiteTaskVision do pliku Podfile.

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

Upewnij się, że model .tflite, którego będziesz używać do wnioskowania, znajduje się w pakiecie aplikacji.

Krok 2. Korzystanie z modelu

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

Więcej opcji konfigurowania TFLImageClassifier znajdziesz w kodzie źródłowym.

Uruchamianie wnioskowania w Pythonie

Krok 1. Zainstaluj pakiet pip

pip install tflite-support

Krok 2. Korzystanie z modelu

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

Więcej opcji konfigurowania ImageClassifier znajdziesz w kodzie źródłowym.

Uruchamianie wnioskowania w 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();

Więcej opcji konfigurowania ImageClassifier znajdziesz w kodzie źródłowym.

Przykładowe wyniki

Oto przykład wyników klasyfikacji klasyfikatora ptaków.

wróbel

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

Wypróbuj proste narzędzie demonstracyjne CLI dla ImageClassifier z własnym modelem i danymi testowymi.

Wymagania dotyczące zgodności modeli

Interfejs ImageClassifier API oczekuje modelu TFLite z obowiązkowymi metadanymi modelu TFLite. Zobacz przykłady tworzenia metadanych dla klasyfikatorów obrazów za pomocą interfejsu API do tworzenia metadanych TensorFlow Lite.

Modele klasyfikatora obrazów powinny spełniać te wymagania:

  • Tensor obrazu wejściowego (kTfLiteUInt8/kTfLiteFloat32)

    • obraz wejściowy o rozmiarze [batch x height x width x channels].
    • wnioskowanie zbiorcze nie jest obsługiwane (batch musi mieć wartość 1).
    • obsługiwane są tylko dane wejściowe RGB (wartość channels musi wynosić 3);
    • Jeśli typ to kTfLiteFloat32, do metadanych muszą być dołączone opcje normalizacji, aby można było normalizować dane wejściowe.

  • Tensor wyniku wyjściowego (kTfLiteUInt8/kTfLiteFloat32)

    • z N klasami i 2 lub 4 wymiarami, czyli [1 x N] lub [1 x 1 x 1 x N].
    • opcjonalne (ale zalecane) mapy etykiet jako AssociatedFile-s z typem TENSOR_AXIS_LABELS, zawierające po 1 etykiecie w wierszu; Zobacz przykładowy plik etykiet. Pierwszy taki element AssociatedFile (jeśli istnieje) jest używany do wypełnienia pola label (w C++ oznaczanego jako class_name) w wynikach. Pole display_name jest wypełniane na podstawie powiązanego pliku (jeśli taki istnieje), którego ustawienia regionalne są zgodne z polem display_names_locale elementu ImageClassifierOptions użytego podczas tworzenia (domyślnie „en”, czyli angielski). Jeśli żadne z tych pól nie jest dostępne, wypełnione zostanie tylko pole index w wynikach.