7 Aralık'ta düzenlenecek Makine Öğreniminde Kadın Sempozyumu'na katılın Şimdi kaydolun

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

Koleksiyonlar ile düzeninizi koruyun İçeriği tercihlerinize göre kaydedin ve kategorilere ayırın.

Bu sayfa, canlı bir kamera akışını analiz etmek ve nesneleri tanımlamak için TensorFlow Lite ile nasıl bir Android uygulaması oluşturacağınızı gösterir. Bu makine öğrenimi kullanım örneğine nesne algılama adı verilir. Örnek uygulama, TensorFlow Lite ile bir ML 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 vizyon 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 GitHub'dan örnek kodu indirin ve Android Studio kullanarak çalıştırın. Bu belgenin 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 veya üzeri
  • Android SDK sürüm 21 veya üzeri

Örnek kodu alın

Oluşturup çalıştırabilmeniz için örnek kodun yerel bir kopyasını oluşturun.

Örnek kodu klonlamak ve kurmak için:

  1. git deposunu klonlayın
    git clone https://github.com/tensorflow/examples.git
    
  2. Git örneğinizi seyrek ödeme kullanacak şekilde yapılandırın, böylece yalnızca nesne algılama örneği uygulaması için 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 için Android Studio'yu kullanın, projeyi oluşturun ve ç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ı ( ...examples/lite/examples/object_detection/android_play_services/build.gradle ) içeren örnek kod dizinine gidin ve o dizini seçin.

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

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

  1. Android Studio'dan Run > Run… ve MainActivity öğelerini 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, mobilenetv1.tflite gibi önceden eğitilmiş nesne algılama modelini kullanır ve TensorFlow Lite biçiminde 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, model için veri 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şturmak ve örnek uygulamada gösterilen modeli çalıştırmak için temel adımlar açıklanmaktadır. Bu talimatlar, daha önce gösterilen örnek uygulamayı referans noktası olarak kullanır.

Proje bağımlılıkları ekle

Temel Android uygulamanızda, 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şlenebilen bir tensör veri biçimine dönüştürür.

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

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, aşağıdakileri seçerek proje bağımlılıklarını senkronize edin: File > Sync Project with Gradle Files .

Google Play hizmetlerini başlat

TensorFlow Lite modellerini çalıştırmak için Google Play hizmetlerini kullandığınızda, kullanmadan önce hizmeti başlatmanız gerekir. Hizmetle birlikte GPU hızlandırma gibi donanım hızlandırma desteği kullanmak istiyorsanız, bu desteği bu başlatmanın bir parçası olarak da 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 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 model yorumlayıcısını başlat

Model dosyasını yükleyerek ve model parametrelerini ayarlayarak TensorFlow Lite makine öğrenimi modeli yorumlayıcısını başlatın. Bir TensorFlow Lite modeli, model kodunu içeren bir .tflite dosyası içerir. Modellerinizi geliştirme projenizin src/main/assets dizininde saklamanız gerekir, ö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())
    

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

Model için veri hazırlama

Görüntüler gibi mevcut verileri Tensor veri formatına dönüştürerek model tarafından yorumlanmak üzere verileri hazırlarsınız, böylece modeliniz tarafından işlenebilir. Tensördeki veriler, modeli eğitmek için kullanılan veri biçimiyle eşleşen belirli boyutlara veya şekle sahip olmalıdır. Kullandığınız modele bağlı olarak, verileri modelin beklediğine uyacak şekilde dönüştürmeniz gerekebilir. Örnek uygulama, kamera alt sisteminden görüntü çerçevelerini çıkarmak için bir ImageAnalysis nesnesi kullanır.

Model tarafından işlenmek üzere verileri hazırlamak için:

  1. Görüntüleri gerekli biçimde çı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 cihazını kamera alt sistemine bağlayın ve kameradan alınan verileri içermesi için 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, 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 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. Ö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)
    

Kol modeli çıktısı

Görüntü verilerini nesne algılama modeline karşı ç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 tahmin sonuçları listesi üretir. Örnek uygulamadaki nesne algılama modeli, algılanan nesneler için bir tahmin listesi ve sınırlayıcı kutular üretir. Ö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ı arabirimi nesnelerine iletmek için bir dinleyici kalıbı kullanın. Örnek uygulama, ObjectDetectorHelper nesnesinden CameraFragment nesnesine algılama sonuçlarını iletmek için bu kalıbı kullanır:

    objectDetectorListener.onResults( // instance of CameraFragment
        results,
        inferenceTime,
        tensorImage.height,
        tensorImage.width)
    
  2. Tahmini kullanıcıya göstermek gibi sonuçlara göre hareket edin. Örnek uygulama, sonucu göstermek için CameraPreview nesnesine 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()
        }
    }
    

Sonraki adımlar