Zintegruj klasyfikatory obrazów

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Klasyfikacja obrazów jest powszechnym zastosowaniem uczenia maszynowego do identyfikowania tego, co przedstawia obraz. Na przykład możemy chcieć wiedzieć, jaki rodzaj zwierzęcia pojawia się na danym zdjęciu. Zadanie przewidzenia tego, co przedstawia obraz, nazywa się klasyfikacją obrazu . Klasyfikator obrazu jest wyszkolony do rozpoznawania różnych klas obrazów. Na przykład model może być wyszkolony do rozpoznawania zdjęć przedstawiających trzy różne rodzaje zwierząt: króliki, chomiki i psy. Zobacz przegląd klasyfikacji obrazów, aby uzyskać więcej informacji na temat klasyfikatorów obrazów.

Użyj interfejsu API biblioteki zadań ImageClassifier , aby wdrożyć niestandardowe lub przeszkolone klasyfikatory obrazów w swoich aplikacjach mobilnych.

Kluczowe cechy interfejsu API ImageClassifier

  • Przetwarzanie obrazu wejściowego, w tym obracanie, zmiana rozmiaru i konwersja przestrzeni kolorów.

  • Obszar zainteresowania obrazu wejściowego.

  • Lokalizacja mapy etykiety.

  • Próg punktacji do filtrowania wyników.

  • Najwyższe wyniki w klasyfikacji.

  • Oznacz listę dozwolonych i odrzuconych.

Obsługiwane modele klasyfikatorów obrazów

Gwarantujemy zgodność następujących modeli z interfejsem ImageClassifier API.

Uruchom wnioskowanie w Javie

Zobacz aplikację referencyjną klasyfikacji obrazów, aby zapoznać się z przykładem użycia ImageClassifier w aplikacji na Androida.

Krok 1: Importuj zależność Gradle i inne ustawienia

Skopiuj plik modelu .tflite do katalogu asset modułu Android, w którym będzie uruchamiany model. Określ, że plik nie powinien być skompresowany, i 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 (NNAPI is included)
    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
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);

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

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 twoim systemie. Zapoznaj się z instrukcją instalacji CocoaPods, aby uzyskać instrukcje.

Zapoznaj się z przewodnikiem CocoaPods, aby uzyskać szczegółowe informacje na temat dodawania podów do projektu Xcode.

Dodaj TensorFlowLiteTaskVision w pliku Podfile.

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

Upewnij się, że model .tflite , którego będziesz używać do wnioskowania, znajduje się w pakiecie aplikacji.

Krok 2: Korzystanie z modelu

Szybki

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

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

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

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

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

Uruchom wnioskowanie w 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();

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

Przykładowe wyniki

Oto przykład wyników klasyfikacji klasyfikatora ptaków .

wróbel

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

Wypróbuj proste narzędzie demonstracyjne CLI dla ImageClassifier z własnym modelem i danymi testowymi.

Wymagania dotyczące zgodności modelu

Interfejs API ImageClassifier oczekuje modelu TFLite z obowiązkowymi metadanymi modelu TFLite . Zobacz przykłady tworzenia metadanych dla klasyfikatorów obrazów przy użyciu interfejsu API TensorFlow Lite Metadata Writer .

Zgodne modele klasyfikatorów obrazów powinny spełniać następujące wymagania:

  • Tensor obrazu wejściowego (kTfLiteUInt8/kTfLiteFloat32)

    • wejście obrazu o rozmiarze [batch x height x width x channels] .
    • wnioskowanie o partiach nie jest obsługiwane ( batch musi wynosić 1).
    • obsługiwane są tylko wejścia RGB (wymagane jest 3 channels ).
    • jeśli typem jest kTfLiteFloat32, NormalizationOptions muszą być dołączone do metadanych w celu normalizacji danych wejściowych.

  • Tensor wyniku wyjściowego (kTfLiteUInt8/kTfLiteFloat32)

    • z klasami N i 2 lub 4 wymiarami, tj. [1 x N] lub [1 x 1 x 1 x N]
    • opcjonalne (ale zalecane) mapy etykiet jako AssociatedFile-s o typie TENSOR_AXIS_LABELS, zawierające jedną etykietę w wierszu. Zobacz przykładowy plik etykiety . Pierwszy taki AssociatedFile (jeśli istnieje) jest używany do wypełnienia pola label (o nazwie class_name w C++) wyników. Pole display_name jest wypełniane z AssociatedFile (jeśli istnieje), którego ustawienia regionalne są zgodne z polem display_names_locale ImageClassifierOptions używanym w czasie tworzenia (domyślnie „en”, tj. angielski). Jeśli żaden z nich nie jest dostępny, wypełnione zostanie tylko pole index wyników.
