Check out what’s new from Firebase at Google I/O 2022. Learn more

Android'de AutoML eğitimli bir modelle görüntüleri etiketleyin

AutoML Vision Edge kullanarak kendi modelinizi eğittikten sonra, görüntüleri etiketlemek için uygulamanızda kullanabilirsiniz.

AutoML Vision Edge'den eğitilen modelleri entegre etmenin iki yolu vardır: Modeli uygulamanızın varlık klasörüne koyarak paketleyebilir veya Firebase'den dinamik olarak indirebilirsiniz.

Model paketleme seçenekleri
Uygulamanızda paketlenmiş
  • Model, uygulamanızın APK'sının bir parçasıdır
  • Model, Android cihaz çevrimdışıyken bile hemen kullanılabilir
  • Firebase projesine gerek yok
Firebase ile barındırılıyor
  • Modeli Firebase Machine Learning'e yükleyerek barındırın
  • APK boyutunu küçültür
  • Model talep üzerine indirilir
  • Uygulamanızı yeniden yayınlamadan model güncellemelerini gönderin
  • Firebase Remote Config ile kolay A/B testi
  • Bir Firebase projesi gerektirir

Sen başlamadan önce

  1. ML Kit Android kitaplıklarının bağımlılıklarını, modülünüzün genellikle app/build.gradle olan uygulama düzeyindeki gradle dosyasına ekleyin:

    Uygulamanızla bir modeli gruplamak için:

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

    Firebase'den dinamik olarak bir model indirmek için linkFirebase bağımlılığını ekleyin:

    dependencies {
      // ...
      // Image labeling feature with automl model downloaded
      // from firebase
      implementation 'com.google.mlkit:image-labeling-custom:16.3.1'
      implementation 'com.google.mlkit:linkfirebase:16.1.0'
    }
    
  2. Bir model indirmek istiyorsanız, henüz yapmadıysanız Firebase'i Android projenize eklediğinizden emin olun. Modeli paketlediğinizde bu gerekli değildir.

1. Modeli yükleyin

Yerel bir model kaynağı yapılandırın

Modeli uygulamanızla birleştirmek için:

  1. Modeli ve meta verilerini Firebase konsolundan indirdiğiniz zip arşivinden çıkarın. Dosyaları indirdiğiniz gibi, değişiklik yapmadan (dosya adları dahil) kullanmanızı öneririz.

  2. Modelinizi ve meta veri dosyalarını uygulama paketinize ekleyin:

    1. Projenizde bir varlıklar klasörünüz yoksa app/ klasöre sağ tıklayıp ardından Yeni > Klasör > Varlıklar Klasörü öğesine tıklayarak bir tane oluşturun.
    2. Model dosyalarını içermek için varlıklar klasörünün altında bir alt klasör oluşturun.
    3. model.tflite , dict.txt ve manifest.json dosyalarını alt klasöre kopyalayın (üç dosyanın tümü aynı klasörde olmalıdır).
  3. Gradle'ın uygulamayı oluştururken model dosyasını sıkıştırmamasını sağlamak için uygulamanızın build.gradle dosyasına aşağıdakini ekleyin:

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

    Model dosyası, uygulama paketine dahil edilecek ve ham bir varlık olarak ML Kit'e sunulacak.

  4. Model bildirim dosyasının yolunu belirterek LocalModel nesnesi oluşturun:

    Java

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

    Kotlin

    val localModel = LocalModel.Builder()
        .setAssetManifestFilePath("manifest.json")
        // or .setAbsoluteManifestFilePath(absolute file path to manifest file)
        .build()
    

Firebase tarafından barındırılan bir model kaynağı yapılandırın

Uzaktan barındırılan modeli kullanmak için, modeli yayınladığınızda atadığınız adı belirterek bir CustomRemoteModel nesnesi oluşturun:

Java

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

Kotlin

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

Ardından, indirmeye izin vermek istediğiniz koşulları belirterek model indirme görevini başlatın. Model cihazda değilse veya modelin daha yeni bir sürümü mevcutsa görev, modeli Firebase'den eşzamansız olarak indirir:

Java

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

Kotlin

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

Birçok uygulama indirme görevini başlatma kodunda başlatır, ancak bunu modeli kullanmaya ihtiyaç duymadan önce herhangi bir noktada yapabilirsiniz.

Modelinizden bir görüntü etiketleyici oluşturun

Model kaynaklarınızı yapılandırdıktan sonra, bunlardan birinden bir ImageLabeler nesnesi oluşturun.

