Halaman ini diterjemahkan oleh Cloud Translation API.

Integrasikan segmenter gambar

Segmenter gambar memprediksi apakah setiap piksel gambar dikaitkan dengan kelas tertentu. Hal ini berbeda dengan deteksi objek , yang mendeteksi objek di daerah persegi panjang, dan klasifikasi gambar , yang mengklasifikasikan gambar secara keseluruhan. Lihat ikhtisar segmentasi gambar untuk informasi lebih lanjut tentang segmenter gambar.

Gunakan API ImageSegmenter Pustaka Tugas untuk menerapkan segmenter gambar khusus atau yang sudah terlatih ke dalam aplikasi seluler Anda.

Fitur utama dari ImageSegmenter API

Pemrosesan gambar input, termasuk rotasi, pengubahan ukuran, dan konversi ruang warna.
Beri label lokal peta.
Dua jenis output, kategori topeng dan topeng kepercayaan.
Label berwarna untuk tujuan tampilan.

Model segmenter gambar yang didukung

Model berikut dijamin kompatibel dengan ImageSegmenter API.

Model segmentasi gambar yang telah dilatih sebelumnya di TensorFlow Hub .
Model khusus yang memenuhi persyaratan kompatibilitas model .

Jalankan inferensi di Java

Lihat aplikasi referensi Segmentasi Gambar untuk contoh cara menggunakan ImageSegmenter di aplikasi Android.

Langkah 1: Impor ketergantungan Gradle dan pengaturan lainnya

Salin file model .tflite ke direktori aset modul Android tempat model akan dijalankan. Tentukan bahwa file tidak boleh dikompresi, dan tambahkan library TensorFlow Lite ke file build.gradle modul:

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

Langkah 2: Menggunakan model

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

Lihat kode sumber dan javadoc untuk opsi lebih lanjut untuk mengonfigurasi ImageSegmenter .

Jalankan inferensi di iOS

Langkah 1: Instal dependensi

Pustaka Tugas mendukung penginstalan menggunakan CocoaPods. Pastikan CocoaPods diinstal pada sistem Anda. Silakan lihat panduan instalasi CocoaPods untuk instruksi.

Silakan lihat panduan CocoaPods untuk detail tentang menambahkan pod ke proyek Xcode.

Tambahkan pod TensorFlowLiteTaskVision di Podfile.

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

Pastikan model .tflite yang akan Anda gunakan untuk inferensi ada di bundel aplikasi Anda.

Langkah 2: Menggunakan model

Cepat

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

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

Lihat kode sumber untuk opsi lebih lanjut untuk mengonfigurasi TFLImageSegmenter .

Jalankan inferensi dengan Python

Langkah 1: Instal paket pip

pip install tflite-support

Langkah 2: Menggunakan model

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

Lihat kode sumber untuk opsi lebih lanjut untuk mengonfigurasi ImageSegmenter .

Jalankan inferensi di C++

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

Lihat kode sumber untuk opsi lebih lanjut untuk mengonfigurasi ImageSegmenter .

Contoh hasil

Berikut adalah contoh hasil segmentasi deeplab_v3 , model segmentasi umum yang tersedia di TensorFlow Hub.

pesawat terbang

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.

Topeng kategori segmentasi akan terlihat seperti:

segmentasi-keluaran

Cobalah alat demo CLI sederhana untuk ImageSegmenter dengan model dan data uji Anda sendiri.

Persyaratan kompatibilitas model

API ImageSegmenter mengharapkan model TFLite dengan Metadata Model TFLite wajib. Lihat contoh pembuatan metadata untuk segmenter gambar menggunakan TensorFlow Lite Metadata Writer API .

Tensor gambar masukan (kTfLiteUInt8/kTfLiteFloat32)
- masukan gambar ukuran [batch x height x width x channels] .
- inferensi batch tidak didukung ( batch harus 1).
- hanya input RGB yang didukung ( channels harus 3).
- jika tipenya adalah kTfLiteFloat32, NormalizationOptions harus dilampirkan ke metadata untuk normalisasi input.
Tensor masker keluaran: (kTfLiteUInt8/kTfLiteFloat32)
- tensor ukuran [batch x mask_height x mask_width x num_classes] , di mana batch harus 1, mask_width dan mask_height adalah dimensi topeng segmentasi yang dihasilkan oleh model, dan num_classes adalah jumlah kelas yang didukung oleh model.
- peta label opsional (tetapi disarankan) dapat dilampirkan sebagai AssociatedFile-s dengan tipe TENSOR_AXIS_LABELS, yang berisi satu label per baris. AssociatedFile yang pertama (jika ada) digunakan untuk mengisi bidang label (dinamakan sebagai class_name dalam C++) dari hasil. Bidang display_name diisi dari AssociatedFile (jika ada) yang lokalnya cocok dengan bidang display_names_locale dari ImageSegmenterOptions yang digunakan pada waktu pembuatan ("en" secara default, yaitu bahasa Inggris). Jika tidak ada yang tersedia, hanya bidang index hasil yang akan diisi.