TensorFlow Lite ile (Android) özel nesne algılama modeli oluşturma ve dağıtma

1. Başlamadan önce

Bu codelab'de, TFLite Model Oluşturucu ile bir dizi eğitim görseli kullanarak özel bir nesne algılama modelini nasıl eğiteceğinizi ve ardından TFLite Görev Kitaplığı'nı kullanarak modelinizi bir Android uygulamasına dağıtacaksınız. Aşağıdaki işlemleri gerçekleştirirsiniz:

• Yemek resimlerindeki malzemeleri algılayan bir Android uygulaması oluşturun.
• Önceden eğitilmiş bir TFLite nesne algılama modeli entegre edin ve modelin neler algılayabileceğine dair sınırı görün.
• salata ve TFLite Model Oluşturucu adlı özel bir veri kümesi kullanarak, bir malzemenin bileşenlerini/bileşenlerini algılayacak özel bir nesne algılama modeli eğitin.
• TFLite Görev Kitaplığı'nı kullanarak Android modelini özel uygulamaya dağıtın.

Sonunda, aşağıdaki resme benzer bir öğe oluşturursunuz:

Ön koşullar

Bu codelab, Makine Öğrenimi konusunda deneyim edinmek isteyen deneyimli mobil geliştiriciler için tasarlanmıştır. Aşağıdaki konular hakkında bilgi sahibi olmalısınız:

• Kotlin ve Android Studio'yu kullanarak Android geliştirme
• Temel Python söz dizimi

Neler öğreneceksiniz?

• TFLite Model Maker'ı kullanarak özel nesne algılama modelini eğitme.
• TFLite Görev Kitaplığı'nı kullanarak TFLite nesne algılama modeli dağıtma.

Gerekenler

• Android Studio'nun en yeni sürümü (v4.2+)
• Android Studio Emulator veya fiziksel bir Android cihaz
• Örnek kod
• Kotlin'de Android geliştirmeyle ilgili temel bilgiler

2. Nesne Algılama

Nesne algılama, dijital görüntüdeki nesneleri algılayıp bulabilen bir bilgisayar görüşü görevleri grubudur. Bir görüntü veya video akışı göz önüne alındığında, bir nesne algılama modeli, bilinen bir nesne grubundan hangilerinin mevcut olduğunu belirleyebilir ve resim içindeki konumları hakkında bilgi sağlayabilir.

TensorFlow, araba, turuncu gibi yaygın nesneleri algılayabilen önceden eğitilmiş, mobil cihazlar için optimize edilmiş modeller sağlar. Önceden eğitilmiş bu modelleri mobil uygulamanıza sadece birkaç kod koduyla entegre edebilirsiniz. Ancak daha ayrıntılı veya sıra dışı kategorilerdeki nesneleri tespit etmek isteyebilir veya isteyebilirsiniz. Bunun için kendi eğitim görüntülerinizi toplamanız ve ardından kendi nesne algılama modelinizi eğitip dağıtmanız gerekir.

Yalnızca kendi modelinizi eğitmeden genel nesne algılamak istiyorsanız yalnızca birkaç satır kod kullanarak bir nesne algılayıcı oluşturmak için ML Kit Nesne Algılama ve İzleme API'sini nasıl kullanacağınızı öğrenmek için bu codelab'e göz atın.

TensorFlow Lite

TensorFlow Lite, Android ve iOS mobil cihazlar dahil, uç cihazlarda makine öğrenimi modelleri çalıştırmak için optimize edilmiş, platformlar arası bir makine öğrenimi kitaplığıdır.

TensorFlow Lite, makine öğrenimi modellerini çalıştırmak için ML Kit'in içinde kullanılan temel motordur. TensorFlow Lite ekosisteminde, mobil cihazlarda makine öğrenimi modellerini eğitmeyi ve dağıtmayı kolaylaştıran iki bileşen bulunur:

