TensorFlow 14 Mayıs'ta Google I/O'ya geri döndü! Şimdi üye Ol

Bu sayfa, Cloud Translation API ile çevrilmiştir.

Android ile nesne algılama

Bu eğitimde, bir cihaz kamerası tarafından yakalanan karelerdeki nesneleri sürekli olarak algılamak için TensorFlow Lite kullanarak bir Android uygulamasının nasıl oluşturulacağı gösterilmektedir. Bu uygulama fiziksel bir Android cihaz için tasarlanmıştır. Mevcut bir projeyi güncelliyorsanız kod örneğini referans olarak kullanabilir ve projenizi değiştirme talimatlarına geçebilirsiniz.

Nesne algılama animasyonlu demosu

Nesne algılamaya genel bakış

Nesne algılama, bir görüntüdeki birden fazla nesne sınıfının varlığını ve konumunu belirlemeye yönelik makine öğrenimi görevidir. Bir nesne algılama modeli, bilinen bir dizi nesneyi içeren bir veri kümesi üzerinde eğitilir.

Eğitilen model, girdi olarak görüntü çerçevelerini alır ve tanımak üzere eğitildiği bilinen sınıflar kümesinden görüntülerdeki öğeleri kategorilere ayırmaya çalışır. Nesne algılama modeli, her görüntü çerçevesi için algıladığı nesnelerin bir listesini, her nesne için bir sınırlayıcı kutunun konumunu ve doğru şekilde sınıflandırılan nesnenin güvenilirliğini gösteren bir puan verir.

Modeller ve veri kümesi

Bu eğitimde COCO veri kümesi kullanılarak eğitilmiş modeller kullanılmaktadır. COCO, 330 bin görüntü, 1,5 milyon nesne örneği ve 80 nesne kategorisi içeren büyük ölçekli bir nesne algılama veri kümesidir.

Aşağıdaki önceden eğitilmiş modellerden birini kullanma seçeneğiniz vardır:

EfficientDet-Lite0 [Önerilen] - BiFPN özellik çıkarıcı, paylaşımlı kutu tahmincisi ve odak kaybı içeren hafif bir nesne algılama modeli. COCO 2017 doğrulama veri kümesi için mAP (ortalama Ortalama Hassasiyet) %25,69'dur.
EfficientDet-Lite1 - orta büyüklükte bir EfficientDet nesne algılama modeli. COCO 2017 doğrulama veri kümesi için mAP %30,55'tir.
EfficientDet-Lite2 - daha büyük bir EfficientDet nesne algılama modeli. COCO 2017 doğrulama veri kümesi için mAP %33,97'dir.
MobileNetV1-SSD - nesne algılama için TensorFlow Lite ile çalışmak üzere optimize edilmiş son derece hafif bir model. COCO 2017 doğrulama veri kümesi için mAP %21'dir.

Bu eğitimde EfficientDet-Lite0 modeli boyut ve doğruluk arasında iyi bir denge kuruyor.

Modellerin indirilmesi, çıkarılması ve varlıklar klasörüne yerleştirilmesi, derleme sırasında çalıştırılan download.gradle dosyası tarafından otomatik olarak yönetilir. TFLite modellerini projeye manuel olarak indirmenize gerek yoktur.

Kurulum ve çalıştırma örneği

Nesne algılama uygulamasını kurmak için örneği GitHub'dan indirin ve Android Studio'yu kullanarak çalıştırın. Bu öğreticinin aşağıdaki bölümleri, kod örneğinin ilgili bölümlerini inceler; böylece bunları kendi Android uygulamalarınıza uygulayabilirsiniz.

Sistem gereksinimleri

Android Studio sürüm 2021.1.1 (Bumblebee) veya üzeri.
Android SDK sürüm 31 veya üzeri
Geliştirici modunun etkin olduğu, minimum işletim sistemi sürümü SDK 24'e (Android 7.0 - Nougat) sahip Android cihazı.

Örnek kodu alın

Örnek kodun yerel bir kopyasını oluşturun. Android Studio'da proje oluşturup örnek uygulamayı çalıştırmak için bu kodu kullanacaksınız.

Örnek kodu klonlamak ve ayarlamak için:

Git deposu

git clone https://github.com/tensorflow/examples.git

klonlayın

