Przedstawiamy LiteRT: wydajne środowisko wykonawcze Google do obsługi AI na urządzeniu, wcześniej znane jako TensorFlow Lite.

Ta strona została przetłumaczona przez Cloud Translation API.

Zintegruj detektory obiektów

Detektory obiektów mogą identyfikować, które ze znanych obiektów mogą być obecne i dostarczają informacji o ich pozycjach na danym obrazie lub filmie . Detektor obiektów jest trenowany tak, aby wykrywał obecność i lokalizację wielu klas obiektów. Na przykład model może być trenowany z wykorzystaniem obrazów zawierające różne kawałki owoców oraz oznaczone etykietą, która określa klasa owoców, które reprezentują (np. jabłko, banan lub truskawka), gdzie na obrazie jest każdy obiekt. Zobacz przykład wykrywania obiektów .

Wdrażanie niestandardowych wzorców do wykrywania obiektów przy użyciu interfejsu Task Library API ObjectDetector lub już wytrenowanych w aplikacjach mobilnych.

Najważniejsze funkcje interfejsu ObjectDetector API

Przetwarzanie obrazu, w tym obrót, zmiana rozmiaru i przestrzeń kolorów konwersji.
Język mapy etykiet.
Próg oceny do filtrowania wyników.
Wyniki wykrywania Top-K.
Listy dozwolonych i odrzuconych etykiet.

Obsługiwane modele wykrywania obiektów

Te modele gwarantują zgodność z modelem ObjectDetector API.

wstępnie wytrenowane modele wykrywania obiektów w TensorFlow Hub.
Modele utworzone przez AutoML Vision Edge Object Detection
Modele utworzone przez Kreator modeli TensorFlow Lite do wykrywania obiektów
Modele niestandardowe, które spełniają wymaganiami dotyczącymi zgodności z modelem.

Uruchom wnioskowanie w Javie

Zobacz Aplikacja referencyjna do wykrywania obiektów pokazuje, jak używać właściwości ObjectDetector w aplikacji na Androida.

Krok 1. Zaimportuj zależność Gradle i inne ustawienia

Skopiuj plik modelu .tflite do katalogu zasobów modułu Androida w którym będzie uruchamiany model. Określ, że plik nie powinien być skompresowany. dodaj bibliotekę TensorFlow Lite do pliku build.gradle modułu:

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

Krok 2. Korzystanie z modelu

// Initialization
ObjectDetectorOptions options =
    ObjectDetectorOptions.builder()
        .setBaseOptions(BaseOptions.builder().useGpu().build())
        .setMaxResults(1)
        .build();
ObjectDetector objectDetector =
    ObjectDetector.createFromFileAndOptions(
        context, modelFile, options);

// Run inference
List<Detection> results = objectDetector.detect(image);

Zobacz kod źródłowy i javadoc , aby uzyskać więcej opcji konfigurowania ObjectDetector.

Uruchom wnioskowanie w iOS

Krok 1. Zainstaluj zależności

Biblioteka zadań obsługuje instalację za pomocą CocoaPods. Upewnij się, że CocoaPods jest zainstalowany w systemie. Zapoznaj się z Przewodnik instalacji CocoaPods .

Zapoznaj się z Przewodnik po CocoaPods dotyczący dowiesz się więcej o dodawaniu podów do projektu Xcode.

Dodaj pod plik TensorFlowLiteTaskVision w pliku Podfile.

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

Sprawdź, czy dostępny jest model .tflite, którego będziesz używać do wnioskowania pakietu aplikacji.

Krok 2. Korzystanie z modelu

Swift

// Imports
import TensorFlowLiteTaskVision

// Initialization
guard let modelPath = Bundle.main.path(forResource: "ssd_mobilenet_v1",
                                            ofType: "tflite") else { return }

let options = ObjectDetectorOptions(modelPath: modelPath)

// Configure any additional options:
// options.classificationOptions.maxResults = 3

let detector = try ObjectDetector.detector(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: "cats_and_dogs.jpg"), let mlImage = MLImage(image: image) else { return }

// Run inference
let detectionResult = try detector.detect(mlImage: mlImage)

Objective-C

// Imports
#import <TensorFlowLiteTaskVision/TensorFlowLiteTaskVision.h>

// Initialization
NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"ssd_mobilenet_v1" ofType:@"tflite"];

TFLObjectDetectorOptions *options = [[TFLObjectDetectorOptions alloc] initWithModelPath:modelPath];

// Configure any additional options:
// options.classificationOptions.maxResults = 3;

TFLObjectDetector *detector = [TFLObjectDetector objectDetectorWithOptions:options
                                                                     error:nil];

