Conheça o LiteRT: o ambiente de execução de alto desempenho do Google para IA no dispositivo, antes conhecido como TensorFlow Lite.

Esta página foi traduzida pela API Cloud Translation.

Integrar segmentos de imagem

Os segmentos de imagem preveem se cada pixel de uma imagem está associado a um determinada classe. Isso é diferente da detecção de objetos, que detecta objetos em as regiões retangulares e a classificação de imagem, que classifica imagem. Consulte a visão geral da segmentação de imagens exemplo para mais informações sobre segmentadores de imagem.

Use a API Task Library ImageSegmenter para implantar seus segmentadores de imagem personalizados ou pré-treinados aos seus apps para dispositivos móveis.

Principais recursos da API ImageSegmentr

Processamento de imagens de entrada, incluindo rotação, redimensionamento e espaço de cores e conversão em massa.
Localidade do mapa do rótulo.
Dois tipos de saída: máscara de categoria e máscaras de confiança.
Marcador colorido para fins de exibição.

Modelos de segmento de imagem com suporte

Os modelos a seguir têm a garantia de compatibilidade com o ImageSegmenter API.

Os modelos pré-treinados de segmentação de imagens no TensorFlow Hub.
Modelos personalizados que atendem aos requisitos de compatibilidade do modelo .

Executar inferência em Java

Consulte a referência de segmentação de imagem App para conferir um exemplo de como usar ImageSegmenter em um app Android.

Etapa 1: importar a dependência do Gradle e outras configurações

Copie o arquivo modelo .tflite para o diretório de assets do módulo Android. em que o modelo será executado. Especifique que o arquivo não deve ser compactado. Adicione a biblioteca do TensorFlow Lite ao arquivo build.gradle do módulo:

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

Etapa 2: uso do modelo

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

Consulte o código-fonte e javadoc para mais opções de configuração do ImageSegmenter.

Executar inferência no iOS

Etapa 1: instalar as dependências

A biblioteca de tarefas oferece suporte à instalação usando o CocoaPods. Verifique se o CocoaPods está instalado no seu sistema. Consulte a página sobre a instalação do CocoaPods guia para obter instruções.

Consulte a documentação do CocoaPods guia (em inglês) para detalhes sobre adicionar pods a um projeto do Xcode.

Adicione o pod TensorFlowLiteTaskVision ao Podfile.

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

O modelo .tflite que você vai usar para inferência precisa estar presente seu pacote de apps.

Etapa 2: uso do modelo

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

Consulte a fonte código para mais opções de configuração do TFLImageSegmenter.

Executar inferência em Python

Etapa 1: instalar o pacote pip

pip install tflite-support

Etapa 2: uso do modelo

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

Consulte a fonte código para mais opções de configuração do ImageSegmenter.

Executar inferência em 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();

Consulte a fonte código para mais opções de configuração do ImageSegmenter.

Resultados de exemplo

Aqui está um exemplo dos resultados da segmentação deeplab_v3 disponível no TensorFlow Hub.

avião

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.

A máscara da categoria de segmentação deve ter esta aparência:

segmentation-output

Teste a ferramenta de demonstração simples da CLI para ImageSegmenter com seu próprio modelo e dados de teste.

Requisitos de compatibilidade do modelo

A API ImageSegmenter espera um modelo TFLite com o modelo TFLite obrigatório Metadados. Veja exemplos de criação de metadados para imagens usando o Gravador de metadados do TensorFlow Lite API.

Tensor de imagem de entrada (kTfLiteUInt8/kTfLiteFloat32)
- entrada de imagem de tamanho [batch x height x width x channels].
- A inferência em lote não é compatível (batch precisa ser 1).
- somente entradas RGB são compatíveis (channels precisa ser 3).
- se o tipo for kTfLiteFloat32, as NormalizationOptions devem ser anexada aos metadados para normalização de entrada.
Tensor de máscara de saída: (kTfLiteUInt8/kTfLiteFloat32)
- tensor de tamanho [batch x mask_height x mask_width x num_classes], em que batch deve ser 1, mask_width e mask_height são os dimensões das máscaras de segmentação produzidas pelo modelo e num_classes é o número de classes compatíveis com o modelo.
- mapas de marcadores opcionais (mas recomendados) podem ser anexados como AssociatedFile-s com tipo TENSOR_AXIS_LABELS, contendo um rótulo por linha O primeiro AssociatedFile (se houver) é usado para preencher o label (nomeado como class_name em C++) dos resultados. O display_name é preenchido pelo AssociatedFile (se houver) cuja localidade corresponde ao Campo display_names_locale do ImageSegmenterOptions usado em hora de criação ("en" por padrão, isto é, inglês). Se nenhuma delas for disponível, apenas o campo index dos resultados será preenchido.