इमेज सेगमेंटर शामिल करें

इमेज सेगमेंटर, यह अनुमान लगाते हैं कि किसी इमेज का हर पिक्सल तय क्लास में शामिल करना है. यह ऑब्जेक्ट डिटेक्शन के उलट है, जो इसमें मौजूद ऑब्जेक्ट का पता लगाता है रेक्टैंग्युलर क्षेत्र और इमेज क्लासिफ़िकेशन, जिनमें इमेज की कैटगरी इमेज. इमेज सेगमेंटेशन की खास जानकारी देखें उदाहरण के लिए इमेज सेगमेंटर के बारे में ज़्यादा जानें.

अपनी पसंद के मुताबिक इमेज सेगमेंटर को डिप्लॉय करने के लिए, टास्क लाइब्रेरी ImageSegmenter API का इस्तेमाल करें जिन्हें आपके मोबाइल ऐप्लिकेशन में पहले से ट्रेनिंग दी गई है.

Imagesegmenter API की मुख्य सुविधाएं

• इनपुट इमेज प्रोसेसिंग, जिसमें रोटेशन, साइज़ बदलना, और कलर स्पेस शामिल हैं कन्वर्ज़न होता है.

• मैप स्थान-भाषा को लेबल करें.

• दो आउटपुट टाइप, कैटगरी मास्क और कॉन्फ़िडेंस मास्क.

• दिखाने के लिए रंगीन लेबल.

इस्तेमाल किए जा सकने वाले इमेज सेगमेंटर मॉडल

ये मॉडल, ImageSegmenter के साथ काम करते हैं एपीआई.

• TensorFlow पर पहले से तैयार इमेज सेगमेंटेशन मॉडल Hub.

• मॉडल के साथ काम करने वाले मॉडल की शर्तों को पूरा करने वाले कस्टम मॉडल ज़रूरी शर्तें.

Java में अनुमान चलाएं

इमेज सेगमेंटेशन रेफ़रंस देखें ऐप्लिकेशन उदाहरण के लिए, जो Android ऐप्लिकेशन में ImageSegmenter इस्तेमाल करने का तरीका है.

पहला चरण: Gradle डिपेंडेंसी और अन्य सेटिंग इंपोर्ट करना

.tflite मॉडल फ़ाइल को, Android मॉड्यूल की ऐसेट डायरेक्ट्री में कॉपी करें जहां मॉडल को चलाया जाएगा. तय करें कि फ़ाइल कंप्रेस नहीं की जानी चाहिए, और मॉड्यूल की build.gradle फ़ाइल में TensorFlow Lite लाइब्रेरी जोड़ें:

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

दूसरा चरण: मॉडल का इस्तेमाल करना

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

सोर्स कोड और JavaScript ImageSegmenter को कॉन्फ़िगर करने के ज़्यादा विकल्पों के बारे में जानें.

iOS में अनुमान चलाएं

पहला चरण: डिपेंडेंसी इंस्टॉल करना

टास्क लाइब्रेरी में, CocoaPods का इस्तेमाल करके इंस्टॉल किए जा सकते हैं. पक्का करें कि CocoaPods आपके सिस्टम पर इंस्टॉल हो. कृपया CocoaPods को इंस्टॉल करने की जानकारी देखें गाइड देखें.

कृपया CocoaPods (CocoaPods) देखें गाइड पढ़ें. किसी Xcode प्रोजेक्ट में पॉड जोड़ना.

Podfile में TensorFlowLiteTaskVision पॉड जोड़ें.

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

पक्का करें कि अनुमान के लिए, जिस .tflite मॉडल का इस्तेमाल करना है वह इसमें मौजूद हो आपका ऐप्लिकेशन बंडल.

दूसरा चरण: मॉडल का इस्तेमाल करना

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

सोर्स देखें कोड TFLImageSegmenter को कॉन्फ़िगर करने के ज़्यादा विकल्पों के बारे में जानें.

Python में इन्फ़रेंस चलाना

पहला चरण: पीआईपी पैकेज इंस्टॉल करना

pip install tflite-support

दूसरा चरण: मॉडल का इस्तेमाल करना

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

सोर्स देखें कोड ImageSegmenter को कॉन्फ़िगर करने के ज़्यादा विकल्पों के बारे में जानें.

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

सोर्स देखें कोड ImageSegmenter को कॉन्फ़िगर करने के ज़्यादा विकल्पों के बारे में जानें.

परिणामों के उदाहरण

यहां के सेगमेंटेशन नतीजों का एक उदाहरण दिया गया है deeplab_v3, यह एक सामान्य सेगमेंटेशन मॉडल है, जो TensorFlow हब पर उपलब्ध है.

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.

सेगमेंटेशन कैटगरी का मास्क इस तरह दिखना चाहिए:

सीएलआई डेमो टूल को आज़माएं. ये टूल, ImageSegmenter की मदद से कैसे डिज़ाइन किया गया है.

मॉडल के साथ काम करने से जुड़ी ज़रूरी शर्तें

ImageSegmenter API के लिए, ज़रूरी TFLite मॉडल वाला TFLite मॉडल होना चाहिए मेटाडेटा. इमेज के लिए मेटाडेटा बनाने के उदाहरण देखें TensorFlow Lite के Metadata Writer टूल का इस्तेमाल करने वाले सेगमेंटर एपीआई.

• इनपुट इमेज टेंसर (kTfLiteUInt8/kTfLiteFloat32)

  • [batch x height x width x channels] साइज़ का इमेज इनपुट.
  • बैच का अनुमान काम नहीं करता (batch को 1 होना ज़रूरी है).
  • सिर्फ़ आरजीबी इनपुट इस्तेमाल किए जा सकते हैं (channels का नंबर 3 होना ज़रूरी है).
  • अगर टाइप kTfLiteFloat32 है, तो NormalizationOptions को इनपुट नॉर्मलाइज़ेशन के लिए मेटाडेटा से जोड़ा गया है.

• आउटपुट मास्क टेंसर: (kTfLiteUInt8/kTfLiteFloat32)

  • [batch x mask_height x mask_width x num_classes] साइज़ का टेंसर, जहां batch की वैल्यू 1 होनी चाहिए. mask_width और mask_height होनी चाहिए मॉडल से बनाए गए सेगमेंटेशन मास्क के डाइमेंशन और num_classes, मॉडल के साथ काम करने वाली क्लास की संख्या है.
  • वैकल्पिक (लेकिन सुझाया गया) लेबल मैप को TENSOR_AXIS_LABEL टाइप वाली सहयोगी फ़ाइल, जिसमें हर लेबल के लिए एक लेबल है लाइन. label को भरने के लिए पहली ऐसी AssociatedFile (अगर कोई है) का इस्तेमाल किया जाता है फ़ील्ड (जिसका नाम C++ में class_name के नाम से रखा गया है) है. display_name फ़ील्ड को AssociatedFile (अगर कोई है) से भरा जाता है, जिसका स्थान ImageSegmenterOptions में से display_names_locale फ़ील्ड का इस्तेमाल किया गया बनाने का समय (डिफ़ॉल्ट रूप से "hi"), जैसे कि अंग्रेज़ी. अगर इनमें से कोई भी उपलब्ध है, तो नतीजों का सिर्फ़ index फ़ील्ड भरा जाएगा.