İsteğe bağlı olarak git örneğinizi seyrek ödeme kullanacak şekilde yapılandırın, böylece yalnızca nesne algılama örnek uygulamasına ait dosyalara sahip olursunuz:
```
cd examples
git sparse-checkout init --cone
git sparse-checkout set lite/examples/object_detection/android
```

Projeyi içe aktarın ve çalıştırın

İndirilen örnek koddan bir proje oluşturun, projeyi derleyin ve ardından çalıştırın.

Örnek kod projesini içe aktarmak ve oluşturmak için:

Android Studio'yu başlatın.
Android Studio'dan Dosya > Yeni > Projeyi İçe Aktar'ı seçin.
build.gradle dosyasını içeren örnek kod dizinine gidin ( .../examples/lite/examples/object_detection/android/build.gradle ) ve bu dizini seçin.
Android Studio Gradle Sync isterse Tamam'ı seçin.
Android cihazınızın bilgisayarınıza bağlı olduğundan ve geliştirici modunun etkinleştirildiğinden emin olun. Yeşil Run okunu tıklayın.

Doğru dizini seçerseniz Android Studio yeni bir proje oluşturur ve onu derler. Bu işlem, bilgisayarınızın hızına ve Android Studio'yu başka projeler için kullanıp kullanmadığınıza bağlı olarak birkaç dakika sürebilir. Derleme tamamlandığında Android Studio, Derleme Çıktısı durum panelinde OLUŞTURMA BUILD SUCCESSFUL mesajını görüntüler.

İsteğe bağlı: Android eklentisi sürümünü güncelleyerek derleme hatalarını düzeltmek için:

Build.gradle dosyasını proje dizininde açın.

Android araçları sürümünü aşağıdaki gibi değiştirin:

// from: classpath
'com.android.tools.build:gradle:4.2.2'
// to: classpath
'com.android.tools.build:gradle:4.1.2'

Projeyi şunu seçerek senkronize edin: File > Sync Project with Gradle Files .

Projeyi çalıştırmak için:

Android Studio'dan Run > Run…' ı seçerek projeyi çalıştırın.
Uygulamayı test etmek için kameralı bağlı bir Android cihazı seçin.

Sonraki bölümlerde, bu örnek uygulamayı referans noktası olarak kullanarak, bu işlevselliği kendi uygulamanıza eklemek için mevcut projenizde yapmanız gereken değişiklikleri gösterir.

Proje bağımlılıkları ekleyin

Kendi uygulamanızda, TensorFlow Lite makine öğrenimi modellerini çalıştırmak için belirli proje bağımlılıkları eklemeniz ve görüntüler gibi verileri, kullandığınız model tarafından işlenebilecek bir tensör veri formatına dönüştüren yardımcı program işlevlerine erişmeniz gerekir.

Örnek uygulama, nesne algılama makine öğrenimi modelinin yürütülmesini sağlamak amacıyla görüş için TensorFlow Lite Görev kitaplığını kullanır. Aşağıdaki talimatlar, gerekli kitaplık bağımlılıklarını kendi Android uygulama projenize nasıl ekleyeceğinizi açıklamaktadır.

Aşağıdaki talimatlar, gerekli proje ve modül bağımlılıklarını kendi Android uygulama projenize nasıl ekleyeceğinizi açıklamaktadır.

Modül bağımlılıkları eklemek için:

TensorFlow Lite kullanan modülde, modülün build.gradle dosyasını aşağıdaki bağımlılıkları içerecek şekilde güncelleyin. Örnek kodda bu dosya burada bulunur: ...examples/lite/examples/object_detection/android/app/build.gradle ( kod referansı )
```
dependencies {
  ...
  implementation 'org.tensorflow:tensorflow-lite-task-vision:0.4.0'
  // Import the GPU delegate plugin Library for GPU inference
  implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin:0.4.0'
  implementation 'org.tensorflow:tensorflow-lite-gpu:2.9.0'
}
```
Proje, Vision görev kitaplığını ( tensorflow-lite-task-vision ) içermelidir. Grafik işlem birimi (GPU) kitaplığı ( tensorflow-lite-gpu-delegate-plugin ), uygulamayı GPU'da çalıştırmak için altyapıyı sağlar ve Delege ( tensorflow-lite-gpu ) uyumluluk listesini sağlar.
Android Studio'da, şunu seçerek proje bağımlılıklarını senkronize edin: File > Sync Project with Gradle Files .

