Pelajari lebih lanjut pengumuman dari I/O Google AI Edge kami

Halaman ini diterjemahkan oleh Cloud Translation API.

Mengintegrasikan segmentasi gambar

Pembagi gambar memprediksi apakah setiap piksel gambar terkait dengan kelas tertentu. Hal ini berbeda dengan deteksi objek, yang mendeteksi objek dalam persegi panjang, serta klasifikasi gambar, yang mengklasifikasikan keseluruhan gambar. Lihat ringkasan segmentasi gambar contoh untuk informasi selengkapnya tentang pembagi gambar.

Gunakan Task Library ImageSegmenter API untuk men-deploy segmen gambar kustom Anda atau yang telah dilatih sebelumnya ke dalam aplikasi seluler Anda.

Fitur utama ImageSegmenter API

Input pemrosesan gambar, termasuk rotasi, perubahan ukuran, dan ruang warna konversi.
Beri label lokalitas peta.
Dua jenis output, mask kategori dan samaran.
Label berwarna untuk tujuan tampilan.

Model segmentasi gambar yang didukung

Model berikut dijamin akan kompatibel dengan ImageSegmenter Compute Engine API.

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

Menjalankan inferensi di Java

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

Langkah 1: Impor dependensi Gradle dan setelan 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
    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 guna mendapatkan opsi selengkapnya untuk mengonfigurasi ImageSegmenter.

Menjalankan inferensi di iOS

Langkah 1: Instal dependensi

Task Library mendukung penginstalan menggunakan CocoaPods. Pastikan CocoaPods diinstal di sistem Anda. Lihat penginstalan CocoaPods kami untuk melihat petunjuk.

Lihat CocoaPods untuk mengetahui detail tentang menambahkan pod ke project Xcode.

Tambahkan pod TensorFlowLiteTaskVision di Podfile.

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

Pastikan bahwa model .tflite yang akan Anda gunakan untuk inferensi ada di app bundle Anda.

Langkah 2: Menggunakan model

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

Lihat sumber kode guna mendapatkan opsi selengkapnya untuk mengonfigurasi TFLImageSegmenter.

Menjalankan inferensi di 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 sumber kode guna mendapatkan opsi selengkapnya untuk mengonfigurasi ImageSegmenter.

Menjalankan 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 sumber kode guna mendapatkan opsi selengkapnya untuk mengonfigurasi ImageSegmenter.

Hasil contoh

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

pesawat

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.

Masker kategori segmentasi akan terlihat seperti:

segmentation-output

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

Persyaratan kompatibilitas model

API ImageSegmenter mengharapkan model TFLite dengan Model TFLite wajib Metadata. Lihat contoh pembuatan metadata untuk gambar membuat segmen pengguna yang menggunakan TensorFlow Lite Metadata Writer Google Cloud Platform.

Memasukkan tensor gambar (kTfLiteUInt8/kTfLiteFloat32)
- input gambar berukuran [batch x height x width x channels].
- inferensi batch tidak didukung (batch harus 1).
- hanya input RGB yang didukung (channels harus 3).
- jika tipenya kTfLiteFloat32, NormalizationOptions diperlukan yang dilampirkan ke metadata untuk normalisasi input.
Output masks tensor: (kTfLiteUInt8/kTfLiteFloat32)
- tensor ukuran [batch x mask_height x mask_width x num_classes], dengan batch harus 1, mask_width dan mask_height adalah dimensi mask segmentasi yang dihasilkan oleh model, dan num_classes adalah jumlah class yang didukung oleh model.
- peta label opsional (tapi direkomendasikan) dapat dilampirkan sebagai AssociatedFile-s dengan jenis TENSOR_AXIS_LABEL, yang berisi satu label per garis. AssociatedFile pertama tersebut (jika ada) digunakan untuk mengisi label (dinamai sebagai class_name di C++) dari hasil tersebut. display_name diisi dari AssociatedFile (jika ada) yang lokalnya cocok dengan Kolom display_names_locale dari ImageSegmenterOptions yang digunakan di waktu pembuatan ("en" secara default, yaitu bahasa Inggris). Jika tidak satu pun dari tersedia, hanya kolom index dari hasil yang akan diisi.