Oznaczanie obrazów etykietami za pomocą wytrenowanego modelu AutoML na Androidzie

Interfejs API AutoML Vision Edge nie jest już dostępny. Zamiast tego użyj interfejsu Custom Image Labeling API, który teraz natywnie obsługuje te modele. Jeśli obecnie korzystasz z tego interfejsu API, postępuj zgodnie z naszymi instrukcjami migracji.

Po wytrenowaniu własnego modelu za pomocą AutoML Vision Edge możesz używać go w aplikacji do oznaczania obrazów etykietami. Modele wytrenowane w AutoML Vision Edge można zintegrować na 2 sposoby: możesz dołączyć model, umieszczając go w folderze zasobów aplikacji, lub możesz pobrać go dynamicznie z Firebase.

Opcje pakietów modeli
Dołączone do aplikacji	Model jest częścią pliku APK aplikacji. Model jest dostępny od razu, nawet gdy urządzenie z Androidem jest offline. Nie musisz mieć projektu Firebase
Hostowane w Firebase	Hostuj model, przesyłając go do Firebase Machine Learning. Zmniejsza rozmiar pliku APK Model jest pobierany na żądanie Wysyłanie aktualizacji modelu bez ponownego publikowania aplikacji Łatwe testy A/B za pomocą Zdalnej konfiguracji Firebase Wymaga projektu Firebase

Wypróbuj

• Wypróbuj przykładową aplikację, aby zobaczyć przykład użycia tego interfejsu API.

Zanim zaczniesz

1. W pliku build.gradle na poziomie projektu dodaj repozytorium Maven firmy Google do sekcji buildscript i allprojects.

2. Dodaj zależności dla bibliotek ML Kit na Androida do pliku Gradle na poziomie aplikacji modułu, który zwykle znajduje się w tym miejscu: app/build.gradle: Aby dołączyć model do aplikacji:

    dependencies {
      // ...
      // Image labeling feature with bundled automl model
      implementation 'com.google.mlkit:image-labeling-automl:16.2.1'
    }
    

Aby dynamicznie pobierać model z Firebase, dodaj zależność linkFirebase:

    dependencies {
      // ...
      // Image labeling feature with automl model downloaded
      // from firebase
      implementation 'com.google.mlkit:image-labeling-automl:16.2.1'
      implementation 'com.google.mlkit:linkfirebase:16.0.1'
    }
    

3. Jeśli chcesz pobrać model, pamiętaj, aby dodać Firebase do projektu Android, jeśli jeszcze tego nie zrobisz. Nie jest to wymagane, gdy dołączasz model.

1. Wczytywanie modelu

Konfigurowanie źródła modelu lokalnego

Aby połączyć model z aplikacją:

1. Wyodrębnij model i jego metadane z pobranego z konsoli Firebase archiwum ZIP. Zalecamy używanie pobranych plików bez modyfikacji (w tym bez zmiany nazw plików).

2. Dołącz model i pliki metadanych do pakietu aplikacji:

a. Jeśli w projekcie nie masz folderu z komponentami, utwórz go, klikając prawym przyciskiem myszy folder app/, a następnie wybierając Nowy > Folder > Folder z komponentami.

b. Utwórz podfolder w folderze zasobów, w którym będą przechowywane pliki modelu.

c. Skopiuj pliki model.tflite, dict.txt i manifest.json do podfolderu (wszystkie 3 pliki muszą znajdować się w tym samym folderze).

3. Aby mieć pewność, że Gradle nie skompresuje pliku modelu podczas kompilowania aplikacji, dodaj do pliku build.gradle ten ciąg:

    android {
        // ...
        aaptOptions {
            noCompress "tflite"
        }
    }
    

Plik modelu zostanie dołączony do pakietu aplikacji i będzie dostępny w ML Kit jako nieprzetworzony zasób.

Uwaga: od wersji 4.1 wtyczki Androida do obsługi Gradle plik .tflite będzie domyślnie dodawany do listy noCompress, więc powyższe działanie nie będzie już konieczne.

