Integroni klasifikuesit e imazheve

Klasifikimi i imazheve është një përdorim i zakonshëm i mësimit të makinerive për të identifikuar atë që përfaqëson një imazh. Për shembull, ne mund të dëshirojmë të dimë se çfarë lloj kafshe shfaqet në një foto të caktuar. Detyra për të parashikuar se çfarë përfaqëson një imazh quhet klasifikimi i imazhit . Një klasifikues imazhi është trajnuar për të njohur klasa të ndryshme imazhesh. Për shembull, një model mund të trajnohet të njohë fotot që përfaqësojnë tre lloje të ndryshme kafshësh: lepujt, hamsterët dhe qentë. Shihni shembullin e klasifikimit të imazheve për më shumë informacion rreth klasifikuesve të imazheve.

Përdorni API-në e Task Library ImageClassifier për të vendosur klasifikuesit tuaj të personalizuar të imazheve ose të paratrajnuar në aplikacionet tuaja celulare.

Karakteristikat kryesore të API-së ImageClassifier

  • Përpunimi i imazhit në hyrje, duke përfshirë rrotullimin, ndryshimin e madhësisë dhe konvertimin e hapësirës së ngjyrave.

  • Rajoni i interesit të imazhit të hyrjes.

  • Vendndodhja e etiketës së hartës.

  • Pragu i rezultatit për të filtruar rezultatet.

  • Rezultatet e klasifikimit Top-k.

  • Etiketoni listën e lejeve dhe refuzoni.

Modele të mbështetura të klasifikuesit të imazhit

Modelet e mëposhtme janë të garantuara të jenë të pajtueshme me API-në ImageClassifier .

Ekzekutoni konkluzionet në Java

Shikoni aplikacionin e referencës së Klasifikimit të Imazheve për një shembull se si të përdorni ImageClassifier 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
ImageClassifierOptions options =
    ImageClassifierOptions.builder()
        .setBaseOptions(BaseOptions.builder().useGpu().build())
        .setMaxResults(1)
        .build();
ImageClassifier imageClassifier =
    ImageClassifier.createFromFileAndOptions(
        context, modelFile, options);

// Run inference
List<Classifications> results = imageClassifier.classify(image);

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

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: "birds_V1",
                                            ofType: "tflite") else { return }

let options = ImageClassifierOptions(modelPath: modelPath)

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

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

// Run inference
let classificationResults = try classifier.classify(mlImage: mlImage)

Objektivi-C 

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

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

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

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

TFLImageClassifier *classifier = [TFLImageClassifier imageClassifierWithOptions:options
                                                                          error:nil];

// Convert the input image to MLImage.
UIImage *image = [UIImage imageNamed:@"sparrow.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
TFLClassificationResult *classificationResult =
    [classifier classifyWithGMLImage:gmlImage error:nil];

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

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)
classification_options = processor.ClassificationOptions(max_results=2)
options = vision.ImageClassifierOptions(base_options=base_options, classification_options=classification_options)
classifier = vision.ImageClassifier.create_from_options(options)

# Alternatively, you can create an image classifier in the following manner:
# classifier = vision.ImageClassifier.create_from_file(model_path)

# Run inference
image = vision.TensorImage.create_from_file(image_path)
classification_result = classifier.classify(image)

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

Ekzekutoni konkluzionet në C++ 

// Initialization
ImageClassifierOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_path);
std::unique_ptr<ImageClassifier> image_classifier = ImageClassifier::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 ClassificationResult result = image_classifier->Classify(*frame_buffer).value();

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

Shembuj të rezultateve

Këtu është një shembull i rezultateve të klasifikimit të një klasifikuesi të shpendëve .

harabeli

Results:
  Rank #0:
   index       : 671
   score       : 0.91406
   class name  : /m/01bwb9
   display name: Passer domesticus
  Rank #1:
   index       : 670
   score       : 0.00391
   class name  : /m/01bwbt
   display name: Passer montanus
  Rank #2:
   index       : 495
   score       : 0.00391
   class name  : /m/0bwm6m
   display name: Passer italiae

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

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

ImageClassifier API pret një model TFLite me Metadata të detyrueshme të Modelit TFLite . Shihni shembuj të krijimit të meta të dhënave për klasifikuesit e imazheve duke përdorur API-në e shkrimtarit metadata TensorFlow Lite .

Modelet e përputhshme të klasifikuesit të imazhit 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.

  • Tensor i rezultatit të daljes (kTfLiteUInt8/kTfLiteFloat32)

    • me klasa N dhe 2 ose 4 dimensione, p.sh. [1 x N] ose [1 x 1 x 1 x N]
    • Hartat e etiketës opsionale (por të rekomanduara) si AssociatedFile-s me llojin TENSOR_AXIS_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 label (e emërtuar si class_name në C++) 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ë ImageClassifierOptions të përdorura në kohën e krijimit ("en" si parazgjedhje, p.sh. anglisht). Nëse asnjëra nga këto nuk është e disponueshme, do të plotësohet vetëm fusha e index të rezultateve.