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

Bu sayfada, canlı kamera akışını analiz etmek ve nesneleri tanımlamak için TensorFlow Lite ile nasıl bir Android uygulaması oluşturulacağı gösterilmektedir. Bu makine öğrenimi kullanım durumuna nesne algılama adı verilir. Örnek uygulama, TensorFlow Lite ile bir makine öğrenimi uygulaması oluşturmak için önerilen yaklaşım olan nesne algılama makine öğrenimi modelinin yürütülmesini sağlamak üzere Google Play hizmetleri aracılığıyla görüş için TensorFlow Lite Görev kitaplığını kullanır.

Nesne algılama animasyonlu demosu

Örneği kurun ve çalıştırın

Bu alıştırmanın ilk kısmı için örnek kodu GitHub'dan indirin ve Android Studio'yu kullanarak çalıştırın. Bu belgenin aşağıdaki bölümleri kod örneğinin ilgili bölümlerini inceliyor; 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 veya üzeri
  • Android SDK sürüm 21 veya üzeri

Örnek kodu alın

Örnek kodun yerel bir kopyasını oluşturun, böylece onu oluşturup çalıştırabilirsiniz.

Örnek kodu klonlamak ve ayarlamak için:

  1. Git deposu
    git clone https://github.com/tensorflow/examples.git
    
    klonlayın
  2. Git örneğinizi seyrek ödemeyi 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_play_services
    

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

İndirilen örnek koddan bir proje oluşturmak, projeyi oluşturmak ve çalıştırmak için Android Studio'yu kullanı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ında Projeyi İçe Aktar'ı veya Dosya > Yeni > Projeyi İçe Aktar'ı seçin.
  3. build.gradle dosyasını içeren örnek kod dizinine gidin ( ...examples/lite/examples/object_detection/android_play_services/build.gradle ) ve bu dizini seçin.

Bu dizini seçtikten sonra Android Studio yeni bir proje oluşturur ve onu derler. Derleme tamamlandığında Android Studio, Derleme Çıktısı durum panelinde OLUŞTURMA BUILD SUCCESSFUL mesajını görüntüler.

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

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

Örnek uygulama nasıl çalışır?

Örnek uygulama, TensorFlow Lite formatında mobilenetv1.tflite gibi önceden eğitilmiş nesne algılama modelini kullanır ve bir Android cihazının kamerasından canlı video akışındaki nesneleri arar. Bu özelliğin kodu öncelikle şu dosyalarda bulunur:

  • ObjectDetectorHelper.kt - Çalışma zamanı ortamını başlatır, donanım hızlandırmayı etkinleştirir ve nesne algılama ML modelini çalıştırır.
  • CameraFragment.kt - Kamera görüntü veri akışını oluşturur, verileri model için hazırlar ve nesne algılama sonuçlarını görüntüler.

Sonraki bölümler size bu kod dosyalarının temel bileşenlerini gösterir; böylece bu işlevi eklemek için bir Android uygulamasını değiştirebilirsiniz.

Uygulamayı oluşturun

Aşağıdaki bölümlerde kendi Android uygulamanızı oluşturmaya ve örnek uygulamada gösterilen modeli çalıştırmaya yönelik temel adımlar açıklanmaktadır. Bu talimatlarda daha önce gösterilen örnek uygulama referans noktası olarak kullanılmıştır.

Proje bağımlılıkları ekleyin

Temel Android uygulamanıza, TensorFlow Lite makine öğrenimi modellerini çalıştırmak ve ML veri yardımcı programı işlevlerine erişmek için proje bağımlılıklarını ekleyin. Bu yardımcı işlevler, görüntüler gibi verileri bir model tarafından işlenebilecek tensör veri formatına dönüştürür.

Örnek uygulama, nesne algılama makine öğrenimi modelinin yürütülmesini sağlamak amacıyla Google Play hizmetlerinden görüntü almak 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.

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

  1. TensorFlow Lite kullanan Android uygulama modülünde, 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_play_services/app/build.gradle

    ...
    dependencies {
    ...
        // Tensorflow Lite dependencies
        implementation 'org.tensorflow:tensorflow-lite-task-vision-play-services:0.4.2'
        implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
    ...
    }
    
  2. Android Studio'da, şunu seçerek proje bağımlılıklarını senkronize edin: File > Sync Project with Gradle Files .

Google Play hizmetlerini başlatın

TensorFlow Lite modellerini çalıştırmak için Google Play hizmetlerini kullandığınızda, hizmeti kullanmadan önce başlatmanız gerekir. Hizmetle birlikte GPU hızlandırma gibi donanım hızlandırma desteğini kullanmak istiyorsanız bu başlatma işleminin bir parçası olarak bu desteği de etkinleştirirsiniz.