4. Utwórz obiekt LocalModel, podając ścieżkę do pliku manifestu modelu:

Kotlin

val localModel = AutoMLImageLabelerLocalModel.Builder()
        .setAssetFilePath("manifest.json")
        // or .setAbsoluteFilePath(absolute file path to manifest file)
        .build()

Java

AutoMLImageLabelerLocalModel localModel =
    new AutoMLImageLabelerLocalModel.Builder()
        .setAssetFilePath("manifest.json")
        // or .setAbsoluteFilePath(absolute file path to manifest file)
        .build();

Konfigurowanie źródła modelu hostowanego w Firebase

Aby użyć modelu hostowanego zdalnie, utwórz obiekt RemoteModel, podając nazwę, którą przypisano do modelu podczas publikowania:

Kotlin

// Specify the name you assigned in the Firebase console.
val remoteModel =
    AutoMLImageLabelerRemoteModel.Builder("your_model_name").build()

Java

// Specify the name you assigned in the Firebase console.
AutoMLImageLabelerRemoteModel remoteModel =
    new AutoMLImageLabelerRemoteModel.Builder("your_model_name").build();

Następnie rozpocznij pobieranie modelu, określając warunki, w jakich chcesz zezwolić na pobieranie. Jeśli modelu nie ma na urządzeniu lub dostępna jest nowsza wersja, zadanie asynchronicznie pobierze model z Firebase:

Kotlin

val downloadConditions = DownloadConditions.Builder()
    .requireWifi()
    .build()
RemoteModelManager.getInstance().download(remoteModel, downloadConditions)
    .addOnSuccessListener {
        // Success.
    }

Java

DownloadConditions downloadConditions = new DownloadConditions.Builder()
        .requireWifi()
        .build();
RemoteModelManager.getInstance().download(remoteModel, downloadConditions)
        .addOnSuccessListener(new OnSuccessListener() {
            @Override
            public void onSuccess(@NonNull Task task) {
                // Success.
            }
        });

Wiele aplikacji rozpoczyna pobieranie w kodzie inicjującym, ale możesz to zrobić w dowolnym momencie przed użyciem modelu.

Tworzenie narzędzia do oznaczania obrazów na podstawie modelu

Po skonfigurowaniu źródeł modelu utwórz z jednego z nich ImageLabelerobiekt.

Jeśli masz tylko model dołączony lokalnie, utwórz narzędzie do etykietowania z obiektu AutoMLImageLabelerLocalModel i skonfiguruj próg wyniku ufności, który chcesz wymagać (patrz Ocena modelu):

Kotlin

val autoMLImageLabelerOptions = AutoMLImageLabelerOptions.Builder(localModel)
    .setConfidenceThreshold(0)  // Evaluate your model in the Firebase console
                                // to determine an appropriate value.
    .build()
val labeler = ImageLabeling.getClient(autoMLImageLabelerOptions)

Java

AutoMLImageLabelerOptions autoMLImageLabelerOptions =
        new AutoMLImageLabelerOptions.Builder(localModel)
                .setConfidenceThreshold(0.0f)  // Evaluate your model in the Firebase console
                                               // to determine an appropriate value.
                .build();
ImageLabeler labeler = ImageLabeling.getClient(autoMLImageLabelerOptions)

Jeśli masz model hostowany zdalnie, przed jego uruchomieniem musisz sprawdzić, czy został pobrany. Stan zadania pobierania modelu możesz sprawdzić za pomocą metody isModelDownloaded() menedżera modeli.

Chociaż musisz to potwierdzić tylko przed uruchomieniem narzędzia do etykietowania, jeśli masz zarówno model hostowany zdalnie, jak i model dołączony lokalnie, warto przeprowadzić to sprawdzenie podczas tworzenia instancji narzędzia do etykietowania obrazów: utwórz narzędzie do etykietowania na podstawie modelu zdalnego, jeśli został on pobrany, a w przeciwnym razie na podstawie modelu lokalnego.

