Weitere Informationen zu den Ankündigungen der Google AI Edge auf der Google I/O

Diese Seite wurde von der Cloud Translation API übersetzt.

Bildsegmentierer einbinden

Bildsegmentierer sagen vorher, ob jedes Pixel eines Bildes mit einem bestimmten Klasse an. Dies steht im Gegensatz zur Objekterkennung, mit der Objekte in rechteckige Bereiche und die Bildklassifizierung, mit der die Gesamtheit Bild. Siehe Bildsegmentierung – Übersicht Beispiel finden Sie weitere Informationen zu Bildsegmentierern.

Benutzerdefinierte Bildsegmentierer mit der Task Library ImageSegmenter API bereitstellen in Ihre mobilen Apps integrieren.

Wichtige Funktionen der ImageSegmenter API

Eingabebildverarbeitung, einschließlich Drehung, Größenanpassung und Farbraum Conversion.
Sprache der Labelzuordnung.
Zwei Ausgabetypen: Kategoriemaske und Konfidenzmasken.
Farbiges Label zu Anzeigezwecken.

Unterstützte Modelle zur Bildsegmentierung

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

Vortrainierte Bildsegmentierungsmodelle in TensorFlow Hub
Benutzerdefinierte Modelle, die die Modellkompatibilität erfüllen Anforderungen.

Inferenz in Java ausführen

Siehe Referenz zur Bildsegmentierung App findest du ein Beispiel für die Verwendung von ImageSegmenter 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
ImageSegmenterOptions options =
    ImageSegmenterOptions.builder()
        .setBaseOptions(BaseOptions.builder().useGpu().build())
        .setOutputType(OutputType.CONFIDENCE_MASK)
        .build();
ImageSegmenter imageSegmenter =
    ImageSegmenter.createFromFileAndOptions(context, modelFile, options);

// Run inference
List<Segmentation> results = imageSegmenter.segment(image);

Sehen Sie sich den Quellcode und Javadoc finden Sie weitere Optionen zum Konfigurieren von ImageSegmenter.

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. Weitere Informationen finden Sie in der CocoaPods-Installation Leitfaden .

Weitere Informationen finden Sie in den CocoaPods finden Sie weitere Informationen Hinzufügen von Pods zu einem Xcode-Projekt

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: "deeplabv3",
                                            ofType: "tflite") else { return }

let options = ImageSegmenterOptions(modelPath: modelPath)

// Configure any additional options:
// options.outputType = OutputType.confidenceMasks

let segmenter = try ImageSegmenter.segmenter(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: "plane.jpg"), let mlImage = MLImage(image: image) else { return }

// Run inference
let segmentationResult = try segmenter.segment(mlImage: mlImage)

Objective C

// Imports
#import <TensorFlowLiteTaskVision/TensorFlowLiteTaskVision.h>

// Initialization
NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"deeplabv3" ofType:@"tflite"];

TFLImageSegmenterOptions *options =
    [[TFLImageSegmenterOptions alloc] initWithModelPath:modelPath];

// Configure any additional options:
// options.outputType = TFLOutputTypeConfidenceMasks;

TFLImageSegmenter *segmenter = [TFLImageSegmenter imageSegmenterWithOptions:options
                                                                      error:nil];

// Convert the input image to MLImage.
UIImage *image = [UIImage imageNamed:@"plane.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
TFLSegmentationResult *segmentationResult =
    [segmenter segmentWithGMLImage:gmlImage error:nil];

Siehe Quelle Code finden Sie weitere Optionen zum Konfigurieren von TFLImageSegmenter.

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)
segmentation_options = processor.SegmentationOptions(
    output_type=processor.SegmentationOptions.output_type.CATEGORY_MASK)
options = vision.ImageSegmenterOptions(base_options=base_options, segmentation_options=segmentation_options)
segmenter = vision.ImageSegmenter.create_from_options(options)

# Alternatively, you can create an image segmenter in the following manner:
# segmenter = vision.ImageSegmenter.create_from_file(model_path)

# Run inference
image_file = vision.TensorImage.create_from_file(image_path)
segmentation_result = segmenter.segment(image_file)

Siehe Quelle Code finden Sie weitere Optionen zum Konfigurieren von ImageSegmenter.

Inferenz in C++ ausführen

// Initialization
ImageSegmenterOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_path);
std::unique_ptr<ImageSegmenter> image_segmenter = ImageSegmenter::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 SegmentationResult result = image_segmenter->Segment(*frame_buffer).value();

Siehe Quelle Code finden Sie weitere Optionen zum Konfigurieren von ImageSegmenter.

Beispielergebnisse

Hier ist ein Beispiel für die Segmentierungsergebnisse deeplab_v3 ein generisches Segmentierungsmodell, das auf TensorFlow Hub verfügbar ist.

mit dem Flugzeug

Color Legend:
 (r: 000, g: 000, b: 000):
  index       : 0
  class name  : background
 (r: 128, g: 000, b: 000):
  index       : 1
  class name  : aeroplane

# (omitting multiple lines for conciseness) ...

 (r: 128, g: 192, b: 000):
  index       : 19
  class name  : train
 (r: 000, g: 064, b: 128):
  index       : 20
  class name  : tv
Tip: use a color picker on the output PNG file to inspect the output mask with
this legend.

Die Maske für die Segmentierungskategorie sollte wie folgt aussehen:

segmentation-output

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

Anforderungen an die Modellkompatibilität

Die ImageSegmenter API erwartet ein TFLite-Modell mit dem obligatorischen TFLite-Modell Metadaten. Beispiele zum Erstellen von Metadaten für ein Bild ansehen Segmentierer mit dem TensorFlow Lite Metadata Writer verwenden API hinzu.

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.
Ausgabemaskentensor: (kTfLiteUInt8/kTfLiteFloat32)
- Tensor der Größe [batch x mask_height x mask_width x num_classes], wobei batch muss 1 sein, mask_width und mask_height sind die Dimensionen der Segmentierungsmasken, die vom Modell erzeugt wurden, und num_classes ist die Anzahl der vom Modell unterstützten Klassen.
- optionale (aber empfohlene) Labelzuordnung(en) kann/können als AssociatedFile-s vom Typ TENSOR_AXIS_LABELS mit einem Label pro Zeile. Die erste AssociatedFile (falls vorhanden) wird zum Füllen von label verwendet (mit dem Namen class_name in C++) der Ergebnisse. Das display_name wird aus AssociatedFile (falls vorhanden) gefüllt, deren Gebietsschema mit dem Feld display_names_locale von ImageSegmenterOptions verwendet bei Erstellungszeit (standardmäßig "en", also Englisch). Wenn keiner dieser verfügbar ist, wird nur das Feld index der Ergebnisse gefüllt.