Przewodnik po klasyfikacji obrazów w systemie iOS

Zadanie Klasyfikator obrazów umożliwia klasyfikację obrazów. Za pomocą pozwala określić, co obraz reprezentuje w grupie kategorii zdefiniowanych podczas trenowania. Te instrukcje pokazują, jak używać klasyfikatora obrazów w Aplikacje na iOS. Przykładowy kod opisany w tych instrukcjach jest dostępny na GitHub

Aby zobaczyć, jak działa to zadanie, wejdź na tę stronę wersji demonstracyjnej. Dla: więcej informacji o możliwościach, modelach i opcjach konfiguracji tego zadania, zobacz Przegląd.

Przykładowy kod

Przykładowy kod MediaPipe Tasks to podstawowa implementacja klasyfikatora obrazów na iOS. W tym przykładzie użyto aparatu w fizycznym urządzeniu z iOS, stale klasyfikować obiekty, a także korzystać z obrazów i filmów pochodzących galerii urządzeń do statycznego klasyfikowania obiektów.

Możesz użyć tej aplikacji jako punktu wyjścia dla własnej aplikacji na iOS lub skorzystać z niej podczas modyfikowania istniejącej aplikacji. Przykładowy kod klasyfikatora obrazów jest hostowany GitHub

Pobieranie kodu

Poniżej znajdziesz instrukcje tworzenia lokalnej kopii przykładu. za pomocą narzędzia wiersza poleceń git.

Aby pobrać przykładowy kod:

1. Sklonuj repozytorium git za pomocą tego polecenia:

   git clone https://github.com/google-ai-edge/mediapipe-samples
   

2. Opcjonalnie możesz skonfigurować instancję git tak, aby wykorzystywała rozproszony proces płatności, aby tylko pliki przykładowej aplikacji Image Classifier:

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/image_classification/ios/
   

Po utworzeniu lokalnej wersji przykładowego kodu możesz zainstalować w bibliotece zadań MediaPipe, otwórz projekt za pomocą Xcode i uruchom aplikację. Dla: instrukcje znajdziesz w Przewodniku po konfiguracji na iOS.

Kluczowe elementy

Poniższe pliki zawierają kluczowy kod przykładowego klasyfikatora obrazów aplikacja:

• ImageClassifierService.swift: Inicjuje klasyfikator obrazów, obsługuje wybór modelu i wykonuje wnioskowanie na danych wejściowych.
• CameraViewController.swift: Implementuje interfejs trybu wprowadzania obrazu z kamery na żywo i wizualizuje wyniki.
• MediaLibraryViewController.swift Implementuje interfejs trybu wprowadzania zdjęć i filmów oraz wizualizuje wyniki.

Konfiguracja

W tej sekcji opisujemy najważniejsze czynności związane z konfigurowaniem środowiska programistycznego oraz w projektach kodu, w których używa się klasyfikatora obrazów. Ogólne informacje o konfigurowaniu środowisko programistyczne do używania zadań MediaPipe, w tym wersja platformy wymagania znajdziesz w przewodniku konfiguracji dla iOS.

Zależności

Klasyfikator obrazów używa biblioteki MediaPipeTasksVision, którą należy zainstalować za pomocą CocoaPods. Biblioteka jest zgodna z aplikacjami Swift i Objective-C. i nie wymaga żadnej dodatkowej konfiguracji.

Instrukcje instalowania CocoaPods w macOS znajdziesz w CocoaPods przewodnik instalacji. Aby dowiedzieć się, jak utworzyć Podfile z podami niezbędnymi dla Twojego aplikacji można znaleźć w sekcji Korzystanie CocoaPods.

Dodaj pod MediaPipeTasksVision w tabeli Podfile przy użyciu tego kodu:

target 'MyImageClassifierApp' do
  use_frameworks!
  pod 'MediaPipeTasksVision'
end

Jeśli Twoja aplikacja zawiera cele testów jednostkowych, zapoznaj się z przewodnikiem po konfiguracji iOS, gdzie znajdziesz dodatkowe informacje o konfigurowaniu Podfile.

Model

Zadanie MediaPipe Image Classifier wymaga wytrenowanego modelu, który jest zgodny w tym zadaniu. Aby uzyskać więcej informacji o dostępnych wytrenowanych modelach dla Klasyfikator obrazów – patrz omówienie zadań: modele .

Wybierz i pobierz model, a następnie dodaj go do katalogu projektu za pomocą Xcode. Instrukcje dodawania plików do projektu Xcode znajdziesz w sekcji Zarządzanie pliki i foldery w Xcode projekt.

Użyj właściwości BaseOptions.modelAssetPath, aby określić ścieżkę do modelu w pakiecie aplikacji. Przykładowy kod znajdziesz w następnej sekcji.

Tworzenie zadania