• Model Oluşturucu, makine öğrenimi uzmanlığına gerek olmadan yalnızca birkaç satır kodla TensorFlow Lite modellerini kendi verileriniz ile eğitmeyi kolaylaştıran bir Python kitaplığıdır.
• Görev Kitaplığı, mobil uygulamalarınızda yalnızca birkaç satır kodla TensorFlow Lite modellerini dağıtmayı kolaylaştıran bir platformlar arası kitaplıktır.

Bu codelab'de TFLite ele alınmıştır. TFLite ve nesne algılamayla ilgili olmayan kavramlar ve kod blokları açıklanmaz ve bunlar yalnızca kopyalayıp yapıştırmanız için sunulur.

3. Hazırlanın

Kodu İndirme

Bu codelab'in tüm kodunu indirmek için aşağıdaki bağlantıyı tıklayın:

Kaynak kodu indir

İndirilen ZIP dosyasını paketten çıkarın. Bu, ihtiyaç duyacağınız tüm kaynaklarla bir kök klasörün (odml-pathways-main) paketini açar. Bu codelab için yalnızca object-detection/codelab2/android alt dizinindeki kaynaklara ihtiyacınız olacaktır.

object-detection/codelab2/android deposundaki android alt dizini iki dizin içerir:

• starter - Bu codelab için geliştirdiğiniz başlangıç kodu.
• Son: Tamamlanmış örnek uygulama için kod tamamlandı.

Başlangıç uygulamasını içe aktarın

Başlangıç uygulamasını Android Studio'ya aktararak başlayalım.

1. Android Studio'yu açın ve Projeyi İçe Aktar (Gradle, Eclipse ADT vb.) seçeneğini belirleyin.
2. Daha önce indirdiğiniz kaynak koddan starter klasörünü açın.

Uygulamanızın tüm bağımlılıkları tarafından kullanılabileceğinden emin olmak için içe aktarma işlemi tamamlandığında projenizi gradle dosyalarıyla senkronize etmeniz gerekir.

3. Android Studio araç çubuğundan Projeyi Gradle Dosyalarıyla Senkronize Et'i () seçin. starter/app/build.gradle öğesini içe aktarın

Bu düğme devre dışı bırakılırsa kod deposunun tamamını değil, yalnızca starter/app/build.gradle dosyasını içe aktardığınızdan emin olun.

Starter uygulamasını çalıştırma

Projeyi Android Studio'ya aktardığınıza göre, uygulamayı ilk kez çalıştırmaya hazırsınız.

Android cihazınızı bilgisayarınıza USB üzerinden bağlayın veya Android Studio emülatörünü başlatın, ardından Android Studio araç çubuğundan Çalıştır'ı () tıklayın.

4. Başlangıç uygulamasını anlama

Bu codelab'i basit tutmak ve makine öğrenimi bitlerine odaklanmak için başlangıç uygulaması, sizin için birkaç şey yapan bazı ortak kodlar içerir:

• Cihazın kamerasını kullanarak fotoğraf çekebilir.
• Android emülatöründe nesne algılama özelliğini denemeniz için bazı stok resimler içerir.
• Girdi haritasında nesne algılama sonucunu çizmek için kullanışlı bir yöntem vardır.

Uygulama iskeletinde çoğunlukla şu yöntemlerle etkileşimde bulunursunuz:

• fun runObjectDetection(bitmap: Bitmap) Bu yöntem, hazır ayar bir resim seçtiğinizde veya fotoğraf çektiğinizde çağrılır. bitmap, nesne algılama için giriş resmidir. Daha sonra bu codelab'de bu yönteme nesne algılama kodu eklersiniz.
• data class DetectionResult(val boundingBoxes: Rect, val text: String) Bu, görselleştirme için bir nesne algılama sonucunu temsil eden bir veri sınıfıdır. boundingBoxes, nesnenin bulunduğu dikdörtgendir. text ise nesnenin sınırlayıcı kutusuyla birlikte gösterilecek algılama sonuç dizesidir.
• fun drawDetectionResult(bitmap: Bitmap, detectionResults: List<DetectionResult>): Bitmap Bu yöntem, bitmap girişteki nesne algılama işleminin sonucu detectionResults olan sonucu çizer ve bunun değiştirilmiş kopyasını döndürür.