Kotlin

RemoteModelManager.getInstance().isModelDownloaded(remoteModel)
    .addOnSuccessListener { isDownloaded -> 
    val optionsBuilder =
        if (isDownloaded) {
            AutoMLImageLabelerOptions.Builder(remoteModel)
        } else {
            AutoMLImageLabelerOptions.Builder(localModel)
        }
    // Evaluate your model in the Firebase console to determine an appropriate threshold.
    val options = optionsBuilder.setConfidenceThreshold(0.0f).build()
    val labeler = ImageLabeling.getClient(options)
}

Java

RemoteModelManager.getInstance().isModelDownloaded(remoteModel)
        .addOnSuccessListener(new OnSuccessListener() {
            @Override
            public void onSuccess(Boolean isDownloaded) {
                AutoMLImageLabelerOptions.Builder optionsBuilder;
                if (isDownloaded) {
                    optionsBuilder = new AutoMLImageLabelerOptions.Builder(remoteModel);
                } else {
                    optionsBuilder = new AutoMLImageLabelerOptions.Builder(localModel);
                }
                AutoMLImageLabelerOptions options = optionsBuilder
                        .setConfidenceThreshold(0.0f)  // Evaluate your model in the Firebase console
                                                       // to determine an appropriate threshold.
                        .build();

                ImageLabeler labeler = ImageLabeling.getClient(options);
            }
        });

Jeśli masz tylko model hostowany zdalnie, wyłącz funkcje związane z modelem, np. wyszarz lub ukryj część interfejsu, dopóki nie potwierdzisz, że model został pobrany. Możesz to zrobić, dołączając odbiornik do metody download() menedżera modeli:

Kotlin

RemoteModelManager.getInstance().download(remoteModel, conditions)
    .addOnSuccessListener {
        // Download complete. Depending on your app, you could enable the ML
        // feature, or switch from the local model to the remote model, etc.
    }

Java

RemoteModelManager.getInstance().download(remoteModel, conditions)
        .addOnSuccessListener(new OnSuccessListener() {
            @Override
            public void onSuccess(Void v) {
              // Download complete. Depending on your app, you could enable
              // the ML feature, or switch from the local model to the remote
              // model, etc.
            }
        });

2. Przygotowywanie obrazu wejściowego

Następnie dla każdego obrazu, który chcesz oznaczyć, utwórz InputImage obiekt z obrazu. Etykieciarka obrazów działa najszybciej, gdy używasz formatu Bitmaplub, jeśli korzystasz z interfejsu Camera2 API, formatu YUV_420_888 media.Image, które są zalecane, gdy jest to możliwe.

Możesz utworzyć InputImage obiekt z różnych źródeł. Każde z nich opisujemy poniżej.

Korzystanie z media.Image

Aby utworzyć obiekt InputImage z obiektu media.Image, np. podczas przechwytywania obrazu z aparatu urządzenia, przekaż obiekt media.Image i obrót obrazu do InputImage.fromMediaImage().

Jeśli używasz biblioteki CameraX, klasy OnImageCapturedListener i ImageAnalysis.Analyzer obliczają wartość rotacji za Ciebie.

Kotlin

private class YourImageAnalyzer : ImageAnalysis.Analyzer {

    override fun analyze(imageProxy: ImageProxy) {
        val mediaImage = imageProxy.image
        if (mediaImage != null) {
            val image = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
            // Pass image to an ML Kit Vision API
            // ...
        }
    }
}

Java

private class YourAnalyzer implements ImageAnalysis.Analyzer {

    @Override
    public void analyze(ImageProxy imageProxy) {
        Image mediaImage = imageProxy.getImage();
        if (mediaImage != null) {
          InputImage image =
                InputImage.fromMediaImage(mediaImage, imageProxy.getImageInfo().getRotationDegrees());
          // Pass image to an ML Kit Vision API
          // ...
        }
    }
}