Yalnızca yerel olarak paketlenmiş bir modeliniz varsa, CustomImageLabelerOptions nesnenizden bir etiketleyici oluşturmanız ve ihtiyaç duyduğunuz güven puanı eşiğini yapılandırmanız yeterlidir (bkz . Modelinizi değerlendirin ):

Java

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

Kotlin

val customImageLabelerOptions = CustomImageLabelerOptions.Builder(localModel)
    .setConfidenceThreshold(0.0f)  // Evaluate your model in the Cloud console
                                   // to determine an appropriate value.
    .build()
val labeler = ImageLabeling.getClient(customImageLabelerOptions)

Uzaktan barındırılan bir modeliniz varsa, çalıştırmadan önce indirildiğini kontrol etmeniz gerekir. Model yöneticisinin isModelDownloaded() yöntemini kullanarak model indirme görevinin durumunu kontrol edebilirsiniz.

Etiketleyiciyi çalıştırmadan önce yalnızca bunu onaylamanız gerekse de, hem uzaktan barındırılan hem de yerel olarak paketlenmiş bir modeliniz varsa, görüntü etiketleyiciyi başlatırken bu kontrolü yapmak mantıklı olabilir: aşağıdaki durumlarda uzak modelden bir etiketleyici oluşturun: indirildi ve aksi takdirde yerel modelden.

Java

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

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

Kotlin

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

Yalnızca uzaktan barındırılan bir modeliniz varsa, modelin indirildiğini onaylayana kadar modelle ilgili işlevleri devre dışı bırakmalısınız (örneğin, kullanıcı arayüzünüzün bir bölümünü grileştirme veya gizleme). Model yöneticisinin download() yöntemine bir dinleyici ekleyerek bunu yapabilirsiniz:

Java

RemoteModelManager.getInstance().download(remoteModel, conditions)
        .addOnSuccessListener(new OnSuccessListener<Void>() {
            @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.
            }
        });

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.
    }

2. Giriş görüntüsünü hazırlayın

Ardından, etiketlemek istediğiniz her görüntü için görüntünüzden bir InputImage nesnesi oluşturun. Resim etiketleyici, bir Bitmap kullandığınızda veya camera2 API kullanıyorsanız, mümkün olduğunda önerilen bir YUV_420_888 media.Image kullandığınızda en hızlı şekilde çalışır.

Her biri aşağıda açıklanan farklı kaynaklardan bir InputImage oluşturabilirsiniz.

Bir media.Image kullanma

Bir aygıtın kamerasından bir görüntü yakaladığınızda olduğu gibi bir InputImage nesnesinden bir media.Image nesnesi oluşturmak için, media.Image nesnesini ve görüntünün dönüşünü InputImage.fromMediaImage() .

CameraX kitaplığını kullanırsanız, OnImageCapturedListener ve ImageAnalysis.Analyzer sınıfları döndürme değerini sizin için hesaplar.

Java

private class YourAnalyzer implements ImageAnalysis.Analyzer {

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

Kotlin+KTX

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
            // ...
        }
    }
}

Size görüntünün dönme derecesini veren bir kamera kitaplığı kullanmıyorsanız, bunu cihazın dönme derecesinden ve cihazdaki kamera sensörünün oryantasyonundan hesaplayabilirsiniz:

Java

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