ML modelini başlat

Android uygulamanızda, tahminleri modelle çalıştırmadan önce TensorFlow Lite makine öğrenimi modelini parametrelerle başlatmanız gerekir. Bu başlatma parametreleri, nesne algılama modelleri genelinde tutarlıdır ve tahminler için minimum doğruluk eşikleri gibi ayarları içerebilir.

TensorFlow Lite modeli, model kodunu içeren bir .tflite dosyası içerir ve sıklıkla model tarafından tahmin edilen sınıfların adlarını içeren bir etiket dosyası içerir. Nesne tespiti durumunda sınıflar kişi, köpek, kedi veya araba gibi nesnelerdir.

Bu örnek, download_models.gradle dosyasında belirtilen çeşitli modelleri indirir ve ObjectDetectorHelper sınıfı, modeller için bir seçici sağlar:

val modelName =
  when (currentModel) {
    MODEL_MOBILENETV1 -> "mobilenetv1.tflite"
    MODEL_EFFICIENTDETV0 -> "efficientdet-lite0.tflite"
    MODEL_EFFICIENTDETV1 -> "efficientdet-lite1.tflite"
    MODEL_EFFICIENTDETV2 -> "efficientdet-lite2.tflite"
    else -> "mobilenetv1.tflite"
  }

Modeli uygulamanızda başlatmak için:

Geliştirme projenizin src/main/assets dizinine EfficientDet-Lite0 gibi bir .tflite model dosyası ekleyin.
Modelinizin dosya adı için statik bir değişken ayarlayın. Örnek uygulamada EfficientDet-Lite0 algılama modelini kullanmak için modelName değişkenini MODEL_EFFICIENTDETV0 olarak ayarlarsınız.

Tahmin eşiği, sonuç kümesi boyutu ve isteğe bağlı olarak donanım hızlandırma delegeleri gibi model seçeneklerini ayarlayın:

val optionsBuilder =
  ObjectDetector.ObjectDetectorOptions.builder()
    .setScoreThreshold(threshold)
    .setMaxResults(maxResults)

Modeli içeren bir TensorFlow Lite ObjectDetector nesnesi oluşturmak için bu nesnedeki ayarları kullanın:

objectDetector =
  ObjectDetector.createFromFileAndOptions(
    context, modelName, optionsBuilder.build())

setupObjectDetector aşağıdaki model parametrelerini ayarlar:

Algılama eşiği
Maksimum algılama sonucu sayısı
Kullanılacak işleme iş parçacığı sayısı ( BaseOptions.builder().setNumThreads(numThreads) )
Gerçek model ( modelName )
ObjectDetector nesnesi ( objectDetector )

Donanım hızlandırıcıyı yapılandırma

Uygulamanızda bir TensorFlow Lite modelini başlatırken, modelin tahmin hesaplamalarını hızlandırmak için donanım hızlandırma özelliklerini kullanabilirsiniz.