Jeśli nie używasz biblioteki aparatu, która podaje stopień obrotu obrazu, możesz obliczyć go na podstawie stopnia obrotu urządzenia i orientacji czujnika aparatu w urządzeniu:

Kotlin

private val ORIENTATIONS = SparseIntArray()

init {
    ORIENTATIONS.append(Surface.ROTATION_0, 0)
    ORIENTATIONS.append(Surface.ROTATION_90, 90)
    ORIENTATIONS.append(Surface.ROTATION_180, 180)
    ORIENTATIONS.append(Surface.ROTATION_270, 270)
}

/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Throws(CameraAccessException::class)
private fun getRotationCompensation(cameraId: String, activity: Activity, isFrontFacing: Boolean): Int {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    val deviceRotation = activity.windowManager.defaultDisplay.rotation
    var rotationCompensation = ORIENTATIONS.get(deviceRotation)

    // Get the device's sensor orientation.
    val cameraManager = activity.getSystemService(CAMERA_SERVICE) as CameraManager
    val sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION)!!

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360
    }
    return rotationCompensation
}
MLKitVisionImage.kt

Java

private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
static {
    ORIENTATIONS.append(Surface.ROTATION_0, 0);
    ORIENTATIONS.append(Surface.ROTATION_90, 90);
    ORIENTATIONS.append(Surface.ROTATION_180, 180);
    ORIENTATIONS.append(Surface.ROTATION_270, 270);
}

/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
private int getRotationCompensation(String cameraId, Activity activity, boolean isFrontFacing)
        throws CameraAccessException {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    int deviceRotation = activity.getWindowManager().getDefaultDisplay().getRotation();
    int rotationCompensation = ORIENTATIONS.get(deviceRotation);

    // Get the device's sensor orientation.
    CameraManager cameraManager = (CameraManager) activity.getSystemService(CAMERA_SERVICE);
    int sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION);

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360;
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360;
    }
    return rotationCompensation;
}

Następnie przekaż obiekt media.Image i wartość stopnia obrotu do InputImage.fromMediaImage():

Kotlin

val image = InputImage.fromMediaImage(mediaImage, rotation)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromMediaImage(mediaImage, rotation);

Używanie identyfikatora URI pliku

Aby utworzyć obiekt InputImage z identyfikatora URI pliku, przekaż kontekst aplikacji i identyfikator URI pliku do funkcji InputImage.fromFilePath(). Jest to przydatne, gdy używasz intencji ACTION_GET_CONTENT, aby poprosić użytkownika o wybranie obrazu z aplikacji galerii.

Kotlin

val image: InputImage
try {
    image = InputImage.fromFilePath(context, uri)
} catch (e: IOException) {
    e.printStackTrace()
}
MLKitVisionImage.kt

Java

InputImage image;
try {
    image = InputImage.fromFilePath(context, uri);
} catch (IOException e) {
    e.printStackTrace();
}

Używanie ByteBuffer lub ByteArray

Aby utworzyć obiekt InputImage z ByteBuffer lub ByteArray, najpierw oblicz stopień rotacji obrazu, jak opisano wcześniej w przypadku danych wejściowych media.Image. Następnie utwórz obiekt InputImage z buforem lub tablicą, a także z wysokością, szerokością, formatem kodowania kolorów i stopniem obrotu obrazu:

Kotlin

val image = InputImage.fromByteBuffer(
        byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)
MLKitVisionImage.kt
// Or:
val image = InputImage.fromByteArray(
        byteArray,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromByteBuffer(byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);
MLKitVisionImage.java
// Or:
InputImage image = InputImage.fromByteArray(
        byteArray,
        /* image width */480,
        /* image height */360,
        rotation,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);
MLKitVisionImage.java

Korzystanie z Bitmap

Aby utworzyć obiekt InputImage z obiektu Bitmap, zadeklaruj:

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);
MLKitVisionImage.java

