Android için hızlı başlangıç

Bu eğitici, canlı bir kamera akışını analiz etmek ve minimum miktarda kod kullanarak bir makine öğrenimi modeli kullanarak nesneleri tanımlamak için TensorFlow Lite kullanarak bir Android uygulamasını nasıl oluşturacağınızı gösterir. Mevcut bir projeyi güncelliyorsanız, kod örneğini referans olarak kullanabilir ve projenizi değiştirme talimatlarına geçebilirsiniz.

Makine öğrenimi ile nesne algılama

Nesne algılama animasyonlu demosu Bu öğreticideki makine öğrenimi modeli, nesne algılamayı gerçekleştirir. Bir nesne algılama modeli, görüntü verilerini belirli bir biçimde alır, analiz eder ve görüntüdeki öğeleri, tanımak üzere eğitildiği bir dizi bilinen sınıftan biri olarak sınıflandırmaya çalışır. Bir modelin bilinen bir nesneyi tanımlama hızı (nesne tahmini veya çıkarımı olarak adlandırılır) genellikle milisaniye cinsinden ölçülür. Pratikte çıkarım hızı, modeli barındıran donanıma, işlenen verinin boyutuna ve makine öğrenimi modelinin boyutuna göre değişir.

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

Bu öğreticinin ilk kısmı için GitHub'dan örneği indirin ve Android Studio 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. Bu araçların aşağıdaki sürümlerinin kurulu olması gerekir:

  • Android Studio 4.2.2 veya üstü
  • Android SDK sürüm 31 veya üzeri

Örnek kodu alın

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

Örnek kodu klonlamak ve kurmak için:

  1. git deposunu klonlayın
    git clone https://github.com/android/camera-samples.git
    
  2. Git örneğinizi seyrek ödemeyi kullanacak şekilde yapılandırın, böylece yalnızca nesne algılama örnek uygulaması için dosyalara sahip olursunuz:

    cd camera-samples
    git sparse-checkout init --cone
    git sparse-checkout set CameraXAdvanced
    

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

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

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

  1. Android Studio'yu başlatın .
  2. Android Studio Hoş Geldiniz sayfasından Projeyi İçe Aktar öğesini veya Dosya > Yeni > Projeyi İçe Aktar öğesini seçin.
  3. build.gradle dosyasını ( .../android/camera-samples/CameraXAdvanced/build.gradle ) içeren örnek kod dizinine gidin ve o dizini seçin.

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, Yapı Çıktısı durum panelinde bir BUILD SUCCESSFUL mesajı görüntüler.

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

  1. Proje dizinindeki build.gradle dosyasını açın.
  2. 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'
    
  3. Aşağıdakileri seçerek projeyi senkronize edin: File > Sync Project with Gradle Files .

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

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

Sonraki bölümler, bu örnek uygulamayı bir 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ı ekle

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 biçimine 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 için birkaç TensorFlow Lite kitaplığı kullanır:

  • TensorFlow Lite ana kitaplığı - Gerekli veri giriş sınıflarını, makine öğrenimi modelinin yürütülmesini ve model işlemeden çıktı sonuçlarını sağlar.
  • TensorFlow Lite Destek kitaplığı - Bu kitaplık, kameradaki görüntüleri makine öğrenimi modeli tarafından işlenebilen bir TensorImage veri nesnesine çevirmek için yardımcı bir sınıf sağlar.
  • TensorFlow Lite GPU kitaplığı - Bu kitaplık, varsa aygıtta GPU işlemcileri kullanarak model yürütmeyi hızlandırmak için destek sağlar.

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

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

  1. 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: .../android/camera-samples/CameraXAdvanced/tflite/build.gradle ( kod referansı )

    ...
    dependencies {
    ...
        // Tensorflow lite dependencies
        implementation 'org.tensorflow:tensorflow-lite:2.8.0'
        implementation 'org.tensorflow:tensorflow-lite-gpu:2.8.0'
        implementation 'org.tensorflow:tensorflow-lite-support:2.8.0'
    ...
    }
    
  2. Android Studio'da, aşağıdakileri seçerek proje bağımlılıklarını senkronize edin: File > Sync Project with Gradle Files .

ML model yorumlayıcısını başlat

