Integracja klasyfikatorów obrazów

Klasyfikacja obrazów to typowe zastosowanie systemów uczących się do identyfikowania obrazów obrazu. Możemy na przykład dowiedzieć się, jakiego rodzaju zwierzęta na danym zdjęciu. Zadanie prognozowania, co przedstawia obraz, nazywa się klasyfikacji obrazów. Klasyfikator obrazów jest wytrenowany tak, aby rozpoznawał różne klas obrazów. Model można na przykład wytrenować do rozpoznawania zdjęć 3 rodzaje zwierząt: króliki, chomiki i psy. Zobacz przykład klasyfikacji obrazów .

Wdróż obraz niestandardowy przy użyciu interfejsu Task Library API ImageClassifier lub klasyfikatory już wytrenowane.

Najważniejsze funkcje interfejsu ImageClassifier API

Przetwarzanie obrazu, w tym obrót, zmiana rozmiaru i przestrzeń kolorów konwersji.
Obszar zainteresowań obrazu wejściowego.
Język mapy etykiet.
Próg oceny do filtrowania wyników.
Wyniki klasyfikacji Top-K.
Listy dozwolonych i odrzuconych etykiet.

Obsługiwane modele klasyfikatorów obrazów

Te modele gwarantują zgodność z modelem ImageClassifier API.

Modele utworzone przez TensorFlow Lite Model Maker for Image Classification (Kreator modeli TensorFlow Lite do klasyfikacji obrazów).
wstępnie wytrenowanych modeli klasyfikacji obrazów w TensorFlow Hub.
Modele utworzone przez Klasyfikacja obrazów AutoML Vision Edge
Modele niestandardowe, które spełniają wymaganiami dotyczącymi zgodności z modelem.

Uruchom wnioskowanie w Javie

Zobacz Aplikacja referencyjna do klasyfikacji obrazów pokazuje, jak używać właściwości ImageClassifier w aplikacji na Androida.

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ć skompresowany. 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);

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

Uruchom wnioskowanie w iOS

Krok 1. Zainstaluj zależności

Biblioteka zadań obsługuje instalację za pomocą CocoaPods. Upewnij się, że CocoaPods jest zainstalowany w systemie. Zapoznaj się z Przewodnik instalacji CocoaPods .

Zapoznaj się z Przewodnik po CocoaPods dotyczący dowiesz się więcej o dodawaniu podów do projektu Xcode.

Dodaj pod plik TensorFlowLiteTaskVision w pliku Podfile.

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

Sprawdź, czy dostępny jest model .tflite, którego będziesz używać do wnioskowania pakietu 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];

Zobacz kod źródłowy , aby uzyskać więcej opcji konfigurowania 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 konfigurowania 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 konfigurowania ImageClassifier.

Przykładowe wyniki

Oto przykład wyników klasyfikacji klasyfikator 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 prostą Narzędzie demonstracyjne interfejsu wiersza poleceń ImageClassifier z własnym modelem i danymi testowymi.

Wymagania dotyczące zgodności z modelem

Interfejs API ImageClassifier wymaga modelu TFLite z obowiązkowym ustawieniem Metadane modelu TFLite. Zobacz przykłady tworzenia metadanych dla klasyfikatorów obrazów za pomocą TensorFlow Lite Metadata Writer API.

Zgodne modele klasyfikatorów obrazów powinny spełniać te wymagania:

Tensor obrazu wejściowego (kTfLiteUInt8/kTfLiteFloat32)
- plik do wprowadzania obrazu o rozmiarze [batch x height x width x channels].
- wnioskowanie wsadowe nie jest obsługiwane (wartość batch musi wynosić 1).
- obsługiwane są tylko wejścia RGB (channels musi mieć wartość 3).
- jeśli typ to kTfLiteFloat32, element NormalizationOptions musi mieć wartość do metadanych w celu normalizacji danych wejściowych.
Tensor wyniku wyjściowego (kTfLiteUInt8/kTfLiteFloat32)
- z klasą N i 2 lub 4 wymiarami, np. [1 x N] lub [1 x 1 x 1 x N]
- opcjonalne (ale zalecane) etykiety map jako AssociatedFile-s z typem TENSOR_AXIS_LABELS, zawierający po jednej etykiecie na wiersz. Zobacz przykładowego pliku etykiet. Pierwszy taki powiązany plik (jeśli istnieje) jest używany do wypełnienia pola label. (o nazwie class_name w języku C++). Pole display_name jest wypełniany z pola AssociatedFile (jeśli występuje), którego język zgodny z Pole display_names_locale z ImageClassifierOptions wykorzystywane podczas czas utworzenia („en” – domyślnie „en”, czyli w języku angielskim). Jeśli żadna z tych opcji nie pasuje dostępne, zostanie wypełnione tylko pole index wyników.