Obraz jest reprezentowany przez obiekt Bitmap wraz ze stopniami obrotu.

3. Uruchamianie narzędzia do etykietowania obrazów

Aby oznaczyć obiekty na obrazie, przekaż obiekt image do metody process() w ImageLabeler.

Kotlin

labeler.process(image)
        .addOnSuccessListener { labels ->
            // Task completed successfully
            // ...
        }
        .addOnFailureListener { e ->
            // Task failed with an exception
            // ...
        }
ImageLabelingActivity.kt

Java

labeler.process(image)
        .addOnSuccessListener(new OnSuccessListener<List<ImageLabel>>() {
            @Override
            public void onSuccess(List<ImageLabel> labels) {
                // Task completed successfully
                // ...
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // Task failed with an exception
                // ...
            }
        });
ImageLabelingActivity.java

Uwaga: jeśli używasz interfejsu API CameraX, po zakończeniu korzystania z niego zamknij ImageProxy, np. dodając OnCompleteListener do Task zwróconego przez metodę process. Przykład znajdziesz w klasie VisionProcessorBase w przykładowej aplikacji z szybkim wprowadzeniem.

4. Uzyskiwanie informacji o oznaczonych obiektach

Jeśli operacja etykietowania obrazu się powiedzie, do odbiornika sukcesu zostanie przekazana lista obiektów ImageLabel. Każdy obiekt ImageLabel reprezentuje coś, co zostało oznaczone etykietą na obrazie. Możesz uzyskać tekstowy opis każdej etykiety, wskaźnik ufności dopasowania i indeks dopasowania. Na przykład:

Kotlin

for (label in labels) {
    val text = label.text
    val confidence = label.confidence
    val index = label.index
}
ImageLabelingActivity.kt

Java

for (ImageLabel label : labels) {
    String text = label.getText();
    float confidence = label.getConfidence();
    int index = label.getIndex();
}
ImageLabelingActivity.java

Wskazówki dotyczące poprawy skuteczności w czasie rzeczywistym

Jeśli chcesz oznaczać obrazy w aplikacji działającej w czasie rzeczywistym, postępuj zgodnie z tymi wskazówkami, aby uzyskać najlepszą liczbę klatek na sekundę:

• Jeśli używasz interfejsu API Camera lub camera2, ograniczaj wywołania narzędzia do etykietowania obrazów. Jeśli podczas działania narzędzia do etykietowania obrazów pojawi się nowa klatka wideo, odrzuć ją. Przykład znajdziesz w klasie VisionProcessorBase w przykładowej aplikacji z krótkiego wprowadzenia.
• Jeśli używasz interfejsu CameraX API, upewnij się, że strategia ograniczenia przepustowości ma wartość domyślną ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST. Gwarantuje to, że do analizy będzie przesyłany tylko 1 obraz naraz. Jeśli w czasie, gdy analizator jest zajęty, zostanie wygenerowanych więcej obrazów, zostaną one automatycznie odrzucone i nie zostaną umieszczone w kolejce do dostarczenia. Gdy analizowany obraz zostanie zamknięty przez wywołanie ImageProxy.close(), zostanie dostarczony kolejny najnowszy obraz.
• Jeśli używasz danych wyjściowych narzędzia do etykietowania obrazów, aby nakładać grafikę na obraz wejściowy, najpierw uzyskaj wynik z ML Kit, a potem w jednym kroku wyrenderuj obraz i nałóż na niego grafikę. Jest on renderowany na powierzchni wyświetlacza tylko raz dla każdej ramki wejściowej. Przykład znajdziesz w klasach CameraSourcePreview i  GraphicOverlay w przykładowej aplikacji z krótkiego wprowadzenia.
• Jeśli używasz interfejsu Camera2 API, rób zdjęcia w formacie ImageFormat.YUV_420_888. Jeśli używasz starszego interfejsu Camera API, rób zdjęcia w formacie ImageFormat.NV21.