Android uygulamanızda, modelle tahmin çalıştırmadan önce TensorFlow Lite makine öğrenimi modeli yorumlayıcısını parametrelerle başlatmanız gerekir. Bu başlatma parametreleri, kullandığınız modele bağlıdır ve tahminler için minimum doğruluk eşikleri ve tanımlanan nesne sınıfları için etiketler gibi ayarları içerebilir.

Bir 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 algılama durumunda sınıflar, kişi, köpek, kedi veya araba gibi nesnelerdir. Modeller genellikle kod örneğinde olduğu gibi birincil modülün src/main/assets dizininde saklanır:

  • CameraXAdvanced/tflite/src/main/assets/coco_ssd_mobilenet_v1_1.0_quant.tflite
  • CameraXAdvanced/tflite/src/main/assets/coco_ssd_mobilenet_v1_1.0_labels.txt

Kolaylık ve kod okunabilirliği için örnek, modelin ayarlarını tanımlayan bir eşlik eden nesne bildirir.

Modeli uygulamanızda başlatmak için:

  1. Modelin ayarlarını tanımlamak için bir tamamlayıcı nesne oluşturun: ( kod referansı )

    companion object {
       private val TAG = CameraActivity::class.java.simpleName
    
       private const val ACCURACY_THRESHOLD = 0.5f
       private const val MODEL_PATH = "coco_ssd_mobilenet_v1_1.0_quant.tflite"
       private const val LABELS_PATH = "coco_ssd_mobilenet_v1_1.0_labels.txt"
    }
    
  2. Modeli içeren bir TensorFlow Lite Yorumlayıcı nesnesi oluşturmak için bu nesnedeki ayarları kullanın: ( kod referansı )

    private val tflite by lazy {
       Interpreter(
           FileUtil.loadMappedFile(this, MODEL_PATH),
           Interpreter.Options().addDelegate(nnApiDelegate))
    }
    

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

Uygulamanızda bir TensorFlow Lite modeli başlatırken, modelin tahmin hesaplamalarını hızlandırmak için donanım hızlandırma özelliklerini kullanabilirsiniz. Yukarıdaki kod örneği, model yürütmesinin donanım hızlandırmasını işlemek için NNAPI Temsilcisini kullanır:

Interpreter.Options().addDelegate(nnApiDelegate)

TensorFlow Lite temsilcileri , GPU'lar, TPU'lar veya 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 gerekli değildir.

Temsilcileri TensorFlow Lite ile kullanma hakkında daha fazla bilgi için bkz. TensorFlow Lite Delegeleri .

Modele veri sağlayın

Android uygulamanızda kodunuz, görüntüler gibi mevcut verileri modeliniz tarafından işlenebilecek bir Tensör veri biçimine dönüştürerek modele yorumlanması için veri sağlar. Tensördeki veriler, modeli eğitmek için kullanılan veri biçimiyle eşleşen belirli boyutlara veya şekle sahip olmalıdır.

Bir model için gerekli tensör şeklini belirlemek için:

  • Aşağıdaki kod parçacığında gösterildiği gibi, modeliniz tarafından kullanılan tensörün şeklini belirlemek için başlatılmış Yorumlayıcı nesnesini kullanın: ( kod referansı )

    private val tfInputSize by lazy {
       val inputIndex = 0
       val inputShape = tflite.getInputTensor(inputIndex).shape()
       Size(inputShape[2], inputShape[1]) // Order of axis is: {1, height, width, 3}
    }
    

Örnek kodda kullanılan nesne algılama modeli, 300 x 300 piksel boyutunda kare görüntüler beklemektedir.

Kameradan görüntü sağlamadan önce uygulamanızın görüntüyü alması, beklenen boyuta uygun hale getirmesi, dönüşünü ayarlaması ve görüntü verilerini normalleştirmesi gerekir. Bir TensorFlow Lite modeliyle görüntüleri işlerken, aşağıda gösterildiği gibi bu veri ön işlemeyi işlemek için TensorFlow Lite Destek Kitaplığı ImageProcessor sınıfını kullanabilirsiniz.