drawDetectionResult yardımcı yöntemi yönteminin çıktısına ilişkin bir örneği burada bulabilirsiniz.

5. Cihaz üzerinde nesne algılama ekleme

Artık başlangıç uygulamasına, ortak nesneleri algılayabilen önceden eğitilmiş bir TFLite modelini entegre ederek bir prototip oluşturabilirsiniz.

Önceden eğitilmiş TFLite nesne algılama modeli indirme

TensorFlow Hub'da kullanabileceğiniz birkaç nesne algılayıcı modeli bulunur. Bu codelab'de, COCO 2017 veri kümesi üzerinde eğitilmiş, TFLite için optimize edilmiş ve mobil CPU, GPU ile EdgeTPU'da performansa yönelik tasarlanmış EfficientDet-Lite Nesne algılama modelini indirirsiniz.

Modeli indirin

Ardından, önceden eğitilmiş TFLite modelini başlangıç uygulamanıza entegre etmek için TFLite Görev Kitaplığı'nı kullanın. TFLite Görev Kitaplığı, mobil cihazlar için optimize edilmiş makine öğrenimi modellerini bir mobil uygulamaya entegre etmeyi kolaylaştırır. Nesne algılama, görüntü sınıflandırma ve metin sınıflandırma gibi birçok popüler makine öğrenimi kullanım alanını destekler. TFLite modelini yükleyip yalnızca birkaç satır kodla çalıştırabilirsiniz.

TFLite Görev Kitaplığı yalnızca geçerli meta veriler içeren TFLite modellerini destekler. Bu TensorFlow Hub koleksiyonundan daha fazla desteklenen nesne algılama modelleri bulabilirsiniz.

Modeli başlangıç uygulamasına ekleyin

1. Yeni indirdiğiniz modeli, başlangıç uygulamasının assets klasörüne kopyalayın. Klasörü Android Studio'daki Proje gezinme panelinde bulabilirsiniz.

2. Dosyaya model.tflite adını verin.

Gradle dosyası Görev Kitaplığı bağımlılıklarını güncelleme

app/build.gradle dosyasına gidin ve bu satırı dependencies yapılandırmasına ekleyin:

implementation 'org.tensorflow:tensorflow-lite-task-vision:0.3.1'

Projenizi Gradle dosyalarıyla senkronize etme

Bu adımda tüm bağımlıların kullanılabilir olduğundan emin olmak için projenizi, bu noktada gradle dosyalarıyla senkronize etmeniz gerekir. Android Studio araç çubuğundan Projeyi Gradle Dosyalarıyla Senkronize Et'i ( ) seçin.

(Bu düğme devre dışı bırakılırsa kod deposunun tamamını değil, yalnızca start/app/build.gradle dosyasını içe aktardığınızdan emin olun.)

Bir cihazda cihazda nesne algılamayı ayarlama ve çalıştırma

Bir nesne algılama modelini yüklemek ve çalıştırmak için 3 API içeren yalnızca 3 basit adım vardır:

• resim / akış hazırlayın: TensorImage
• bir algılayıcı nesnesi oluştur: ObjectDetector
• yukarıdaki 2 nesneyi bağlayın: detect(image)

Bunları runObjectDetection(bitmap: Bitmap)MainActivity.kt dosyasında fonksiyonun içinde bulursunuz.

/**
* TFLite Object Detection Function
*/
private fun runObjectDetection(bitmap: Bitmap) {
    //TODO: Add object detection code here
}

Şu anda işlev boş. TFLite nesne algılayıcısını uygulamak için aşağıdaki adımlara geçin. Bu süreçte Android Studio, gerekli içe aktarmaları eklemenizi isteyecektir:

• org.tensorflow.lite.support.image.TensorImage
• org.tensorflow.lite.task.vision.detector.ObjectDetector

Resim Nesnesi Oluşturma

Bu codelab için kullanacağınız resimler cihazdaki kameradan veya uygulamanın kullanıcı arayüzünde seçtiğiniz hazır resimlerden gelir. Giriş resminin kodu Bitmap biçiminde çözülür ve runObjectDetection yöntemine aktarılır.

TFLite, Bitmap üzerinden TensorImage oluşturmak için basit bir API sunar. Aşağıdaki kodu runObjectDetection(bitmap:Bitmap) kodunun en üstüne ekleyin:

// Step 1: create TFLite's TensorImage object
val image = TensorImage.fromBitmap(bitmap)

Algılayıcı örneği oluşturma

TFLite Görev Kitaplığı, Builder Design Kalıp'a uyar. Yapılandırmayı bir oluşturucuya iletir, ardından ondan bir algılayıcı alırsınız. Nesne algılayıcının hassasiyetini ayarlamak da dahil olmak üzere yapılandırmak için çeşitli seçenekler vardır:

• maks. sonuç (modelin algılaması gereken maksimum nesne sayısı)
• puan eşiği (algılanan bir nesneyi döndürmek için nesne algılayıcısının ne kadar olması gerektiği)
• etiket izin verilenler listesi/reddedilenler (önceden tanımlanmış bir listedeki nesnelere izin verir/reddeder)

TFLite modelinin dosya adını ve yapılandırma seçeneklerini belirterek nesne algılayıcı örneğini başlatın:

// Step 2: Initialize the detector object
val options = ObjectDetector.ObjectDetectorOptions.builder()
    .setMaxResults(5)
    .setScoreThreshold(0.5f)
    .build()
val detector = ObjectDetector.createFromFileAndOptions(
    this, // the application context
    "model.tflite", // must be same as the filename in assets folder
    options
)

Algılayıcıya Feed Resimleri

fun runObjectDetection(bitmap:Bitmap) koduna aşağıdaki kodu ekleyin. Bu işlem, resimlerinizi algılayıcıya besler.

// Step 3: feed given image to the model and print the detection result
val results = detector.detect(image)

İşlem tamamlandığında algılayıcı, her birinin modelin resimde bulduğu bir nesneyle ilgili bilgileri içeren bir Detection listesi döndürür. Her nesne şunlarla tanımlanır:

• boundingBox: Bir nesnenin varlığını ve resim içindeki konumunu belirten dikdörtgen
• categories: Ne tür bir nesne olduğunu ve modelin, tespit sonucunda ne kadar emin olduğunu gösterir. Model birden fazla kategori döndürür. Bunlardan en önemlisi önce gelir.
• label: Nesne kategorisinin adı.
• classificationConfidence:1,0 ile 1,0 arasında %0,0 ile 0,0 arasında bir hareketli değer

Algılama sonuçlarını yazdırma

fun runObjectDetection(bitmap:Bitmap) koduna aşağıdaki kodu ekleyin. Bu işlem, nesne algılama sonuçlarının Logcat'e yazdırılması için bir yöntem çağırır.

// Step 4: Parse the detection result and show it
debugPrint(results)

Ardından, bu debugPrint() yöntemini MainActivity sınıfına ekleyin:

private fun debugPrint(results : List<Detection>) {
    for ((i, obj) in results.withIndex()) {
        val box = obj.boundingBox

        Log.d(TAG, "Detected object: ${i} ")
        Log.d(TAG, "  boundingBox: (${box.left}, ${box.top}) - (${box.right},${box.bottom})")

        for ((j, category) in obj.categories.withIndex()) {
            Log.d(TAG, "    Label $j: ${category.label}")
            val confidence: Int = category.score.times(100).toInt()
            Log.d(TAG, "    Confidence: ${confidence}%")
        }
    }
} 

