Klasyfikacja obrazu jest powszechnym zastosowaniem uczenia maszynowego do identyfikowania tego, co reprezentuje obraz. Na przykład możemy chcieć wiedzieć, jaki rodzaj zwierzęcia pojawia się na danym obrazku. Zadanie polegające na przewidzeniu, co reprezentuje obraz, nazywa się klasyfikacją obrazu . Klasyfikator obrazu jest przeszkolony do rozpoznawania różnych klas obrazów. Model można na przykład nauczyć rozpoznawania zdjęć przedstawiających trzy różne typy zwierząt: króliki, chomiki i psy. Więcej informacji na temat klasyfikatorów obrazów można znaleźć w omówieniu klasyfikacji obrazów.
Użyj interfejsu API ImageClassifier
biblioteki zadań, aby wdrożyć niestandardowe lub wstępnie przeszkolone klasyfikatory obrazów w aplikacjach mobilnych.
Kluczowe cechy API ImageClassifier
Przetwarzanie obrazu wejściowego, w tym obracanie, zmiana rozmiaru i konwersja przestrzeni kolorów.
Obszar zainteresowania obrazu wejściowego.
Oznacz lokalizację mapy.
Próg punktacji do filtrowania wyników.
Wyniki klasyfikacji z najwyższej półki.
Oznacz listę dozwolonych i odrzuconych etykiet.
Obsługiwane modele klasyfikatorów obrazów
Gwarantujemy kompatybilność następujących modeli z interfejsem API ImageClassifier
.
Modele utworzone przez TensorFlow Lite Model Maker do klasyfikacji obrazów .
Wstępnie wyszkolone modele klasyfikacji obrazów w TensorFlow Hub .
Modele utworzone przez klasyfikację obrazów AutoML Vision Edge .
Modele niestandardowe spełniające wymagania dotyczące kompatybilności modeli .
Uruchom wnioskowanie w Javie
Zobacz aplikację referencyjną do klasyfikacji obrazów , aby zapoznać się z przykładem użycia ImageClassifier
w aplikacji na Androida.
Krok 1: Zaimportuj zależność Gradle i inne ustawienia
Skopiuj plik modelu .tflite
do katalogu zasobów modułu Android, w którym model będzie uruchamiany. Określ, że plik nie powinien być kompresowany 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 systemie iOS
Krok 1: Zainstaluj zależności
Biblioteka zadań obsługuje instalację przy użyciu CocoaPods. Upewnij się, że CocoaPods jest zainstalowany w twoim systemie. Instrukcje znajdziesz w instrukcji instalacji CocoaPods .
Szczegółowe informacje na temat dodawania kapsuł do projektu Xcode można znaleźć w przewodniku CocoaPods .
Dodaj moduł TensorFlowLiteTaskVision
do 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 konfiguracji 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 uzyskanych za pomocą klasyfikatora ptaków .
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 kompatybilnoś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 narzędzia do zapisywania metadanych TensorFlow Lite .
Kompatybilne modele klasyfikatorów obrazu powinny spełniać następujące wymagania:
Tensor obrazu wejściowego (kTfLiteUInt8/kTfLiteFloat32)
- wprowadzanie obrazu o rozmiarze
[batch x height x width x channels]
. - wnioskowanie wsadowe nie jest obsługiwane (wymagana jest
batch
1). - obsługiwane są tylko wejścia RGB (wymagane są 3
channels
). - jeśli typ to kTfLiteFloat32, do metadanych należy dołączyć opcje NormalizationOptions w celu normalizacji danych wejściowych.
- wprowadzanie obrazu o rozmiarze
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 typu TENSOR_AXIS_LABELS, zawierające jedną etykietę w linii. Zobacz przykładowy plik etykiety . Pierwszy taki AssociatedFile (jeśli istnieje) jest używany do wypełnienia pola
label
(nazwanego jakoclass_name
w C++) wyników. Poledisplay_name
jest wypełniane z pliku AssociatedFile (jeśli istnieje), którego ustawienia regionalne odpowiadają poludisplay_names_locale
ImageClassifierOptions
użytej w czasie tworzenia (domyślnie „en”, tj. angielski). Jeśli żadne z nich nie jest dostępne, wypełnione zostanie jedynie poleindex
wyników.
- z klasami