TensorFlow Lite delegeleri , Grafik İşleme Birimleri (GPU'lar), Tensör İşleme Birimleri (TPU'lar) ve Dijital Sinyal İşlemcileri (DSP'ler) gibi bir mobil cihazda özel işleme donanımını kullanarak makine öğrenimi modellerinin yürütülmesini hızlandıran yazılım modülleridir. TensorFlow Lite modellerini çalıştırmak için delegelerin kullanılması önerilir ancak zorunlu değildir.

Nesne algılayıcı, onu kullanan iş parçacığında geçerli ayarlar kullanılarak başlatılır. Ana iş parçacığında oluşturulan ve arka plan iş parçacığında kullanılan algılayıcılarla CPU ve NNAPI temsilcilerini kullanabilirsiniz, ancak algılayıcıyı başlatan iş parçacığının GPU temsilcisini kullanması gerekir.

Delegeler ObjectDetectionHelper.setupObjectDetector() işlevi içinde ayarlanır:

when (currentDelegate) {
    DELEGATE_CPU -> {
        // Default
    }
    DELEGATE_GPU -> {
        if (CompatibilityList().isDelegateSupportedOnThisDevice) {
            baseOptionsBuilder.useGpu()
        } else {
            objectDetectorListener?.onError("GPU is not supported on this device")
        }
    }
    DELEGATE_NNAPI -> {
        baseOptionsBuilder.useNnapi()
    }
}

TensorFlow Lite ile donanım hızlandırma delegelerini kullanma hakkında daha fazla bilgi için bkz . TensorFlow Lite Delegeleri .

Model için veri hazırlama

Android uygulamanızda kodunuz, görüntü çerçeveleri gibi mevcut verileri modeliniz tarafından işlenebilecek bir Tensor veri formatına dönüştürerek yorumlanmak üzere modele veri sağlar. Bir modele ilettiğiniz Tensördeki verilerin, modeli eğitmek için kullanılan veri formatıyla eşleşen belirli boyutlara veya şekle sahip olması gerekir.

Bu kod örneğinde kullanılan EfficientDet-Lite0 modeli, piksel başına üç kanal (kırmızı, mavi ve yeşil) ile 320 x 320 boyutundaki görüntüleri temsil eden Tensörleri kabul eder. Tensördeki her değer 0 ile 255 arasında tek bir bayttır. Dolayısıyla, yeni görüntüler üzerinde tahminler yürütmek için uygulamanızın bu görüntü verilerini bu boyut ve şekildeki Tensor veri nesnelerine dönüştürmesi gerekir. TensorFlow Lite Görev Kitaplığı Görüş API'si veri dönüşümünü sizin için yönetir.

Uygulama, kameradan görüntü çekmek için bir ImageAnalysis nesnesi kullanır. Bu nesne, kameradan bit eşlemli detectObject işlevini çağırır. Veriler, modelin görüntü verisi gereksinimlerini karşılayacak şekilde ImageProcessor tarafından otomatik olarak yeniden boyutlandırılır ve döndürülür. Görüntü daha sonra bir TensorImage nesnesine çevrilir.

ML modeli tarafından işlenecek kamera alt sisteminden veri hazırlamak için:

Görüntüleri gerekli formatta çıkarmak için bir ImageAnalysis nesnesi oluşturun:

imageAnalyzer =
    ImageAnalysis.Builder()
        .setTargetAspectRatio(AspectRatio.RATIO_4_3)
        .setTargetRotation(fragmentCameraBinding.viewFinder.display.rotation)
        .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
        .setOutputImageFormat(OUTPUT_IMAGE_FORMAT_RGBA_8888)
        .build()
        ...

Analizörü kamera alt sistemine bağlayın ve kameradan alınan verileri içerecek bir bitmap arabelleği oluşturun:

.also {
  it.setAnalyzer(cameraExecutor) {
    image -> if (!::bitmapBuffer.isInitialized)
    { bitmapBuffer = Bitmap.createBitmap( image.width, image.height,
    Bitmap.Config.ARGB_8888 ) } detectObjects(image)
    }
  }

Modelin ihtiyaç duyduğu belirli görüntü verilerini çıkarın ve görüntü döndürme bilgilerini iletin:

private fun detectObjects(image: ImageProxy) {
  //Copy out RGB bits to the shared bitmap buffer
  image.use {bitmapBuffer.copyPixelsFromBuffer(image.planes[0].buffer) }
    val imageRotation = image.imageInfo.rotationDegrees
    objectDetectorHelper.detect(bitmapBuffer, imageRotation)
  }

Örnek uygulamanın ObjectDetectorHelper.detect() yönteminde gösterildiği gibi, tüm son veri dönüştürmelerini tamamlayın ve görüntü verilerini bir TensorImage nesnesine ekleyin:

val imageProcessor = ImageProcessor.Builder().add(Rot90Op(-imageRotation / 90)).build()
// Preprocess the image and convert it into a TensorImage for detection.
val tensorImage = imageProcessor.process(TensorImage.fromBitmap(image))

Tahminleri çalıştır

Android uygulamanızda, görüntü verileriyle doğru formatta bir TensorImage nesnesi oluşturduğunuzda, bir tahmin veya çıkarım oluşturmak için modeli bu verilere göre çalıştırabilirsiniz.

Örnek uygulamanın fragments/CameraFragment.kt sınıfında, bindCameraUseCases işlevi içindeki imageAnalyzer nesnesi, uygulama kameraya bağlandığında tahminler için verileri otomatik olarak modele aktarır.

Uygulama, kamera seçiciyi, önizleme penceresini ve ML modeli işlemeyi yönetmek için cameraProvider.bindToLifecycle() yöntemini kullanır. ObjectDetectorHelper.kt sınıfı, görüntü verilerinin modele aktarılmasını yönetir. Modeli çalıştırmak ve görüntü verilerinden tahminler oluşturmak için:

Görüntü verilerini tahmin işlevinize ileterek tahmini çalıştırın:
```
val results = objectDetector?.detect(tensorImage)
```

TensorFlow Lite Interpreter nesnesi bu verileri alır, modelde çalıştırır ve bir tahmin listesi üretir. Verilerin model tarafından sürekli olarak işlenmesi için runForMultipleInputsOutputs() yöntemini kullanın; böylece her tahmin çalıştırması için Interpreter nesneleri oluşturulup sistem tarafından kaldırılmaz.

Model çıktısını işle

Android uygulamanızda, görüntü verilerini nesne algılama modeline göre çalıştırdıktan sonra, uygulama kodunuzun ek iş mantığını yürüterek, sonuçları kullanıcıya görüntüleyerek veya başka eylemler gerçekleştirerek işlemesi gereken tahminlerin bir listesini üretir.

Herhangi bir TensorFlow Lite modelinin çıktısı, ürettiği tahminlerin sayısına (bir veya daha fazla) ve her tahmin için açıklayıcı bilgilere göre değişir. Bir nesne algılama modeli durumunda, tahminler tipik olarak bir nesnenin görüntüde nerede algılandığını belirten bir sınırlayıcı kutuya ilişkin verileri içerir. Örnek kodda sonuçlar, nesne algılama işleminde DetectorListener görevi gören CameraFragment.kt içindeki onResults işlevine iletilir.

interface DetectorListener {
  fun onError(error: String)
  fun onResults(
    results: MutableList<Detection>?,
    inferenceTime: Long,
    imageHeight: Int,
    imageWidth: Int
  )
}

Bu örnekte kullanılan model için her tahmin, nesne için bir sınırlayıcı kutu konumu, nesne için bir etiket ve tahminin güvenirliğini temsil eden bir Kayan Nokta olarak 0 ile 1 arasında bir tahmin puanı içerir; 1 en yüksek güven derecesidir . Genel olarak, puanı %50'nin (0,5) altında olan tahminler sonuçsuz kabul edilir. Ancak düşük değerli tahmin sonuçlarını nasıl ele alacağınız size ve uygulamanızın ihtiyaçlarına bağlıdır.

Model tahmin sonuçlarını işlemek için:

Sonuçları uygulama kodunuza veya kullanıcı arayüzü nesnelerinize iletmek için bir dinleyici modeli kullanın. Örnek uygulama, algılama sonuçlarını ObjectDetectorHelper nesnesinden CameraFragment nesnesine aktarmak için bu modeli kullanır:
```
objectDetectorListener.onResults(
// instance of CameraFragment
    results,
    inferenceTime,
    tensorImage.height,
    tensorImage.width)
```

Tahmini kullanıcıya görüntülemek gibi sonuçlara göre hareket edin. Örnek, sonucu göstermek için CameraPreview nesnesinin üzerine bir kaplama çizer:

override fun onResults(
  results: MutableList<Detection>?,
  inferenceTime: Long,
  imageHeight: Int,
  imageWidth: Int
) {
    activity?.runOnUiThread {
        fragmentCameraBinding.bottomSheetLayout.inferenceTimeVal.text =
            String.format("%d ms", inferenceTime)

        // Pass necessary information to OverlayView for drawing on the canvas
        fragmentCameraBinding.overlay.setResults(
            results ?: LinkedList<Detection>(),
            imageHeight,
            imageWidth
        )

        // Force a redraw
        fragmentCameraBinding.overlay.invalidate()
    }
}

Model bir tahmin sonucu döndürdüğünde uygulamanız, sonucu kullanıcınıza sunarak veya ek mantık yürüterek bu tahmine göre hareket edebilir. Örnek kodda uygulama, tanımlanan nesnenin etrafına bir sınırlayıcı kutu çizer ve sınıf adını ekranda görüntüler.

Sonraki adımlar

Örneklerde TensorFlow Lite'ın çeşitli kullanımlarını keşfedin.
Modeller bölümünde TensorFlow Lite ile makine öğrenimi modellerini kullanma hakkında daha fazla bilgi edinin.
TensorFlow Lite Geliştirici Kılavuzu'ndan makine öğrenimini mobil uygulamanıza uygulama hakkında daha fazla bilgi edinin.