// Convert the input image to MLImage.
UIImage *image = [UIImage imageNamed:@"dogs.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
TFLDetectionResult *detectionResult = [detector detectWithGMLImage:gmlImage error:nil];

Zobacz kod źródłowy , aby uzyskać więcej opcji konfigurowania TFLObjectDetector.

Uruchom wnioskowanie w Pythonie

Krok 1. Zainstaluj pakiet pip

pip install tflite-support

Krok 2. Korzystanie z modelu

# 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)
detection_options = processor.DetectionOptions(max_results=2)
options = vision.ObjectDetectorOptions(base_options=base_options, detection_options=detection_options)
detector = vision.ObjectDetector.create_from_options(options)

# Alternatively, you can create an object detector in the following manner:
# detector = vision.ObjectDetector.create_from_file(model_path)

# Run inference
image = vision.TensorImage.create_from_file(image_path)
detection_result = detector.detect(image)

Zobacz kod źródłowy , aby uzyskać więcej opcji konfigurowania ObjectDetector.

Uruchom wnioskowanie w C++

// Initialization
ObjectDetectorOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_path);
std::unique_ptr<ObjectDetector> object_detector = ObjectDetector::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 DetectionResult result = object_detector->Detect(*frame_buffer).value();

Zobacz kod źródłowy , aby uzyskać więcej opcji konfigurowania ObjectDetector.

Przykładowe wyniki

Oto przykład wyników wykrycia ssd mobilenet wersja 1 z TensorFlow Hub.

psy

Results:
 Detection #0 (red):
  Box: (x: 355, y: 133, w: 190, h: 206)
  Top-1 class:
   index       : 17
   score       : 0.73828
   class name  : dog
 Detection #1 (green):
  Box: (x: 103, y: 15, w: 138, h: 369)
  Top-1 class:
   index       : 17
   score       : 0.73047
   class name  : dog

Renderuj ramki ograniczające na obraz wejściowy:

wynik wykrywania

Wypróbuj prostą Narzędzie w wersji demonstracyjnej interfejsu wiersza poleceń ObjectDetector z własnym modelem i danymi testowymi.

Wymagania dotyczące zgodności z modelem

Interfejs API ObjectDetector wymaga modelu TFLite z obowiązkowym ustawieniem Metadane modelu TFLite. Zobacz przykłady tworzenia metadanych dla detektorów obiektów korzystających z TensorFlow Lite Metadata Writer API.

Zgodne modele wykrywania obiektów powinny spełniać te wymagania:

Wejściowy tensor obrazu: (kTfLiteUInt8/kTfLiteFloat32)
- plik do wprowadzania obrazu o rozmiarze [batch x height x width x channels].
- wnioskowanie wsadowe nie jest obsługiwane (wartość batch musi wynosić 1).
- obsługiwane są tylko wejścia RGB (channels musi mieć wartość 3).
- jeśli typ to kTfLiteFloat32, element NormalizationOptions musi mieć wartość do metadanych w celu normalizacji danych wejściowych.
Tensory wyjściowe muszą być 4 wyjściami operacji DetectionPostProcess, tj.:
- Tensor lokalizacji (kTfLiteFloat32)
  - tensor rozmiaru [1 x num_results x 4], tablica wewnętrzna reprezentująca ramki ograniczające w formie [góra, lewo, prawo, dół].
  - Do metadanych należy dołączyć właściwości BoundingBox Property i muszą określić type=BOUNDARIES oraz `coordinate_type=RATIO.
- Tensor klas (kTfLiteFloat32)
  - tensor rozmiaru [1 x num_results], każda wartość reprezentująca indeks całkowity klasy.
  - opcjonalne (ale zalecane) mapy etykiet można załączyć jako Powiązane pliki z typem TENSOR_VALUE_LABELS, zawierające 1 etykietę na wiersz. Zobacz przykładowego pliku etykiet. Pierwszy taki powiązany plik (jeśli istnieje) służy do wypełnienia class_name pola wyników. Pole display_name ma wartość wypełniona z elementu AssociatedFile (jeśli istnieje), którego język zgodny z Pole display_names_locale z ObjectDetectorOptions wykorzystywane podczas czas utworzenia („en” – domyślnie „en”, czyli w języku angielskim). Jeśli żadna z tych opcji nie pasuje dostępne, zostanie wypełnione tylko pole index wyników.
- Tensor wyników (kTfLiteFloat32)
  - tensor rozmiaru [1 x num_results], każda wartość reprezentująca wykrywanego obiektu.
- Liczba tensora wykrywania (kTfLiteFloat32)
  - liczba całkowita num_results w postaci tensora rozmiaru [1].