Zadanie klasyfikatora obrazów możesz utworzyć, wywołując jeden z jego inicjatorów. Inicjator ImageClassifier(options:) ustawia wartości opcji konfiguracji w tym tryb biegania, ustawienia regionalne wyświetlanych nazw, maksymalna liczba wyników, poziom ufności próg, listę dozwolonych kategorii i listę odrzuconych.

Jeśli nie potrzebujesz klasyfikatora obrazów zainicjowanego z niestandardową konfiguracją możesz użyć inicjatora ImageClassifier(modelPath:) do utworzenia Klasyfikator obrazów z opcjami domyślnymi. Więcej informacji o konfiguracji Więcej informacji znajdziesz w artykule Omówienie konfiguracji.

Zadanie Klasyfikator obrazów obsługuje 3 typy danych wejściowych: nieruchome obrazy i pliki wideo i transmisje wideo na żywo. Domyślnie ImageClassifier(modelPath:) inicjuje dla nieruchomych obrazów. Jeśli chcesz, aby zadanie zostało zainicjowane do przetworzenia filmu plików lub transmisji wideo na żywo, użyj właściwości ImageClassifier(options:), aby określić w trybie wyświetlania wideo lub transmisji na żywo. Tryb transmisji na żywo wymaga też: dodatkową opcję konfiguracji imageClassifierLiveStreamDelegate, która umożliwia klasyfikator obrazów dostarczanie wyników klasyfikacji obrazów do asynchronicznie.

Wybierz kartę odpowiadającą Twojemu trybowi biegowemu, aby zobaczyć, jak utworzyć zadanie i prowadź wnioskowanie.

Swift

import MediaPipeTasksVision

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "tflite")

let options = ImageClassifierOptions()
options.baseOptions.modelAssetPath = modelPath
options.runningMode = .image
options.maxResults = 5

let imageClassifier = try ImageClassifier(options: options)
    

import MediaPipeTasksVision

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "tflite")

let options = ImageClassifierOptions()
options.baseOptions.modelAssetPath = modelPath
options.runningMode = .video
options.maxResults = 5

let imageClassifier = try ImageClassifier(options: options)
    

import MediaPipeTasksVision

// Class that conforms to the `ImageClassifierLiveStreamDelegate` protocol and
// implements the method that the image classifier calls once it
// finishes performing classification on each input frame.
class ImageClassifierResultProcessor: NSObject, ImageClassifierLiveStreamDelegate {

   func imageClassifier(
    _ imageClassifier: ImageClassifier,
    didFinishClassification result: ImageClassifierResult?,
    timestampInMilliseconds: Int,
    error: Error?) {

    // Process the image classifier result or errors here.

  }
}

let modelPath = Bundle.main.path(
  forResource: "model",
  ofType: "tflite")

let options = ImageClassifierOptions()
options.baseOptions.modelAssetPath = modelPath
options.runningMode = .liveStream
options.maxResults = 5

// Assign an object of the class to the `imageClassifierLiveStreamDelegate`
// property.
let processor = ImageClassifierResultProcessor()
options.imageClassifierLiveStreamDelegate = processor

let imageClassifier = try ImageClassifier(options: options)
    

Objective-C

@import MediaPipeTasksVision;

NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model"
                                                      ofType:@"tflite"];

MPPImageClassifierOptions *options = [[MPPImageClassifierOptions alloc] init];
options.baseOptions.modelAssetPath = modelPath;
options.runningMode = MPPRunningModeImage;
options.maxResults = 5;

MPPImageClassifier *imageClassifier =
      [[MPPImageClassifier alloc] initWithOptions:options error:nil];
    

@import MediaPipeTasksVision;

NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model"
                                                      ofType:@"tflite"];

MPPImageClassifierOptions *options = [[MPPImageClassifierOptions alloc] init];
options.baseOptions.modelAssetPath = modelPath;
options.runningMode = MPPRunningModeVideo;
options.maxResults = 5;

MPPImageClassifier *imageClassifier =
      [[MPPImageClassifier alloc] initWithOptions:options error:nil];
    

@import MediaPipeTasksVision;

// Class that conforms to the `MPPImageClassifierLiveStreamDelegate` protocol
// and implements the method that the image classifier calls once it finishes
// performing classification on each input frame.

@interface APPImageClassifierResultProcessor : NSObject 

@end

@implementation APPImageClassifierResultProcessor

-   (void)imageClassifier:(MPPImageClassifier *)imageClassifier
    didFinishClassificationWithResult:(MPPImageClassifierResult *)imageClassifierResult
              timestampInMilliseconds:(NSInteger)timestampInMilliseconds
                                error:(NSError *)error {

    // Process the image classifier result or errors here.

}

@end

NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model"
                                                      ofType:@"tflite"];

