Bu sayfa, Cloud Translation API ile çevrilmiştir.

Görüntü segmenterlerini entegre edin

Görüntü bölütleyiciler, bir görüntünün her pikselinin belirli bir sınıfla ilişkili olup olmadığını tahmin eder. Bu, dikdörtgen bölgelerdeki nesneleri algılayan nesne algılama ve genel görüntüyü sınıflandıran görüntü sınıflandırmasının aksinedir. Görüntü bölümleyiciler hakkında daha fazla bilgi için görüntü bölümlendirmeye genel bakışa bakın.

Özel görüntü segmenterlerinizi veya önceden eğitilmiş olanları mobil uygulamalarınıza dağıtmak için Görev Kitaplığı ImageSegmenter API'sini kullanın.

ImageSegmenter API'sinin temel özellikleri

Döndürme, yeniden boyutlandırma ve renk alanı dönüştürme dahil olmak üzere girdi görüntü işleme.
Harita yerel ayarını etiketleyin.
İki çıktı türü, kategori maskesi ve güven maskesi.
Teşhir amaçlı renkli etiket.

Desteklenen görüntü segmenter modelleri

Aşağıdaki modellerin ImageSegmenter API ile uyumlu olması garanti edilmektedir.

TensorFlow Hub'da önceden eğitilmiş görüntü segmentasyon modelleri .
Model uyumluluk gereksinimlerini karşılayan özel modeller.

Java'da çıkarımı çalıştır

Bir Android uygulamasında ImageSegmenter nasıl kullanılacağına ilişkin bir örnek için Görüntü Segmentasyonu referans uygulamasına bakın.

Adım 1: Gradle bağımlılığını ve diğer ayarları içe aktarın

.tflite model dosyasını, modelin çalıştırılacağı Android modülünün varlıklar dizinine kopyalayın. Dosyanın sıkıştırılmaması gerektiğini belirtin ve TensorFlow Lite kitaplığını modülün build.gradle dosyasına ekleyin:

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 (NNAPI is included)
    implementation 'org.tensorflow:tensorflow-lite-task-vision'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin'
}

Adım 2: Modeli kullanma

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

ImageSegmenter'ı yapılandırmak için daha fazla seçenek için kaynak koduna ve ImageSegmenter .

iOS'ta çıkarımı çalıştır

Adım 1: Bağımlılıkları yükleyin

Görev Kitaplığı, CocoaPods kullanılarak kurulumu destekler. CocoaPods'un sisteminizde kurulu olduğundan emin olun. Talimatlar için lütfen CocoaPods kurulum kılavuzuna bakın.

Bir Xcode projesine bölme eklemeyle ilgili ayrıntılar için lütfen CocoaPods kılavuzuna bakın.

TensorFlowLiteTaskVision bölmesini Pod dosyasına ekleyin.

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

Çıkarım için kullanacağınız .tflite modelinin uygulama paketinizde bulunduğundan emin olun.

Adım 2: Modeli kullanma

Süratli

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

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

TFLImageSegmenter yapılandırmak için daha fazla seçenek için kaynak koduna bakın.

Python'da çıkarımı çalıştır

Adım 1: pip paketini kurun

pip install tflite-support

Adım 2: Modeli kullanma

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

ImageSegmenter yapılandırmak için daha fazla seçenek için kaynak koduna bakın.

Çıkarımı C++ ile çalıştırın

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

ImageSegmenter yapılandırmak için daha fazla seçenek için kaynak koduna bakın.

Örnek sonuçlar

Burada, TensorFlow Hub'da bulunan genel bir segmentasyon modeli olan deeplab_v3'ün segmentasyon sonuçlarına bir örnek verilmiştir.

uçak

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.

Segmentasyon kategori maskesi şöyle görünmelidir:

segmentasyon-çıktı

Kendi model ve test verilerinizle ImageSegmenter için basit CLI demo aracını deneyin.

Model uyumluluğu gereksinimleri

ImageSegmenter API, zorunlu TFLite Model Meta Verilerine sahip bir TFLite modeli bekler. TensorFlow Lite Meta Veri Yazıcı API'sını kullanarak görüntü segmenterleri için meta veri oluşturma örneklerine bakın.

Giriş görüntü tensörü (kTfLiteUInt8/kTfLiteFloat32)
- [batch x height x width x channels] boyutunda görüntü girişi.
- toplu çıkarım desteklenmiyor ( batch işin 1 olması gerekiyor).
- yalnızca RGB girişleri desteklenir ( channels 3 olması gerekir).
- tür kTfLiteFloat32 ise, normalizationOptions'ın giriş normalleştirmesi için meta verilere eklenmesi gerekir.
Çıkış maskeleri tensörü: (kTfLiteUInt8/kTfLiteFloat32)
- boyut tensörü [batch x mask_height x mask_width x num_classes] , burada batch 1 olması gerekir, mask_width ve mask_height model tarafından üretilen segmentasyon maskelerinin boyutlarıdır ve num_classes model tarafından desteklenen sınıfların sayısıdır.
- isteğe bağlı (ancak önerilen) etiket haritaları, satır başına bir etiket içeren TENSOR_AXIS_LABELS türüyle AssociatedFile-s olarak eklenebilir. Bu tür ilk AssociatedFile (varsa), sonuçların label alanını (C++'da class_name olarak adlandırılır) doldurmak için kullanılır. display_name alanı, yerel ayarı oluşturma sırasında kullanılan ImageSegmenterOptions display_names_locale alanıyla eşleşen AssociatedFile'dan (varsa) doldurulur (varsayılan olarak "en", yani İngilizce). Bunların hiçbiri mevcut değilse, sonuçların yalnızca index alanı doldurulacaktır.