Google używa technologii AI do tłumaczenia treści na Twój preferowany język. Tłumaczenia wygenerowane przez AI mogą zawierać błędy.

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

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

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

Wypróbuj

Wypróbuj przykładową aplikację, aby zobaczyć, jak można używać tego interfejsu API.

Zanim zaczniesz

1. W pliku build.gradle na poziomie projektu dodaj repozytorium Google Maven w sekcjach buildscript i allprojects.

2. Dodaj zależności dla bibliotek ML Kit na Androida do pliku gradle na poziomie aplikacji modułu (zwykle 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, dodaj Firebase do projektu aplikacji na Androida, jeśli jeszcze nie korzystasz w nim z tej usługi. Nie jest to wymagane, gdy dołączasz model do pakietu.

1. Wczytywanie modelu

Konfigurowanie źródła modelu lokalnego

Aby dołączyć model do aplikacji:

1. Wyodrębnij model i jego metadane z pliku ZIP pobranego z konsoli Firebase. Zalecamy używanie pobranych plików bez wprowadzania w nich zmian (dotyczy to również nazw plików).

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

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

b. Utwórz podfolder w folderze zasobów, który będzie zawierał 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. Dodaj do pliku build.gradle aplikacji ten kod, aby Gradle nie kompresował pliku modelu podczas tworzenia aplikacji:

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

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

Uwaga: od wersji 4.1 wtyczki Androida do obsługi Gradle pliki .tflite będą domyślnie dodawane do listy noCompress i powyższe czynności nie będą już potrzebne.

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ę przypisaną do modelu podczas jego 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 zadanie pobierania modelu, określając warunki, w których chcesz zezwolić na pobieranie. Jeśli modelu nie ma na urządzeniu lub dostępna jest jego 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 zadanie pobierania w kodzie inicjującym, ale możesz to zrobić w dowolnym momencie, zanim będziesz potrzebować modelu.

Tworzenie etykietującego obrazy na podstawie modelu

Po skonfigurowaniu źródeł modelu utwórz obiekt ImageLabeler na podstawie jednego z nich.

Jeśli masz tylko model powiązany lokalnie, utwórz etykietującego z obiektu AutoMLImageLabelerLocalModel i skonfiguruj wymagany próg wyniku ufności (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 uruchomieniem musisz sprawdzić, czy został pobrany. Stan zadania pobierania modelu możesz sprawdzić za pomocą metody isModelDownloaded() menedżera modeli.

Chociaż wystarczy to potwierdzić przed uruchomieniem etykietującego, jeśli masz zarówno model hostowany zdalnie, jak i model dołączony lokalnie, warto przeprowadzić tę kontrolę podczas tworzenia instancji etykietującego obrazy: utwórz etykietującego z modelu zdalnego, jeśli został pobrany, a w przeciwnym razie z 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 detektor 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ć etykietą, utwórz obiekt InputImage na podstawie obrazu. Funkcja oznaczania obrazów etykietami działa najszybciej, gdy używasz Bitmap lub, jeśli używasz interfejsu camera2 API, YUV_420_888 media.Image, które są zalecane, gdy jest to możliwe.

Obiekt InputImage możesz utworzyć z różnych źródeł, które opisujemy poniżej.

Korzystanie z urządzenia `media.Image`

Aby utworzyć obiekt InputImage z obiektu media.Image, np. gdy robisz zdjęcie aparatem 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ść obrotu 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 go obliczyć 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);

Za pomocą identyfikatora URI pliku

Aby utworzyć obiekt InputImage z identyfikatora URI pliku, przekaż kontekst aplikacji i identyfikator URI pliku do 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();
}

Za pomocą `ByteBuffer` lub `ByteArray`

Aby utworzyć obiekt InputImage z ByteBuffer lub ByteArray, najpierw oblicz stopień obrotu obrazu, jak opisano wcześniej w przypadku danych wejściowych media.Image. Następnie utwórz obiekt InputImage z buforem lub tablicą oraz 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 urządzenia `Bitmap`

Aby utworzyć obiekt InputImage z obiektu Bitmap, utwórz tę deklarację:

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 z liczbą stopni obrotu.

3. Uruchamianie narzędzia do oznaczania obrazów etykietami

Aby oznaczyć etykietami obiekty na obrazie, przekaż obiekt image do metody process() obiektu 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, pamiętaj, aby zamknąć ImageProxy, gdy skończysz z niego korzystać, np. przez dodanie OnCompleteListener do Task zwróconego przez metodę process. Zobacz przykład w klasie VisionProcessorBase w przykładowej aplikacji w krótkim wprowadzeniu.

4. Uzyskiwanie informacji o obiektach oznaczonych etykietami

Jeśli operacja oznaczania obrazu etykietami się powiedzie, do detektora sukcesu zostanie przekazana lista obiektów ImageLabel. Każdy obiekt ImageLabel reprezentuje coś, co zostało oznaczone etykietą na obrazie. Możesz uzyskać opis tekstowy 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 wydajności w czasie rzeczywistym

Jeśli chcesz oznaczać etykietami 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, ogranicz wywołania do modułu oznaczania obrazów etykietami. Jeśli podczas działania modułu do oznaczania obrazów etykietami pojawi się nowa klatka wideo, odrzuć ją. Przykład znajdziesz w klasie VisionProcessorBase w przykładowej aplikacji w krótkim wprowadzeniu.
Jeśli używasz interfejsu API CameraX, upewnij się, że strategia przeciwciśnienia jest ustawiona na wartość domyślną ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST. Dzięki temu do analizy będzie dostarczany tylko 1 obraz naraz. Jeśli podczas analizy zostaną wygenerowane kolejne obrazy, zostaną one automatycznie odrzucone i nie będą umieszczane w kolejce do dostarczenia. Po zamknięciu analizowanego obrazu przez wywołanie metody ImageProxy.close() zostanie dostarczony kolejny najnowszy obraz.
Jeśli używasz danych wyjściowych funkcji oznaczania obrazów etykietami do nakładania grafiki na obraz wejściowy, najpierw pobierz wynik z ML Kit, a następnie wyrenderuj obraz i nakładkę w jednym kroku. Renderowanie na powierzchni wyświetlacza odbywa się tylko raz dla każdej klatki wejściowej. Przykład znajdziesz w klasach CameraSourcePreview i GraphicOverlay w przykładowej aplikacji z krótkiego przewodnika.
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.

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

Wypróbuj

Zanim zaczniesz

1. Wczytywanie modelu

Konfigurowanie źródła modelu lokalnego

Kotlin

Java

Konfigurowanie źródła modelu hostowanego w Firebase

Kotlin

Java

Kotlin

Java

Tworzenie etykietującego obrazy na podstawie modelu

Kotlin

Java

Kotlin

Java

Kotlin

Java

2. Przygotowywanie obrazu wejściowego

Korzystanie z urządzenia media.Image

Kotlin

Java

Kotlin

Java

Kotlin

Java

Za pomocą identyfikatora URI pliku

Kotlin

Java

Za pomocą ByteBuffer lub ByteArray

Kotlin

Java

Korzystanie z urządzenia Bitmap

Kotlin

Java

3. Uruchamianie narzędzia do oznaczania obrazów etykietami

Kotlin

Java

4. Uzyskiwanie informacji o obiektach oznaczonych etykietami

Kotlin

Java

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

Korzystanie z urządzenia `media.Image`

Za pomocą `ByteBuffer` lub `ByteArray`

Korzystanie z urządzenia `Bitmap`