MPPImageClassifierOptions *options = [[MPPImageClassifierOptions alloc] init];
options.baseOptions.modelAssetPath = modelPath;
options.runningMode = MPPRunningModeLiveStream;
options.maxResults = 5;

// Assign an object of the class to the `imageClassifierLiveStreamDelegate`
// property.
APPImageClassifierResultProcessor *processor = [APPImageClassifierResultProcessor new];
options.imageClassifierLiveStreamDelegate = processor;

MPPImageClassifier *imageClassifier =
      [[MPPImageClassifier alloc] initWithOptions:options error:nil];
    

Opcje konfiguracji

To zadanie zawiera te opcje konfiguracji aplikacji na iOS:

Konfiguracja transmisji na żywo

Gdy tryb działania jest ustawiony na transmisję na żywo, klasyfikator obrazów wymaga parametru dodatkową opcję konfiguracji imageClassifierLiveStreamDelegate, która umożliwia klasyfikatorowi asynchroniczne dostarczanie wyników klasyfikacji. deleguje implementuje imageClassifier(_:didFinishClassification:timestampInMilliseconds:error:) którą wywołuje klasyfikator obrazów po przetworzeniu klasyfikacji. dla każdej klatki.

Przygotuj dane

Musisz przekonwertować obraz lub ramkę wejściową na obiekt MPImage przed i przekazać go do klasyfikatora obrazów. MPImage obsługuje różne typy obrazów z iOS formatów i używać ich w dowolnym trybie działania do wnioskowania. Więcej informacje na temat marki MPImage znajdziesz w Interfejs MPImage API

Wybierz format obrazu na iOS na podstawie swojego przypadku użycia i trybu uruchamiania wymagane jest zgłoszenie.MPImage akceptuje UIImage, CVPixelBuffer i CMSampleBuffer Formaty obrazów w iOS.

UIImage

Format UIImage sprawdza się w tych trybach biegu:

• Obrazy: obrazy z pakietu aplikacji, galerii użytkownika lub systemu plików w formacie Obrazy (UIImage) można przekonwertować na obiekt MPImage.

• Filmy: użyj narzędzia AVAssetImageGenerator. aby wyodrębnić klatki wideo do CGImage a potem przekonwertuj je na UIImage obrazy.

// Load an image on the user's device as an iOS `UIImage` object.

// Convert the `UIImage` object to a MediaPipe's Image object having the default
// orientation `UIImage.Orientation.up`.
let image = try MPImage(uiImage: image)
    

// Load an image on the user's device as an iOS `UIImage` object.

// Convert the `UIImage` object to a MediaPipe's Image object having the default
// orientation `UIImageOrientationUp`.
MPImage *image = [[MPPImage alloc] initWithUIImage:image error:nil];
    

Ten przykład inicjuje MPImage z domyślną wartością UIImage.Orientation.Up orientacji ekranu. Możesz zainicjować MPImage przy użyciu dowolnej z obsługiwanych UIImage.Orientation . Klasyfikator obrazów nie obsługuje lustrzanych orientacji, takich jak .upMirrored, .downMirrored, .leftMirrored, .rightMirrored.

Więcej informacji o UIImage znajdziesz na stronie UIImage dla deweloperów Apple Dokumentacja.

CVPixelBuffer

Format CVPixelBuffer sprawdza się w przypadku aplikacji generujących ramki. i zastosuj CoreImage na iOS platformy przetwarzania danych.

Format CVPixelBuffer sprawdza się w tych trybach biegu:

• Obrazy: aplikacje, które po przetworzeniu generują CVPixelBuffer obrazy. przy użyciu platformy CoreImage systemu iOS można wysłać do klasyfikatora obrazów w narzędziu w trybie uruchamiania obrazu.

• Filmy: klatki wideo można konwertować do formatu CVPixelBuffer dla a następnie przesłany do klasyfikatora obrazów w trybie wideo.

• transmisja na żywo: aplikacje korzystające z aparatu w iOS do generowania klatek mogą być konwertowane w formacie CVPixelBuffer do przetworzenia przed wysłaniem do Klasyfikator obrazów w trybie transmisji na żywo.

// Obtain a CVPixelBuffer.

// Convert the `CVPixelBuffer` object to a MediaPipe's Image object having the default
// orientation `UIImage.Orientation.up`.
let image = try MPImage(pixelBuffer: pixelBuffer)
    

// Obtain a CVPixelBuffer.

// Convert the `CVPixelBuffer` object to a MediaPipe's Image object having the
// default orientation `UIImageOrientationUp`.
MPImage *image = [[MPPImage alloc] initWithUIImage:image error:nil];
    

Więcej informacji o CVPixelBuffer znajdziesz tutaj: CVPixelBuffer Apple Dla programistów Dokumentacja.

CMSampleBuffer

