Integracja klasyfikatorów obrazu

Klasyfikacja obrazu jest powszechnym zastosowaniem uczenia maszynowego do identyfikowania tego, co reprezentuje obraz. Na przykład możemy chcieć wiedzieć, jaki rodzaj zwierzęcia pojawia się na danym obrazku. Zadanie polegające na przewidzeniu, co reprezentuje obraz, nazywa się klasyfikacją obrazu . Klasyfikator obrazu jest przeszkolony do rozpoznawania różnych klas obrazów. Model można na przykład nauczyć rozpoznawania zdjęć przedstawiających trzy różne typy zwierząt: króliki, chomiki i psy. Więcej informacji na temat klasyfikatorów obrazów można znaleźć w omówieniu klasyfikacji obrazów.

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

Kluczowe cechy API ImageClassifier

Przetwarzanie obrazu wejściowego, w tym obracanie, zmiana rozmiaru i konwersja przestrzeni kolorów.
Obszar zainteresowania obrazu wejściowego.
Oznacz lokalizację mapy.
Próg punktacji do filtrowania wyników.
Wyniki klasyfikacji z najwyższej półki.
Oznacz listę dozwolonych i odrzuconych etykiet.

Obsługiwane modele klasyfikatorów obrazów

Gwarantujemy kompatybilność następujących modeli z interfejsem API ImageClassifier .

Modele utworzone przez TensorFlow Lite Model Maker do klasyfikacji obrazów .
Wstępnie wyszkolone modele klasyfikacji obrazów w TensorFlow Hub .
Modele utworzone przez klasyfikację obrazów AutoML Vision Edge .
Modele niestandardowe spełniające wymagania dotyczące kompatybilności modeli .

Uruchom wnioskowanie w Javie

Zobacz aplikację referencyjną do klasyfikacji obrazów , aby zapoznać się z przykładem użycia ImageClassifier w aplikacji na Androida.

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

Skopiuj plik modelu .tflite do katalogu zasobów modułu Android, w którym model będzie uruchamiany. 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 (NNAPI is included)
    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);

Zobacz kod źródłowy i javadoc, aby uzyskać więcej opcji konfiguracji ImageClassifier .

Uruchom wnioskowanie w systemie iOS

Krok 1: Zainstaluj zależności

Biblioteka zadań obsługuje instalację przy użyciu CocoaPods. Upewnij się, że CocoaPods jest zainstalowany w twoim systemie. Instrukcje znajdziesz w instrukcji instalacji CocoaPods .

Szczegółowe informacje na temat dodawania kapsuł do projektu Xcode można znaleźć w przewodniku CocoaPods .

Dodaj moduł 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

Szybki

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

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

Zobacz kod źródłowy , aby uzyskać więcej opcji konfiguracji TFLImageClassifier .

Uruchom wnioskowanie 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)

Zobacz kod źródłowy , aby uzyskać więcej opcji konfiguracji ImageClassifier .

Uruchom wnioskowanie 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();

Zobacz kod źródłowy , aby uzyskać więcej opcji konfiguracji ImageClassifier .

Przykładowe wyniki

Oto przykład wyników klasyfikacji uzyskanych za pomocą 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 kompatybilności modelu

Interfejs API ImageClassifier oczekuje modelu TFLite z obowiązkowymi metadanymi modelu TFLite . Zobacz przykłady tworzenia metadanych dla klasyfikatorów obrazów przy użyciu interfejsu API narzędzia do zapisywania metadanych TensorFlow Lite .

Kompatybilne modele klasyfikatorów obrazu powinny spełniać następujące wymagania:

Tensor obrazu wejściowego (kTfLiteUInt8/kTfLiteFloat32)
- wprowadzanie obrazu o rozmiarze [batch x height x width x channels] .
- wnioskowanie wsadowe nie jest obsługiwane (wymagana jest batch 1).
- obsługiwane są tylko wejścia RGB (wymagane są 3 channels ).
- jeśli typ to kTfLiteFloat32, do metadanych należy dołączyć opcje NormalizationOptions w celu normalizacji danych wejściowych.
Tensor wyniku wyjściowego (kTfLiteUInt8/kTfLiteFloat32)
- z klasami N i 2 lub 4 wymiarami, tj. [1 x N] lub [1 x 1 x 1 x N]
- opcjonalne (ale zalecane) mapy etykiet jako AssociatedFile-s typu TENSOR_AXIS_LABELS, zawierające jedną etykietę w linii. Zobacz przykładowy plik etykiety . Pierwszy taki AssociatedFile (jeśli istnieje) jest używany do wypełnienia pola label (nazwanego jako class_name w C++) wyników. Pole display_name jest wypełniane z pliku AssociatedFile (jeśli istnieje), którego ustawienia regionalne odpowiadają polu display_names_locale ImageClassifierOptions użytej w czasie tworzenia (domyślnie „en”, tj. angielski). Jeśli żadne z nich nie jest dostępne, wypełnione zostanie jedynie pole index wyników.