Introducing LiteRT: Google's high-performance runtime for on-device AI, formerly known as TensorFlow Lite. Learn more

Kjo faqe është përkthyer nga Cloud Translation API.

Integroni detektorë objektesh

Detektorët e objekteve mund të identifikojnë se cili nga një grup i njohur objektesh mund të jetë i pranishëm dhe të sigurojë informacion rreth pozicioneve të tyre brenda imazhit të dhënë ose një transmetimi video. Një detektor objektesh është trajnuar për të zbuluar praninë dhe vendndodhjen e klasave të shumta të objekteve. Për shembull, një model mund të trajnohet me imazhe që përmbajnë copa të ndryshme frutash, së bashku me një etiketë që specifikon klasën e frutave që përfaqësojnë (p.sh. një mollë, një banane ose një luleshtrydhe) dhe të dhëna që specifikojnë se ku shfaqet çdo objekt në imazhin. Shihni shembullin e zbulimit të objekteve për më shumë informacion rreth detektorëve të objekteve.

Përdorni Task Library ObjectDetector API për të vendosur detektorët tuaj të personalizuar të objekteve ose ato të paratrajnuara në aplikacionet tuaja celulare.

Karakteristikat kryesore të ObjectDetector API

Përpunimi i imazhit në hyrje, duke përfshirë rrotullimin, ndryshimin e madhësisë dhe konvertimin e hapësirës së ngjyrave.
Vendndodhja e etiketës së hartës.
Pragu i rezultatit për të filtruar rezultatet.
Rezultatet e zbulimit Top-k.
Etiketoni listën e lejeve dhe refuzoni.

Modele të mbështetura të detektorëve të objekteve

Modelet e mëposhtme janë të garantuara të jenë të pajtueshme me ObjectDetector API.

Modelet e para-trajnuara të zbulimit të objekteve në TensorFlow Hub .
Modelet e krijuara nga AutoML Vision Edge Object Detection .
Modele të krijuara nga TensorFlow Lite Model Maker për detektor objektesh .
Modele të personalizuara që plotësojnë kërkesat e përputhshmërisë së modelit .

Ekzekutoni konkluzionet në Java

Shikoni aplikacionin e referencës "Zbulimi i objekteve" për një shembull se si të përdorni ObjectDetector në një aplikacion Android.

Hapi 1: Importoni varësinë Gradle dhe cilësime të tjera

Kopjoni skedarin e modelit .tflite në drejtorinë e aseteve të modulit Android ku do të ekzekutohet modeli. Specifikoni që skedari të mos jetë i ngjeshur dhe shtoni bibliotekën TensorFlow Lite në skedarin build.gradle të modulit:

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

Hapi 2: Përdorimi i modelit

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

Shikoni kodin burimor dhe javadoc për më shumë opsione për të konfiguruar ObjectDetector .

Ekzekutoni konkluzionet në iOS

Hapi 1: Instaloni varësitë

Biblioteka e detyrave mbështet instalimin duke përdorur CocoaPods. Sigurohuni që CocoaPods të jetë i instaluar në sistemin tuaj. Ju lutemi shikoni udhëzuesin e instalimit të CocoaPods për udhëzime.

Ju lutemi shikoni udhëzuesin CocoaPods për detaje mbi shtimin e pods në një projekt Xcode.

Shtoni podin TensorFlowLiteTaskVision në Podfile.

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

Sigurohuni që modeli .tflite që do të përdorni për konkluzion është i pranishëm në paketën tuaj të aplikacionit.

Hapi 2: Përdorimi i modelit

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)

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

Shihni kodin burimor për më shumë opsione për të konfiguruar TFLObjectDetector .

Ekzekutoni konkluzionet në Python

Hapi 1: Instaloni paketën pip

pip install tflite-support

Hapi 2: Përdorimi i modelit

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

Shikoni kodin burimor për më shumë opsione për të konfiguruar ObjectDetector .

Ekzekutoni konkluzionet në 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();

Shikoni kodin burimor për më shumë opsione për të konfiguruar ObjectDetector .

Shembuj të rezultateve

Këtu është një shembull i rezultateve të zbulimit të ssd mobilenet v1 nga TensorFlow Hub.

qentë

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

Paraqitni kutitë kufizuese në imazhin e hyrjes:

prodhimi i zbulimit

Provoni mjetin e thjeshtë demo CLI për ObjectDetector me modelin tuaj dhe të dhënat e testimit.

Kërkesat e përputhshmërisë së modelit

API ObjectDetector pret një model TFLite me Metadata të detyrueshme të Modelit TFLite . Shihni shembuj të krijimit të meta të dhënave për detektorë objektesh duke përdorur API-në e shkrimit metadata TensorFlow Lite .

Modelet e përputhshme të detektorëve të objekteve duhet të plotësojnë kërkesat e mëposhtme:

Tenzori hyrës i imazhit: (kTfLiteUInt8/kTfLiteFloat32)
- futja e imazhit të madhësisë [batch x height x width x channels] .
- konkluzioni i grupit nuk mbështetet (kërkohet që batch të jetë 1).
- mbështeten vetëm hyrjet RGB ( channels duhet të jenë 3).
- nëse lloji është kTfLiteFloat32, NormalizationOptions kërkohet t'i bashkëngjiten meta të dhënave për normalizimin e hyrjes.
Tenzorët e daljes duhet të jenë 4 daljet e një funksioni DetectionPostProcess , dmth:
- Tensor i vendndodhjeve (kTfLiteFloat32)
  - tensori i madhësisë [1 x num_results x 4] , grupi i brendshëm që përfaqëson kutitë kufizuese në formën [lart, majtas, djathtas, poshtë].
  - BoundingBoxProperties kërkohet që t'i bashkëngjiten meta të dhënave dhe duhet të specifikojë type=BOUNDARIES dhe `coordinate_type=RATIO.
- Tenzori i klasave (kTfLiteFloat32)
  - tensor i madhësisë [1 x num_results] , secila vlerë përfaqëson indeksin e numrit të plotë të një klase.
  - Hartat e etiketave opsionale (por të rekomanduara) mund të bashkëngjiten si AssociatedFile-s me llojin TENSOR_VALUE_LABELS, që përmbajnë një etiketë për rresht. Shihni shembullin e skedarit të etiketës . I pari i tillë AssociatedFile (nëse ka) përdoret për të mbushur fushën class_name të rezultateve. Fusha display_name plotësohet nga AssociatedFile (nëse ka) vendndodhja e së cilës përputhet me fushën display_names_locale të ObjectDetectorOptions të përdorura në kohën e krijimit ("en" si parazgjedhje, dmth. anglisht). Nëse asnjëra nga këto nuk është e disponueshme, do të plotësohet vetëm fusha e index të rezultateve.
- Tenzori i rezultateve (kTfLiteFloat32)
  - tensor i madhësisë [1 x num_results] , secila vlerë përfaqëson rezultatin e objektit të zbuluar.
- Numri i tensorit të zbulimit (kTfLiteFloat32)
  - numër i plotë num_rezultatet si tensor me madhësi [1] .