,

Klasyfikacja obrazów jest powszechnym zastosowaniem uczenia maszynowego do identyfikowania tego, co przedstawia obraz. Na przykład możemy chcieć wiedzieć, jaki rodzaj zwierzęcia pojawia się na danym zdjęciu. Zadanie przewidzenia tego, co przedstawia obraz, nazywa się klasyfikacją obrazu . Klasyfikator obrazu jest wyszkolony do rozpoznawania różnych klas obrazów. Na przykład model może być wyszkolony do rozpoznawania zdjęć przedstawiających trzy różne rodzaje zwierząt: króliki, chomiki i psy. Zobacz przegląd klasyfikacji obrazów, aby uzyskać więcej informacji na temat klasyfikatorów obrazów.

Użyj interfejsu API biblioteki zadań ImageClassifier , aby wdrożyć niestandardowe lub przeszkolone klasyfikatory obrazów w swoich aplikacjach mobilnych.

Kluczowe cechy interfejsu API ImageClassifier

  • Przetwarzanie obrazu wejściowego, w tym obracanie, zmiana rozmiaru i konwersja przestrzeni kolorów.

  • Obszar zainteresowania obrazu wejściowego.

  • Lokalizacja mapy etykiety.

  • Próg punktacji do filtrowania wyników.

  • Najwyższe wyniki w klasyfikacji.

  • Oznacz listę dozwolonych i odrzuconych.

Obsługiwane modele klasyfikatorów obrazów

Gwarantujemy zgodność następujących modeli z interfejsem ImageClassifier API.

Uruchom wnioskowanie w Javie

Zobacz aplikację referencyjną klasyfikacji obrazów, aby zapoznać się z przykładem użycia ImageClassifier w aplikacji na Androida.

Krok 1: Importuj zależność Gradle i inne ustawienia

Skopiuj plik modelu .tflite do katalogu asset modułu Android, w którym będzie uruchamiany model. Określ, że plik nie powinien być skompresowany, i 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 (NNAPI is included)
    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
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);

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

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 twoim systemie. Zapoznaj się z instrukcją instalacji CocoaPods, aby uzyskać instrukcje.

Zapoznaj się z przewodnikiem CocoaPods, aby uzyskać szczegółowe informacje na temat dodawania podów do projektu Xcode.

Dodaj TensorFlowLiteTaskVision w pliku Podfile.

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

Upewnij się, że model .tflite , którego będziesz używać do wnioskowania, znajduje się w pakiecie aplikacji.

Krok 2: Korzystanie z modelu

Szybki

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

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

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

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

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

Uruchom wnioskowanie w 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();

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

Przykładowe wyniki

Oto przykład wyników klasyfikacji klasyfikatora ptaków .

wróbel

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

Wypróbuj proste narzędzie demonstracyjne CLI dla ImageClassifier z własnym modelem i danymi testowymi.

Wymagania dotyczące zgodności modelu

Interfejs API ImageClassifier oczekuje modelu TFLite z obowiązkowymi metadanymi modelu TFLite . Zobacz przykłady tworzenia metadanych dla klasyfikatorów obrazów przy użyciu interfejsu API TensorFlow Lite Metadata Writer .

Zgodne modele klasyfikatorów obrazów powinny spełniać następujące wymagania:

  • Tensor obrazu wejściowego (kTfLiteUInt8/kTfLiteFloat32)

    • wejście obrazu o rozmiarze [batch x height x width x channels] .
    • wnioskowanie o partiach nie jest obsługiwane ( batch musi wynosić 1).
    • obsługiwane są tylko wejścia RGB (wymagane jest 3 channels ).
    • jeśli typem jest kTfLiteFloat32, NormalizationOptions muszą być dołączone do metadanych w celu normalizacji danych wejściowych.

  • Tensor wyniku wyjściowego (kTfLiteUInt8/kTfLiteFloat32)

    • z klasami N i 2 lub 4 wymiarami, tj. [1 x N] lub [1 x 1 x 1 x N]
    • opcjonalne (ale zalecane) mapy etykiet jako AssociatedFile-s o typie TENSOR_AXIS_LABELS, zawierające jedną etykietę w wierszu. Zobacz przykładowy plik etykiety . Pierwszy taki AssociatedFile (jeśli istnieje) jest używany do wypełnienia pola label (o nazwie class_name w C++) wyników. Pole display_name jest wypełniane z AssociatedFile (jeśli istnieje), którego ustawienia regionalne są zgodne z polem display_names_locale ImageClassifierOptions używanym w czasie tworzenia (domyślnie „en”, tj. angielski). Jeśli żaden z nich nie jest dostępny, wypełnione zostanie tylko pole index wyników.