Artık nesne algılayıcınız hazır. Android Studio araç çubuğunda Çalıştır'ı () tıklayarak uygulamayı derleyin ve çalıştırın. Uygulama cihazda göründükten sonra, nesne algılayıcıyı başlatmak için hazır resimlerden birine dokunun. Ardından, IDE'nizin içindeki Logcat penceresine*(* *)* baktığınızda, aşağıdakine benzer bir durum görürsünüz:

D/TFLite-ODT: Detected object: 0 
D/TFLite-ODT:   boundingBox: (0.0, 15.0) - (2223.0,1645.0)
D/TFLite-ODT:     Label 0: dining table
D/TFLite-ODT:     Confidence: 77%
D/TFLite-ODT: Detected object: 1 
D/TFLite-ODT:   boundingBox: (702.0, 3.0) - (1234.0,797.0)
D/TFLite-ODT:     Label 0: cup
D/TFLite-ODT:     Confidence: 69%

Bu, algılayıcının 2 nesne gördüğünü bildirir. Bunların ilki:

• Bir nesne (0, 15) - (2223, 1645) dikdörtgeninin içindedir
• Etiket yemek masası
• Model, birincisinin yemek masası olduğundan (%77) emin

Teknik olarak TFLite Görev Kitaplığı'nın çalışması için ihtiyacınız olan tek şey bu kadar. Hepsi bu kadar. Tebrikler.

Ancak kullanıcı arayüzü tarafında hâlâ başlangıç noktasındasınız. Şimdi, algılanan sonuçların işlendikten sonra, kullanıcı arayüzünde tespit edilen sonuçlardan yararlanmanız gerekir.

6. Algılama sonucunu giriş resmine çiz

Önceki adımlarda, algılama sonucunu logcat cihazına yazdırdınız: Basit ve hızlı. Bu adımda:

• bir görsele sınırlayıcı kutu çiz
• Sınırlayıcı kutunun içinde bir kategori adı ve güven yüzdesi çizin

1. debugPrint(results) çağrısını aşağıdaki kod snippet'iyle değiştirin:

val resultToDisplay = results.map {
    // Get the top-1 category and craft the display text
    val category = it.categories.first()
    val text = "${category.label}, ${category.score.times(100).toInt()}%"

    // Create a data object to display the detection result
    DetectionResult(it.boundingBox, text)
}
// Draw the detection result on the bitmap and show it.
val imgWithResult = drawDetectionResult(bitmap, resultToDisplay)
runOnUiThread {
    inputImageView.setImageBitmap(imgWithResult)
}

Not: Nesne algılama, bilgi işlem açısından yoğun bir işlem olduğundan ve TFLite Görev Kitaplığı, çağrıldığı aynı ileti dizisinde çalıştığı için uygulama kullanıcı arayüzünü engellememek için bunu bir arka plan ileti dizisinde çalıştırmanız önemlidir. Gördüğünüz gibi runObjectDetection yöntemini çağırmak için Kotlin eş yordamı kullanılmış

lifecycleScope.launch(Dispatchers.Default) { runObjectDetection(bitmap) }

2. Şimdi Android Studio araç çubuğunda Çalıştır'ı () tıklayın.
3. Uygulama yüklendikten sonra, algılama sonucunu görmek için hazır resimlerden birine dokunun.

Kendi fotoğrafınızla denemek ister misiniz? Fotoğraf çek düğmesine dokunun ve çevrenizdeki nesnelerin resimlerini çekin.

7. Özel nesne algılama modeli eğitme

Önceki adımda Android uygulamasına önceden eğitilmiş bir TFLite nesne algılama modeli entegre ederek örnek resimlerde kase veya yemek masası gibi yaygın nesneleri algılayabildiğini gördünüz. Ancak hedefiniz, resimdeki yemeklerin bileşenlerini algılamaktır, dolayısıyla genel nesne algılama işlevi kullanım alanınıza uygun değildir. Algılamak istediğiniz malzemelerle bir eğitim veri kümesi kullanarak özel bir nesne algılama modeli eğitmek istiyorsunuz.

