Bildklassifikatoren einbinden

Die Bildklassifizierung ist eine gängige Methode des maschinellen Lernens, um zu ermitteln, Bild repräsentiert. Wir möchten beispielsweise wissen, welche Art von Tier zu sehen ist. in einem Bild. Die Aufgabe, vorherzusagen, was ein Bild darstellt, Bildklassifizierung. Ein Bildklassifikator wird trainiert, unterschiedliche Bildklassen an. So kann ein Modell z. B. trainiert werden, Fotos zu erkennen die drei verschiedene Tierarten darstellen: Kaninchen, Hamster und Hunde. Weitere Informationen finden Sie unter die Beispiel für die Bildklassifizierung finden Sie weitere Informationen zu Bildklassifikatoren.

Benutzerdefiniertes Image mit der Task Library ImageClassifier API bereitstellen oder vortrainierte Klassifikatoren in Ihre mobilen Apps einbinden.

Wichtige Funktionen der ImageClassifier API

  • Eingabebildverarbeitung, einschließlich Drehung, Größenanpassung und Farbraum Conversion.

  • Interessanter Bereich des Eingabebilds.

  • Sprache der Labelzuordnung.

  • Punktzahlgrenzwert zum Filtern von Ergebnissen.

  • Top-K-Klassifizierungsergebnisse.

  • Zulassungsliste und Sperrliste für Labels.

Unterstützte Bildklassifikatormodelle

Die folgenden Modelle sind garantiert kompatibel mit dem ImageClassifier der API erstellen.

Inferenz in Java ausführen

Weitere Informationen finden Sie in der Referenz-App zur Bildklassifizierung findest du ein Beispiel für die Verwendung von ImageClassifier in einer Android-App.

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

Kopieren Sie die Modelldatei .tflite in das Asset-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 der Datei build.gradle des Moduls die TensorFlow Lite-Bibliothek 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 Informationen finden Sie in der Quellcode und Javadoc finden Sie weitere Optionen zum Konfigurieren von ImageClassifier.

Inferenz unter iOS ausführen

Schritt 1: Abhängigkeiten installieren

Die Task Library unterstützt die Installation mit CocoaPods. Achte darauf, dass CocoaPods auf Ihrem System installiert ist. In der Installationsanleitung für CocoaPods .

In der CocoaPods-Leitfaden für wie Sie Pods zu einem Xcode-Projekt hinzufügen.

Fügen Sie der Podfile-Datei den Pod TensorFlowLiteTaskVision hinzu.

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

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

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 Informationen finden Sie in der Quellcode finden Sie weitere Optionen zum Konfigurieren von TFLImageClassifier.

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 Informationen finden Sie in der Quellcode finden Sie weitere Optionen zum Konfigurieren von ImageClassifier.

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 Informationen finden Sie in der Quellcode finden Sie weitere Optionen zum Konfigurieren von ImageClassifier.

Beispielergebnisse

Hier ist ein Beispiel für die Klassifizierungsergebnisse eines Vogelklassifikator.

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

Probieren Sie die einfache CLI-Demotool für ImageClassifier mit eigenen Modell- und Testdaten.

Anforderungen an die Modellkompatibilität

Die ImageClassifier API erwartet ein TFLite-Modell mit obligatorischen TFLite-Modellmetadaten. Beispiele zum Erstellen von Metadaten für Bildklassifikatoren mit der TensorFlow Lite Metadata Writer API

Die kompatiblen Bildklassifikatormodelle müssen die folgenden Anforderungen erfüllen:

  • Eingabebildtensor (kTfLiteUInt8/kTfLiteFloat32)

    • Bildeingabe mit der Größe [batch x height x width x channels].
    • 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.
  • Tensor für Ausgabewert (kTfLiteUInt8/kTfLiteFloat32)

    • mit N-Klassen und entweder 2 oder 4 Dimensionen, z.B. [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 mit einem Label pro Zeile. Weitere Informationen finden Sie in der Beispiel-Labeldatei. Die erste AssociatedFile (falls vorhanden) wird zum Ausfüllen des Felds label verwendet (namens class_name in C++) der Ergebnisse. Das Feld display_name wird aus der AssociatedFile (falls vorhanden) gefüllt, deren Gebietsschema mit der Feld display_names_locale von ImageClassifierOptions verwendet bei Erstellungszeit (standardmäßig "en", also Englisch). Wenn keiner dieser verfügbar ist, wird nur das Feld index der Ergebnisse gefüllt.