TensorFlow Lite'ı Google Play hizmetleriyle başlatmak için:

  1. Bir TfLiteInitializationOptions nesnesi oluşturun ve GPU desteğini etkinleştirmek için onu değiştirin:

    val options = TfLiteInitializationOptions.builder()
        .setEnableGpuDelegateSupport(true)
        .build()
    
  2. Play hizmetleri çalışma zamanının kullanımını etkinleştirmek için TfLiteVision.initialize() yöntemini kullanın ve başarıyla yüklendiğini doğrulamak için bir dinleyici ayarlayın:

    TfLiteVision.initialize(context, options).addOnSuccessListener {
        objectDetectorListener.onInitialized()
    }.addOnFailureListener {
        // Called if the GPU Delegate is not supported on the device
        TfLiteVision.initialize(context).addOnSuccessListener {
            objectDetectorListener.onInitialized()
        }.addOnFailureListener{
            objectDetectorListener.onError("TfLiteVision failed to initialize: "
                    + it.message)
        }
    }
    

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

Model dosyasını yükleyerek ve model parametrelerini ayarlayarak TensorFlow Lite makine öğrenimi modeli yorumlayıcısını başlatın. TensorFlow Lite modeli, model kodunu içeren bir .tflite dosyası içerir. Modellerinizi geliştirme projenizin src/main/assets dizininde saklamalısınız, örneğin:

.../src/main/assets/mobilenetv1.tflite`

Modeli başlatmak için:

  1. Geliştirme projenizin src/main/assets dizinine ssd_mobilenet_v1 gibi bir .tflite model dosyası ekleyin.
  2. ML modelinizin dosya adını belirtmek için modelName değişkenini ayarlayın:

    val modelName = "mobilenetv1.tflite"
    
  3. Tahmin eşiği ve sonuç kümesi boyutu gibi model seçeneklerini ayarlayın:

    val optionsBuilder =
        ObjectDetector.ObjectDetectorOptions.builder()
            .setScoreThreshold(threshold)
            .setMaxResults(maxResults)
    
  4. Seçeneklerle GPU hızlandırmayı etkinleştirin ve cihazda hızlandırma desteklenmiyorsa kodun düzgün bir şekilde başarısız olmasına izin verin:

    try {
        optionsBuilder.useGpu()
    } catch(e: Exception) {
        objectDetectorListener.onError("GPU is not supported on this device")
    }
    
    
  5. Modeli içeren bir TensorFlow Lite ObjectDetector nesnesi oluşturmak için bu nesnedeki ayarları kullanın:

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

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

Görüntü gibi mevcut verileri Tensor veri formatına dönüştürerek, modeliniz tarafından işlenebilmesi için verileri model tarafından yorumlanmaya hazırlarsınız. Tensördeki verilerin, modeli eğitmek için kullanılan veri formatıyla eşleşen belirli boyutlara veya şekle sahip olması gerekir. Kullandığınız modele bağlı olarak verileri modelin beklentilerine uyacak şekilde dönüştürmeniz gerekebilir. Örnek uygulama, kamera alt sisteminden görüntü karelerini çıkarmak için bir ImageAnalysis nesnesi kullanır.

Verileri modele göre işlenmek üzere hazırlamak için:

  1. 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()
            ...
    
  2. 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)
            }
        }
    
  3. 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)
    }    
    
  4. Ö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

Doğru formatta görüntü verisine sahip bir TensorImage nesnesi oluşturduğunuzda, bir tahmin veya çıkarım oluşturmak için modeli bu verilerle çalıştırabilirsiniz. Örnek uygulamada bu kod ObjectDetectorHelper.detect() yönteminde bulunur.

Bir 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)
    

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

Görüntü verilerini nesne algılama modeline göre ç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 tahmin sonuçlarının bir listesini oluşturur. Örnek uygulamadaki nesne algılama modeli, algılanan nesneler için tahminlerin ve sınırlayıcı kutuların bir listesini oluşturur. Örnek uygulamada, tahmin sonuçları daha fazla işlenmek ve kullanıcıya gösterilmek üzere bir dinleyici nesnesine iletilir.

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

  1. 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)
    
  2. Tahmini kullanıcıya görüntülemek gibi sonuçlara göre hareket edin. Örnek uygulama, sonucu göstermek için CameraPreview nesnesinin üzerine bir katman ç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()
        }
    }
    

Sonraki adımlar