Kendi özel modelinizi eğitmek için kullanabileceğiniz resimleri ve etiketleri içeren bir veri kümesi burada verilmiştir. Open Images Dataset V4'teki resimler kullanılarak oluşturulmuştur.

Colaboratory

Şimdi özel modeli eğitmek için Google Colab'a gidelim.

Google Colab'a gidin

Tanımadığınız Google Colaboratory veya kısa bir süre içinde Colab, kod yazmanıza ve yürütmenize olanak tanıyan etkileşimli bir ortamdır. Colab, makine öğrenimi topluluğunda yaygın olarak kullanılmaktadır. Colab ile bir resim veri kümesini içe aktarabilir, bu veri kümesinde resim sınıflandırıcıyı eğitebilir ve modeli değerlendirebilirsiniz.

Colab not defterleri Google'ın bulut sunucularında kod yürütür. Yani makinenizin gücünden bağımsız olarak, GPU'lar ve TPU'lar dahil Google donanımının gücünden yararlanabilirsiniz. Tek ihtiyacınız bir tarayıcıdır.

Colab'a erişemiyorsanız başka bir ortam kullanabilir ve bu GitHub bağlantısı üzerinden koda erişebilirsiniz.

Özel modeli eğitmek yaklaşık 30 dakika sürer.

Aceleniz varsa sağlanan veri kümesinde sizin için önceden eğitilmiş olduğumuz bir modeli indirip bir sonraki adıma geçebilirsiniz.

Salı algılama modelini indirin

8. Özel TFLite modelini Android uygulamasına entegre edin

Bir salata algılama modelini eğittiğinize, bir salata dedektörünü entegre ettiğinize ve uygulamanızı yaygın olarak kullanılan bir salgın algılayıcısına dönüştürdüğünüze göre.

1. Salata TFLite modelini assets klasörüne kopyalayın. Yeni modeli salad.tflite olarak adlandırın.

2. MainActivity.kt dosyasını açın ve ObjectDetector başlatma kodunu bulun.
3. EfficientDet-Lite modelini (model.tflite) salata modeliyle (salad.tflite) değiştirin

val detector = ObjectDetector.createFromFileAndOptions(
    this, // the application context
    "salad.tflite", // must be same as the filename in assets folder
    options
)

4. Uygulamayı yeni modelle tekrar çalıştırmak için Android Studio araç çubuğunda Çalıştır'ı () tıklayın. Ve işte! Uygulama artık peynir, salata, unlu mamulları tanıyabilir.

Uygulamayı bir Android emülatöründe çalıştırırsanız nesne algılama modelinin sonucunu döndürmesinin birkaç saniye sürebileceğini görebilirsiniz. Bunun nedeni, TFLite niceliksel modellerin bir emülatörde çalışacak şekilde optimize edilmemiş olmasıdır. Fiziksel bir Android cihazda çok daha hızlı çalışır.

9. Tebrikler!

Özel bir model eğitmek ve uygulamanıza Nesne Algılama özelliklerini eklemek için TFLite uygulamasını kullandınız. Bu özelliği çalıştırmak için ihtiyacınız olan tek şey bu!

Değindiğimiz konular

• TensorFlow Hub'da önceden eğitilmiş TFLite nesne algılama modelleri bulma
• TFLite Görev Kitaplığı'nı kullanarak itiraz algılama modellerini Android uygulamanıza entegre etme
• TFLite Model Maker ile özel nesne algılama modeli eğitme

Sonraki Adımlar

• TFLite modelinizin dağıtımını geliştirmek için Firebase'i kullanın
• Kendi modelinizi eğitmek için eğitim verileri toplayın
• Kendi Android uygulamanızda nesne algılamayı uygulama

Daha Fazla Bilgi

• Google teknolojileriyle cihaz üzerinde makine öğrenimi