/**
 * 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, Context context)
        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);

    // On most devices, the sensor orientation is 90 degrees, but for some
    // devices it is 270 degrees. For devices with a sensor orientation of
    // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
    CameraManager cameraManager = (CameraManager) context.getSystemService(CAMERA_SERVICE);
    int sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION);
    rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360;

    // Return the corresponding FirebaseVisionImageMetadata rotation value.
    int result;
    switch (rotationCompensation) {
        case 0:
            result = FirebaseVisionImageMetadata.ROTATION_0;
            break;
        case 90:
            result = FirebaseVisionImageMetadata.ROTATION_90;
            break;
        case 180:
            result = FirebaseVisionImageMetadata.ROTATION_180;
            break;
        case 270:
            result = FirebaseVisionImageMetadata.ROTATION_270;
            break;
        default:
            result = FirebaseVisionImageMetadata.ROTATION_0;
            Log.e(TAG, "Bad rotation value: " + rotationCompensation);
    }
    return result;
}

Kotlin+KTX

private val ORIENTATIONS = SparseIntArray()

init {
    ORIENTATIONS.append(Surface.ROTATION_0, 90)
    ORIENTATIONS.append(Surface.ROTATION_90, 0)
    ORIENTATIONS.append(Surface.ROTATION_180, 270)
    ORIENTATIONS.append(Surface.ROTATION_270, 180)
}
/**
 * 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, context: Context): 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)

    // On most devices, the sensor orientation is 90 degrees, but for some
    // devices it is 270 degrees. For devices with a sensor orientation of
    // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
    val cameraManager = context.getSystemService(CAMERA_SERVICE) as CameraManager
    val sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION)!!
    rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360

    // Return the corresponding FirebaseVisionImageMetadata rotation value.
    val result: Int
    when (rotationCompensation) {
        0 -> result = FirebaseVisionImageMetadata.ROTATION_0
        90 -> result = FirebaseVisionImageMetadata.ROTATION_90
        180 -> result = FirebaseVisionImageMetadata.ROTATION_180
        270 -> result = FirebaseVisionImageMetadata.ROTATION_270
        else -> {
            result = FirebaseVisionImageMetadata.ROTATION_0
            Log.e(TAG, "Bad rotation value: $rotationCompensation")
        }
    }
    return result
}

Ardından media.Image nesnesini ve döndürme derecesi değerini InputImage.fromMediaImage() :

Java

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

Kotlin+KTX

val image = InputImage.fromMediaImage(mediaImage, rotation)

Bir dosya URI'sini kullanma

Bir dosya URI'sinden bir InputImage nesnesi oluşturmak için uygulama bağlamını ve dosya URI'sini InputImage.fromFilePath() . Bu, kullanıcıdan galeri uygulamasından bir resim seçmesini istemek için bir ACTION_GET_CONTENT amacı kullandığınızda kullanışlıdır.

Java

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

Kotlin+KTX

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

ByteBuffer veya ByteArray Kullanma

Bir ByteBuffer veya ByteArray bir InputImage nesnesi oluşturmak için, önce media.Image girişi için daha önce açıklandığı gibi görüntü döndürme derecesini hesaplayın. Ardından, görüntünün yüksekliği, genişliği, renk kodlama biçimi ve döndürme derecesi ile birlikte arabellek veya diziyle InputImage nesnesini oluşturun:

Java

InputImage image = InputImage.fromByteBuffer(byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);

Kotlin+KTX

val image = InputImage.fromByteBuffer(
        byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)

Bitmap kullanma

Bir Bitmap nesnesinden bir InputImage nesnesi oluşturmak için aşağıdaki bildirimi yapın:

Java

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

Kotlin+KTX

val image = InputImage.fromBitmap(bitmap, 0)

Görüntü, döndürme dereceleriyle birlikte bir Bitmap nesnesi ile temsil edilir.

3. Görüntü etiketleyiciyi çalıştırın

Bir görüntüdeki nesneleri etiketlemek için, image nesnesini ImageLabeler process() yöntemine iletin.

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
                // ...
            }
        });

Kotlin

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

4. Etiketli nesneler hakkında bilgi alın

Görüntü etiketleme işlemi başarılı olursa, başarılı dinleyiciye ImageLabel nesnelerinin bir listesi iletilir. Her ImageLabel nesnesi, görüntüde etiketlenmiş bir şeyi temsil eder. Her etiketin metin açıklamasını, eşleşmenin güven puanını ve eşleşmenin indeksini alabilirsiniz. Örneğin:

Java

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

Kotlin

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

Gerçek zamanlı performansı iyileştirmeye yönelik ipuçları

Görüntüleri gerçek zamanlı bir uygulamada etiketlemek istiyorsanız, en iyi kare hızlarını elde etmek için şu yönergeleri izleyin:
  • Gaz kelebeği görüntü etiketleyiciye çağrı yapar. Görüntü etiketleyici çalışırken yeni bir video karesi kullanıma sunulursa, kareyi bırakın. Örnek için hızlı başlangıç ​​örnek uygulamasındaki VisionProcessorBase sınıfına bakın.
  • Giriş görüntüsünün üzerine grafik bindirmek için görüntü etiketleyicinin çıkışını kullanıyorsanız, önce sonucu alın, ardından görüntüyü oluşturun ve tek adımda bindirin. Bunu yaparak, her giriş karesi için görüntüleme yüzeyine yalnızca bir kez render alırsınız. Örnek için hızlı başlangıç ​​örnek uygulamasındaki CameraSourcePreview ve GraphicOverlay sınıflarına bakın.
  • Camera2 API kullanıyorsanız, görüntüleri ImageFormat.YUV_420_888 biçiminde yakalayın.

    Daha eski Kamera API'sini kullanıyorsanız, görüntüleri ImageFormat.NV21 biçiminde yakalayın.