Bildklassifikatoren einbinden

Die Bildklassifizierung ist eine gängige Anwendung von maschinellem Lernen, um zu erkennen, was ein Bild darstellt. Wir möchten beispielsweise wissen, welche Art von Tier auf einem bestimmten Bild zu sehen ist. Die Aufgabe, vorherzusagen, was ein Bild darstellt, wird als Bildklassifizierung bezeichnet. Ein Bildklassifikator wird trainiert, um verschiedene Bildklassen zu erkennen. Ein Modell könnte beispielsweise darauf trainiert werden, Fotos von drei verschiedenen Tierarten zu erkennen: Kaninchen, Hamster und Hunde. Weitere Informationen zu Bildklassifizierern finden Sie im Beispiel für die Bildklassifizierung.

Mit der Task Library ImageClassifier API können Sie Ihre benutzerdefinierten oder vortrainierten Bildklassifizierer in Ihren mobilen Apps bereitstellen.

Wichtige Funktionen der ImageClassifier API

  • Verarbeitung von Eingabebildern, einschließlich Drehung, Größenänderung und Farbraumkonvertierung.

  • Der Bereich des Eingabebilds, der von Interesse ist.

  • Gebietsschema für Labelkarte.

  • Schwellenwert für die Punktzahl zum Filtern von Ergebnissen.

  • Die k besten Klassifizierungsergebnisse.

  • Zulassungs- und Sperrliste für Labels.

Unterstützte Bildklassifizierungsmodelle

Die folgenden Modelle sind garantiert mit der ImageClassifier API kompatibel.

Inferenz in Java ausführen

Ein Beispiel für die Verwendung von ImageClassifier in einer Android-App finden Sie in der Referenz-App zur Bildklassifizierung.

Schritt 1: Gradle-Abhängigkeit und andere Einstellungen importieren

Kopieren Sie die Modelldatei .tflite in das Assets-Verzeichnis des Android-Moduls, in dem das Modell ausgeführt wird. Geben Sie an, dass die Datei nicht komprimiert werden soll, und fügen Sie die TensorFlow Lite-Bibliothek der build.gradle-Datei des Moduls hinzu:

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

Schritt 2: Modell verwenden

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

Weitere Optionen zum Konfigurieren von ImageClassifier finden Sie im Quellcode und in der Javadoc.

Inferenz auf iOS-Geräten ausführen

Schritt 1: Abhängigkeiten installieren

Die Task Library unterstützt die Installation mit CocoaPods. Prüfen Sie, ob CocoaPods auf Ihrem System installiert ist. Eine Anleitung finden Sie im CocoaPods-Installationsleitfaden.

Weitere Informationen zum Hinzufügen von Pods zu einem Xcode-Projekt finden Sie im CocoaPods-Leitfaden.

Fügen Sie den TensorFlowLiteTaskVision-Pod in die Podfile ein.

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

Achten Sie darauf, dass das .tflite-Modell, das Sie für die Inferenz verwenden, in Ihrem App-Bundle enthalten ist.

Schritt 2: Modell verwenden

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

Weitere Optionen zum Konfigurieren von TFLImageClassifier finden Sie im Quellcode.

Inferenz in Python ausführen

Schritt 1: pip-Paket installieren

pip install tflite-support

Schritt 2: Modell verwenden

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

Weitere Optionen zum Konfigurieren von ImageClassifier finden Sie im Quellcode.

Inferenz in C++ ausführen

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

Weitere Optionen zum Konfigurieren von ImageClassifier finden Sie im Quellcode.

Beispielergebnisse

Hier sehen Sie ein Beispiel für die Klassifizierungsergebnisse eines Vogelklassifikators.

Spatz

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

Testen Sie das einfache CLI-Demotool für ImageClassifier mit Ihrem eigenen Modell und Ihren eigenen Testdaten.

Anforderungen an die Modellkompatibilität

Für die ImageClassifier API ist ein TFLite-Modell mit obligatorischen TFLite-Modellmetadaten erforderlich. Beispiele für das Erstellen von Metadaten für Bildklassifizierer mit der TensorFlow Lite Metadata Writer API

Die kompatiblen Bildklassifizierungsmodelle sollten die folgenden Anforderungen erfüllen:

  • Eingabe-Bildtensor (kTfLiteUInt8/kTfLiteFloat32)

    • Bild-Eingabe der Größe [batch x height x width x channels].
    • Die Batch-Inferenz wird nicht unterstützt (batch muss 1 sein).
    • Es werden nur RGB-Eingaben unterstützt (channels muss 3 sein).
    • Wenn der Typ kTfLiteFloat32 ist, müssen NormalizationOptions an die Metadaten für die Eingabenormalisierung angehängt werden.

  • Tensor für Ausgabebereich (kTfLiteUInt8/kTfLiteFloat32)

    • mit N Klassen und entweder 2 oder 4 Dimensionen, d.h. [1 x N] oder [1 x 1 x 1 x N]
    • Optionale (aber empfohlene) Labelzuordnung(en) als AssociatedFile-s mit dem Typ TENSOR_AXIS_LABELS, die ein Label pro Zeile enthalten. Beispiel für eine Labeldatei Die erste solche AssociatedFile (falls vorhanden) wird verwendet, um das Feld label (in C++ als class_name bezeichnet) der Ergebnisse zu füllen. Das Feld display_name wird aus der AssociatedFile (falls vorhanden) gefüllt, deren Gebietsschema mit dem Feld display_names_locale des bei der Erstellung verwendeten ImageClassifierOptions übereinstimmt („en“ als Standard, d.h. Englisch). Wenn keine dieser Informationen verfügbar sind, wird nur das Feld index der Ergebnisse ausgefüllt.