Format CMSampleBuffer przechowuje próbki multimediów jednolitego typu mediów i jest co sprawdza się w trybie biegowym transmisji na żywo. Klatki na żywo z aparatów z iOS są asynchronicznie dostarczone w formacie CMSampleBuffer przez iOS AVCaptureVideoDataOutput.

// Obtain a CMSampleBuffer.

// Convert the `CMSampleBuffer` object to a MediaPipe's Image object having the default
// orientation `UIImage.Orientation.up`.
let image = try MPImage(sampleBuffer: sampleBuffer)
    

// Obtain a `CMSampleBuffer`.

// Convert the `CMSampleBuffer` object to a MediaPipe's Image object having the
// default orientation `UIImageOrientationUp`.
MPImage *image = [[MPPImage alloc] initWithSampleBuffer:sampleBuffer error:nil];
    

Więcej informacji o CMSampleBuffer znajdziesz tutaj: CMSampleBuffer Apple Dla programistów Dokumentacja.

Uruchamianie zadania

Aby uruchomić klasyfikator obrazów, użyj metody classify() specyficznej dla przypisanej tryb działania:

• Zdjęcie: classify(image:)
• Film: classify(videoFrame:timestampInMilliseconds:)
• transmisja na żywo: classifyAsync(image:timestampInMilliseconds:)

Klasyfikator obrazów zwraca możliwe kategorie dla obiektu w obrazu lub ramki.

Poniżej znajdziesz przykładowy kod pokazujący, jak uruchomić klasyfikator obrazów: w różnych trybach:

Swift

let result = try imageClassifier.classify(image: image)
    

let result = try imageClassifier.classify(
  videoFrame: image,
  timestampInMilliseconds: timestamp)
    

try imageClassifier.classifyAsync(
  image: image,
  timestampInMilliseconds: timestamp)
    

Objective-C

MPPImageClassifierResult *result = [imageClassifier classifyImage:image
                                                            error:nil];
    

MPPImageClassifierResult *result = [imageClassifier classifyVideoFrame:image
                                               timestampInMilliseconds:timestamp
                                                                 error:nil];
    

BOOL success = [imageClassifier classifyAsyncImage:image
                          timestampInMilliseconds:timestamp
                                            error:nil];
    

Przykładowy kod klasyfikatora obrazów pokazuje implementacje każdego z tych trybów classify(image:), więcej informacji classify(videoFrame:timestampInMilliseconds:) i classifyAsync(image:timestampInMilliseconds:) Ten przykładowy kod umożliwia użycie funkcji przełączać się między trybami przetwarzania, które mogą nie być wymagane tych kwestii.

Pamiętaj:

• Korzystając z trybu wideo lub transmisji na żywo, musisz też podać: sygnatura czasowa ramki wejściowej zadania Klasyfikator obrazów.

• W trybie obrazu lub wideo zadanie Klasyfikator obrazów blokuje w bieżącym wątku aż do zakończenia przetwarzania obrazu lub ramki wejściowej. Do unikaj blokowania bieżącego wątku, uruchamiaj przetwarzanie w tle w iOS na iOS Dispatch lub NSOperation zasad.

• W trybie transmisji na żywo zadanie klasyfikatora obrazów zwraca się natychmiast. i nie blokuje bieżącego wątku. Wywołuje on metodę imageClassifier(_:didFinishClassification:timestampInMilliseconds:error:) z wynikiem klasyfikacji po przetworzeniu każdej ramki wejściowej. Klasyfikator obrazów wywołuje tę metodę asynchronicznie na dedykowanym kolejki wysyłki. Aby wyświetlić wyniki w interfejsie, wyślij do głównej kolejki po przetworzeniu wyników. Jeśli Funkcja classifyAsync jest wywoływana, gdy zadanie klasyfikatora obrazów jest zajęte podczas przetwarzania kolejnej klatki, klasyfikator obrazów zignoruje nową ramkę wejściową.

Obsługa i wyświetlanie wyników

Po uruchomieniu wnioskowania zadanie Klasyfikator obrazów zwraca błąd ImageClassifierResult obiekt zawierający listę możliwych kategorii obiektów na obrazie lub w ramce wejściowej.

Poniżej znajdziesz przykładowe dane wyjściowe tego zadania:

ImageClassifierResult:
 Classifications #0 (single classification head):
  head index: 0
  category #0:
   category name: "/m/01bwb9"
   display name: "Passer domesticus"
   score: 0.91406
   index: 671
  category #1:
   category name: "/m/01bwbt"
   display name: "Passer montanus"
   score: 0.00391
   index: 670

Ten wynik uzyskano po uruchomieniu Bird Classifier. dnia:

Przykładowy kod klasyfikatora obrazów pokazuje, jak wyświetlić klasyfikację wyników zwróconych przez zadanie, patrz kod przykład .