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.
Modelle erstellt von TensorFlow Lite Model Maker für die Bildklassifizierung
Die vortrainierten Bildklassifizierungsmodellen auf TensorFlow Hub.
Modelle erstellt von AutoML Vision Edge-Bildklassifizierung.
Benutzerdefinierte Modelle, die den Anforderungen an die Modellkompatibilität.
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.
Inferenzen in iOS ausführen
Schritt 1: Abhängigkeiten installieren
Die Task Library unterstützt die Installation mit CocoaPods. Achten Sie 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.
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 (
batchmuss 1 sein). - Es werden nur RGB-Eingaben unterstützt (
channelsmuss 3 sein). - Wenn der Typ kTfLiteFloat32 ist, müssen NormalizationOptions an die Metadaten für die Eingabenormalisierung angehängt.
- Bildeingabe mit der Größe
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
labelverwendet (namensclass_namein C++) der Ergebnisse. Das Felddisplay_namewird aus der AssociatedFile (falls vorhanden) gefüllt, deren Gebietsschema mit der Felddisplay_names_localevonImageClassifierOptionsverwendet bei Erstellungszeit (standardmäßig "en", also Englisch). Wenn keiner dieser verfügbar ist, wird nur das Feldindexder Ergebnisse gefüllt.
- mit