Bir model için görüntü verilerini dönüştürmek için:

  1. Görüntü verilerini modelinizin tahminleri çalıştırmak için kullanabileceği bir biçime dönüştürmek için bir nesne oluşturmak üzere Destek Kitaplığı ImageProcessor'ı kullanın: ( kod referansı )

    private val tfImageProcessor by lazy {
       val cropSize = minOf(bitmapBuffer.width, bitmapBuffer.height)
       ImageProcessor.Builder()
           .add(ResizeWithCropOrPadOp(cropSize, cropSize))
           .add(ResizeOp(
               tfInputSize.height, tfInputSize.width, ResizeOp.ResizeMethod.NEAREST_NEIGHBOR))
           .add(Rot90Op(-imageRotationDegrees / 90))
           .add(NormalizeOp(0f, 1f))
           .build()
    }
    
  2. Android kamera sisteminden görüntü verilerini kopyalayın ve ImageProcessor nesnenizle analiz için hazırlayın: ( kod referansı )

    // Copy out RGB bits to the shared buffer
    image.use { bitmapBuffer.copyPixelsFromBuffer(image.planes[0].buffer)  }
    
    // Process the image in Tensorflow
    val tfImage =  tfImageProcessor.process(tfImageBuffer.apply { load(bitmapBuffer) })
    

Tahminleri çalıştır

Android uygulamanızda, doğru biçimde görüntü verileriyle bir TensorImage nesnesi oluşturduğunuzda, bir tahmin veya çıkarım üretmek için modeli bu verilere karşı çalıştırabilirsiniz. Bu öğretici için örnek kod, bu kodu bir predict() yönteminde kapsülleyen bir ObjectDetectionHelper sınıfını kullanır.

Bir dizi görüntü verisi üzerinde bir tahmin yürütmek için:

  1. Görüntü verilerini tahmin işlevinize ileterek tahmini çalıştırın: ( kod referansı )

    // Perform the object detection for the current frame
    val predictions = detector.predict(tfImage)
    
  2. Tahminler oluşturmak için tflite nesne örneğinizdeki run yöntemini görüntü verileriyle çağırın: ( kod referansı )

    fun predict(image: TensorImage): List<ObjectPrediction> {
       tflite.runForMultipleInputsOutputs(arrayOf(image.buffer), outputBuffer)
       return predictions
    }
    

TensorFlow Lite Yorumlayıcı nesnesi bu verileri alır, modele karşı çalıştırır ve bir tahmin listesi üretir. Model tarafından verilerin sürekli olarak işlenmesi için, yorumlayıcı nesnelerinin oluşturulmaması ve ardından her tahmin çalıştırması için sistem tarafından kaldırılmaması için runForMultipleInputsOutputs() yöntemini kullanın.

Kol modeli çıktısı

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

Herhangi bir TensorFlow Lite modelinin çıktısı, ürettiği tahminlerin sayısı (bir veya daha fazla) ve her bir tahmin için açıklayıcı bilgiler açısından farklılık gösterir. Bir nesne algılama modeli durumunda, tahminler tipik olarak, bir nesnenin görüntüde nerede algılandığını gösteren bir sınırlayıcı kutu için verileri içerir. Örnek kodda, döndürülen veriler aşağıda gösterildiği gibi ObjectPrediction nesnelerinin bir listesi olarak biçimlendirilir: ( kod referansı )

val predictions get() = (0 until OBJECT_COUNT).map {
   ObjectPrediction(

       // The locations are an array of [0, 1] floats for [top, left, bottom, right]
       location = locations[0][it].let {
           RectF(it[1], it[0], it[3], it[2])
       },

       // SSD Mobilenet V1 Model assumes class 0 is background class
       // in label file and class labels start from 1 to number_of_classes + 1,
       // while outputClasses correspond to class index from 0 to number_of_classes
       label = labels[1 + labelIndices[0][it].toInt()],

       // Score is a single value of [0, 1]
       score = scores[0][it]
   )
}

Nesne algılama ekran görüntüsü 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 1 en yüksek güven derecesi olmak üzere, tahminin güvenini temsil eden bir Kayan Nokta olarak 0 ile 1 arasında bir tahmin puanı içerir. . Genel olarak, %50'nin (0.5) altında bir puana sahip 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 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 kod durumunda, uygulama tanımlanan nesnenin etrafına bir sınırlayıcı kutu çizer ve sınıf adını ekranda görüntüler. Ayrıntılar için örnek koddaki CameraActivity.reportPrediction() işlevini inceleyin.

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'nda mobil uygulamanızda makine öğrenimini uygulama hakkında daha fazla bilgi edinin.