Google Play Hizmetleri'nde ML Kit ve LiteRT ile cihaz üzerinde zekada uzmanlaşma

Herkese iyi akşamlar.

Sohbet başlamak üzere.

Dolayısıyla, günümüzde "cihaz üzerinde yapay zeka" dendiğinde genellikle LLM'ler kastedilir.

Bugün daha önce, ML Kit, Firebase ve Google'ın diğer birçok ürünüyle birlikte Gemini Nano hakkında birkaç konuşma dinlediniz.

Bu oturumda ise diğer yarıyı, yani klasik makine öğrenimini ve kendi getirdiğiniz modeli ele alacağız.

Bugün farkında olmadan birkaç kez kullanmış olabilirsiniz.

Arka planınızı bulanıklaştırdığınız, barkod tarayıcı kullandığınız veya bir tür resim düzenleme işlemi yaptığınız uygulamalarınızı düşünün.

Bu çalışmaların çoğu klasik makine öğrenimiyle ilgiliydi ve genellikle cihaz üzerinde çalışıyordu.

Bu özelliklerden herhangi birini kendi uygulamanıza veya APK'nıza eklediyseniz genellikle şu ikilemle karşılaşmışsınızdır: Temel olarak anahtar teslim bir API mi kullanmalıyım yoksa kendi modelimi mi getirmeliyim?

Uygulamamın boyutuna etkisi ne olacak?

Bugün, kullanıma hazır bir model ile kendi modelinizi getirme arasında seçim yapmak zorunda olmadığınızı göreceksiniz.

Aslında tek bir yalın çalışma zamanıyla her ikisini de yapabilirsiniz.

Adım Chintan Parikh.

Ben LiteRT'nin ürün müdürüyüm. Yanımda Android ML hizmetlerinin mühendislik lideri Fergus var.

Merhaba,

Son olarak, her kamera karesinde saniyedeki kare sayısı (FPS) yaklaşık 30 olan iki model çalıştıran bir uygulamayı nasıl oluşturabileceğinizi göreceksiniz.

Bu konuşma dört bölümden oluşuyor.

İlk bölümde, Google'ın klasik makine öğrenimine odaklanan cihaz üzerinde yapay zeka çözümlerinden (ML Kiti ve LiteRT) bahsedeceğiz.

İkinci olarak, LiteRT ve Play Hizmetleri'ndeki yenilikleri de inceleyeceğiz.

Ayrıca LiteRT'nin yeni CompiledModel API'sini ve desteklediğimiz cihazları da ele alacağız.

Üçüncü olarak, yeni bir uygulamanın nasıl oluşturulacağını göstereceğiz.

Fergus, ML Kiti ve özel bir modelle tek bir APK'da uygulama oluşturma konusunu ele alacak.

Son olarak, Temsilci Modu'nu kullanarak mevcut bir uygulamayı nasıl yükselteceğinizi göstereceğiz.

Ayrıca bu temsilci desteğiyle yeni bir uygulama da oluşturabilirsiniz.

İşte böyle.

Öncelikle LiteRT'nin ne olduğunu öğrenelim.

LiteRT, Google'ın kendi modelleriniz için cihaz üzerinde çıkarım çalışma zamanıdır.

Daha önce TensorFlow Lite ile kullandıysanız aynı .tflite dosya biçimini kullanır.

Performans için yeniden tasarlanmıştır ve çoklu çerçeveyi de destekler.

Yani PyTorch, TensorFlow ve hatta JAX'ten modelleri getirip LiteRT için düz arabellek biçimine indirebilirsiniz.

2022'den beri Google Play Hizmetleri'ndeki TensorFlow Lite, özel modeller için Android'in resmi cihaz üzerinde çalışma zamanı olarak kullanılmaktadır.

Bugün önemli bir güncelleme alıyor ve bu konuşmanın büyük bir kısmı da bununla ilgili olacak.

Bu yükseltme, 1, 4 kat daha hızlı olacak yeni ve iyileştirilmiş GPU çıkarımı da dahil olmak üzere en yeni LiteRT CompiledModel API'yi sunacak ve çok daha küçük APK boyutlarında daha küçük uygulamalar oluşturmanıza olanak tanıyacak.

Peki neden Play Hizmetleri üzerinden sunuluyor?

Birkaç avantajı var. Uygulama boyutu ve APK şişkinliğinin gerçek bir sorun haline geldiği birçok konuşmada bunun kesinlikle büyük bir sorun olduğunu görüyorum.

Bu sayede çalışma zamanı küçük olur.

Çalışma zamanı APK'nızda bulunmadığından ince istemci kullanırsınız. Bu da APK'nızın yaklaşık 8 MB daha küçük olmasını sağlar.

İkinci avantaj, verimliliktir.

Çalışma zamanının bir kopyası olduğu için LiteRT çalışma zamanı tüm uygulamalarda paylaşılır.

Çok sayıda uygulamanız varsa her birinin 8 MB tasarruf sağladığını düşünebilirsiniz.

Disk alanından tasarruf etmeye ve daha yalın bir uygulamaya sahip olmaya çalıştığınızda bu boyutlar çok hızlı bir şekilde artar.

İkincisi, bakımı yapılır.

Google, hata düzeltmelerini gönderir, GPU sürücüsüyle ilgili sorunları çözer ve diğer tüm güvenlik güncellemelerini otomatik güncellemeler aracılığıyla sunar.

Ayrıca bahsettiğim gibi GPU daha hızlı. 1,4 kat daha hızlı GPU elde edersiniz. Bu konuyu da daha ayrıntılı olarak ele alacağız.

Kapsam açısından bakıldığında, eski Android cihazlara da gönderebiliriz.

Play Hizmetleri'ndeki LiteRT, 2016'dan itibaren Android 7'ye kadar tüm sürümleri destekler.

Fergus'un da göstereceği gibi, ilerleyen slaytlarda yeni cihazlara da yer vereceğiz.

Bu, teslimat aracıdır. Şimdi bir sonraki adım olan çalışma zamanından bahsedelim.

Dolayısıyla LiteRT yeni veya deneysel bir ürün değildir.

TensorFlow Lite ve LiteRT,günümüzde 250.000'den fazla uygulamada çalışıyor.

Ayrıca günümüzde 3,8 milyardan fazla cihazda çalışıyor.

Yani kullandığınız birçok uygulama, farkında bile olmasanız da bu sistemi kullanıyor.

Bu da her gün bir trilyondan fazla çıkarım yapıldığı anlamına geliyor, değil mi?

Bu ölçekte, her türlü tuhaf yonga seti sorunuyla karşılaştık, ROM sorunlarını veya GPU sürücüsü sorunlarını çözebildik ve sizin için bir çözümümüz var.

LiteRT, Google'ın amiral gemisi uygulamalarında, platformlarda ve hatta çeşitli cihazlarda da çalıştırdığı bir araçtır.

YouTube Shorts efektleri, Meet arka plan segmentasyonu ve fotoğrafta bulanıklık giderme, gerçek zamanlı video ve ağır görüntü modellerinin LiteRT'de çalıştığı örneklerden bazılarıdır.

Bu da son derece önemli. Çünkü kullanım alanlarını kullanıcılar için ilgi çekici ve hızlı hale getirmek çok önemli, değil mi?

Bu, amiral gemisi özellikler için güçlendirdiğimiz çalışma zamanı ortamıdır ve Google Play Hizmetleri aracılığıyla sunulur.

Şimdi de neden cihaz üzerinde yapay zekayı tercih etmeniz gerektiğine değinelim.

Gecikme, gizlilik, çevrimdışı çalışma veya düşük maliyetler sizin için önemliyse çevrimdışı çalıştırın.

Başka nedenler de olabilir ancak cihaz üzerinde çalıştırma konusunda duyduğumuz en belirgin nedenlerden bazıları bunlardır.

Cihaz üzerinde çalıştırmak da her zaman ücretsiz değildir.

Bu yaklaşımın bazı nüansları ve zorlukları vardır.

Bu zorluklardan bazılarını ele alıp size bir yol haritası da sunacağız.

Performans: Önceki uygulamalardan bazı örneklerde gördüğünüz gibi, gecikme ve bellek bütçeleri her zaman kısıtlıdır.

Anlık video ve ses için son derece yüksek verimlilik gerekir.

Basit etkileşimli özelliklerin bile hızlı olması gerekir.

Aksi takdirde kullanıcı etkileşimini kaybedersiniz.

Donanım çeşitliliği: Farklı CPU ve GPU yapılandırmalarına sahip yüzlerce SoC vardır.

Bunların hepsi için kod yazamazsınız, değil mi?

Bu sorunları nasıl çözersiniz?

APK boyutu: Yerel bir çalışma zamanını paketlemek, her indirme işleminin boyutunu da artırır ve bu da dönüşüm oranlarınızı etkileyebilir.

Özelleştirme: Model eğitimi, kalite, model boyutu, bunların hepsi dağıtımdan önce bile son derece kritik olacaktır.

Evet, cihaz üzerinde çalışan harika bir cihaz uygulaması geliştirmek zor olabilir.

Ancak bu durumların her birinde, platformun sizin için çalışmasını istiyoruz, tersini değil, değil mi?

Google'ın cihaz üzerinde yapay zeka portföyü bu zorlukları ele almak için tasarlandı. Şimdi bu konuyu inceleyeceğiz.

Bugün iki basit çözüme odaklanacağız.

Play Hizmetleri aracılığıyla cihaz üzerinde yapay zeka eklemenin iki kolay yolu vardır.

1. yol, ML Kiti'ni kullanan anahtar teslim yol, değil mi?

Bunlar kullanıma hazır görüntü ve dil API'leridir. Sınırlı makine öğrenimi uzmanlığı gerektirir. Birçok model sağlanır ve tümü Google Play Hizmetleri aracılığıyla sunulur.

Sonraki slaytlarda bunlarla ilgili bazı örnekleri de inceleyeceğiz.

Özel yol, LiteRT aracılığıyla kullanılır.

LiteRT, kendi modelinizi getirmenize ve CPU ile GPU'da çalıştırmanıza olanak tanır.

Çalışma zamanı da Play Hizmetleri'nden gelir.

Yani APK'nızda paketlemezsiniz.

Bunlar birbirini dışlayan seçenekler değildir.

Birlikte daha iyi de olabilirler.

Bugün önümüzdeki birkaç dakika içinde tam olarak bunu oluşturacağız.

Ancak önce ML Kit'in neleri kapsadığına değinelim.

ML Kit'in kullanıma hazır olarak sunduğu özellikler şunlardır:

Bu özelliklerden bazılarının ihtiyaçlarınızı karşıladığını düşünüyorsanız bu harika bir başlangıç noktasıdır ve zaten bir adım öndesiniz demektir.

Görsel, barkod, belge, metin, poz gibi birçok özellik için kapsamımız var. Çeviri, akıllı yanıtlar ve hatta varlık çıkarma gibi dil API'lerimiz de var, değil mi?

Önemli nokta, bu görüntü ve dil API'lerinin çoğunun arka planda LiteRT ile çalışmasıdır.

ML Kit ihtiyacınızı karşılıyorsa buradan başlayabilirsiniz.

Yeterli olmadığı durumlarda ise kendi modelinizi kullanabilirsiniz.

Burada önemli bir nokta var: ML Kiti ve özel modeliniz, bahsettiğim gibi iki çalışma zamanı olmayacak.

Bunları, arka planda çalışacak aynı LiteRT'ye açılan iki ön kapı olarak düşünebilirsiniz.

Bu nedenle LiteRT, bu özelliklerin her ikisini de yöneten Play çalışma zamanı olacak.

Uygulamanızda Google Play Store'u kullanıyorsanız ML Kit'i de kullanabilirsiniz.

Aksi takdirde LiteRT yolunu da inceleyeceğiz.

LiteRT'deki yeniliklere de değinelim.

Bahsettiğim gibi, LiteRT, TensorFlow Lite'ın gelişmiş bir versiyonu.

En büyük iyileştirmeler, daha hızlı bir GPU'ya sahip olmamız.

Daha hızlı GPU; OpenCL ve OpenGL'yi destekler, ayrıca Metal arka uçları için bile platformlar arası destek sunar.

Bu nedenle, gerektiğinde birden fazla platform için bu özelliği kullanabilirsiniz.

Ayrıca daha basit.

CPU, GPU ve NPU hızlandırma için tek bir birleştirilmiş iş akışımız var.

CPU ve GPU şu anda Play Hizmetleri'nde yer alırken NPU, LiteRT aracılığıyla paketlenir ve bu konuda çalışmalar devam etmektedir.

Yani daha önce her hızlandırıcı farklı bir yetki verilmiş kullanıcı kurulumu anlamına geliyordu, değil mi?

Artık bunu yalnızca bir kez yapmanız yeterli.

Bu nedenle, CPU'ya otomatik olarak geri dönen bir API vardır ve özel yetki verilmiş kurulumlar yapmanız gerekmez.

Bu işlemi çok daha basit ve daha az kodla yönetebilen hızlandırıcı çağrıları kullanabilirsiniz.

Ayrıca güçlüdür. Bahsettiğim gibi aynı model birden fazla platformda çalışır.

Bu esneklik kısmı çok önemli olacak.

Bu nedenle .tflite biçimi aynı kalır.

Mevcut bir uygulamanız varsa bu biçimi kullanmaya devam edebilirsiniz.

Yeni bir uygulama geliştiriyorsanız bu dosya biçimini tekrar kullanabilirsiniz.

Ayrıca, daha önce TensorFlow Lite'da bulunan Interpreter API'yi de destekliyoruz.

Aşamalı olarak geçiş yapmak istiyorsanız Interpreter API, yeni LiteRT'nin bir parçası olarak dahil edildiğinden geçiş işlemini kolayca gerçekleştirebilirsiniz.

Çalışma zamanı bu şekilde.

Bu araçla neler oluşturabileceğinizden bahsedelim.

Android uygulamaları bugün bu şekilde geliştiriliyor.

Kamera efektleri, fotoğraf düzenleme, akıllı yazma, oyunlar ve avatarlar gibi her şey, değil mi?

Bu uygulamaların çoğu gerçek zamanlı özelliklere ihtiyaç duyacak.

GPU, kareleri doğrudan kameradan gönderiyor. Bu nedenle, işlemlerin hızlı ve gerçek zamanlı olması önemlidir.

Bu fotoğraf düzenleme modellerinden bazıları da daha ağır hale geliyor.

Gözlüklerle yapılan bazı demolarda gördüğünüz AR/VR özellikleri de aynı şekilde LiteRT'yi kullanıyor.

Bu çalışma zamanı, Google'ın amiral gemisi özelliklerinin ve Google Play Hizmetleri'nin arkasındaki çalışma zamanıyla aynıdır. Bu sayede, APK'nıza herhangi bir şey eklemeden tüm bu özelliklerden yararlanabilirsiniz.

Şimdi bir uygulama geliştirelim. Fergus bize nasıl yapacağımızı gösterecek.

Hadi yapalım.

Teşekkürler, Chintan.

Şimdi Google Play Hizmetleri'ndeki LiteRT'deki yeniliklerden biraz bahsedeceğim.

Derleme işlemine geçmeden önce bir haber daha verelim: Az önce gördüğünüz her şey artık yalnızca telefonlarda çalışmıyor. Google Play Hizmetleri'ndeki LiteRT, Wear OS ve Android Automotive OS'te de kullanılabiliyor.

Böylece kol saatinizde, diğer giyilebilir cihazlarınızda veya arabanızda cihaz üzerinde çalışan modeller kullanabilirsiniz.

Önceden telefonunuzda Wear için tamamlayıcı uygulama olarak kullanabileceğiniz bir uygulama kullanabiliyordunuz. Artık bu uygulamayı doğrudan giyilebilir cihazda çalıştırabilirsiniz. Aynı durum Android Automotive için de geçerlidir.

Böylece aynı API'yi ve aynı .tflite modelini daha fazla platformda kullanabilirsiniz.

Her form faktörü için ayrı bir uygulama yapmanız gerekmez. Tüm bu farklı cihazlar için aynı uygulamayı kullanabilirsiniz.

Play Hizmetleri dağıtım modelinin en güzel yanı, bu özelliği eski cihazlarda çalışacak şekilde geriye dönük olarak uyarlayabilmemizdir.

Android Automotive OS için 2020'de kullanıma sunulan Android 11'e kadar olan sürümleri, Wear OS için ise Wear OS 4 ve sonraki sürümleri destekliyoruz.

Anladım.

Şimdi iki farklı yoldan bahsedeceğim: yeni bir uygulama oluşturma ve mevcut bir uygulamayı yükseltme.

Konuşmanın geri kalanında bu konuyu ele alacağız.

ML Kit'in kullanımını LiteRT'de çalışan özel bir GPU modeliyle birleştiren örnek bir uygulamayla başlayacağım.

Mevcut bir uygulamayı yükseltmek için üç küçük değişiklik yapmanız gerekir: bağımlılıkları güncellemek için Gradle değişikliği, Google Play Hizmetleri'nde LiteRT'yi etkinleştirmek için başlatma değişikliği ve Interpreter API'den CompiledModel API'ye geçiş.

Ancak önce yeni uygulamayı inceleyeceğiz. Çünkü neye yükseltme yaptığınızı gördüğünüzde yükseltme işlemi çok daha anlamlı hale gelecektir.

Yeni bir uygulama geliştiriyorsunuz.

Oluşturacağımız uygulama bu.

Bu özellik, canlı kamera görünümünde sizi net gösterirken arka plana sanatsal bir stil uygular.

Kamera çerçevesini alacağız.

Kamera karesindeki görüntüleri ML Kit selfie segmentasyonu üzerinden yayınlayacağız.

Bu, mevcut ML Kit anahtar teslim API'lerinden biridir.

Bu da görüntüdeki piksellerden hangilerinin görüntüdeki kişiye karşılık geldiğini belirten bir ön plan maskesi oluşturur.

Ardından, stil aktarımı türünde bir model olan özel modelimizi alacağız. Bu model, bir görüntüye stil uygulayacak.

Bunu kamera karesinin tamamına uygulayacağız ancak asıl ilgilendiğimiz kısım arka plan. Sonuçta orijinal kamera karesini, maskeyi ve stil arka planını alıp basit bir mantıkla birleştireceğiz. Böylece özneyi koruduğumuz ve arka planın stile sahip olduğu bir kompozit kare elde edeceğiz.

Bu nedenle, mevcut olan yerlerde kullanıma hazır API'lerden, uygulamamızı farklılaştıran yerlerde ise özel API'lerden yararlanmak istiyoruz.

Bu, ML Kit selfie segmentasyon API'sini çağırdığımız ilk bölümdür.

// 1. Configure and create segmenter client
val segmenter = Segmentation.getClient(
    SelfieSegmenterOptions.Builder()
        .setDetectorMode(
            SelfieSegmenterOptions.STREAM_MODE)
        .build())

// 2. Prepare image & run inference
fun processFrame(mediaImage: Image) {
  val image = InputImage.fromMediaImage(
      mediaImage, /* rotationDegrees= */ 0)
  segmenter.process(image)
      .addOnSuccessListener { mask -> … }
}

Yani bu normal bir API gibi, değil mi?

Bu, Android geliştiricileri için ekmek ve tereyağı gibidir.

API belgelerine bakabilir veya Gemini'dan sizin için oluşturmasını isteyebilirsiniz.

Ancak oldukça basit bir süreç.

İstemciyi oluştururken bazı seçenekleri ilettiğiniz bir istemci oluşturursunuz.

Bu örnekte, video kareleri akışını işleyebilmek için akış modunu belirtiyoruz.

Ardından, bu işlem yöntemini çağırdığınız bir yer var ve bu yöntemin geri çağırma işlevi, selfie segmentasyonu tarafından hesaplanan ve döndürülen maskeyi alır.

Giriş ise kameradan alınan görüntüdür.

Tüm bu API'ler ham tensörler yerine uygulama düzeyinde türler kullanır. Bu sayede çok yüksek düzeyde programlama yapabilirsiniz ve bu gerçekten çok kolaydır.

İkinci bölüm olan özel model için bir PyTorch modeli kullanacağız.

Sanırım Chintan bunu Kaggle veya Hugging Face gibi bir yerden aldı…

Doğru.

Evet, kendi videolarınızı da dönüştürebilirsiniz.

Kendi modelinizi oluşturabilirsiniz.

Maalesef geri dönüyorum.

Evet, yığın bu şekilde görünüyor.

PyTorch modelini dönüştürüp niceliklendirdikten sonra LiteRT modeli elde edersiniz.

Ardından, bunu uygulamanızla birlikte istediğiniz şekilde dağıtırsınız.

Uygulamanın bir parçası olarak öğe şeklinde paketlenebilir veya ayrı olarak indirilebilir.

İki yöntem de kullanılabilir.

Bu da Play Hizmetleri'ndeki LiteRT çalışma zamanının üzerinde yer alır.

CPU'da optimizasyon için CPU çekirdekleri vardır ve GPU hızlandırıcının adı ML Drift'tir.

Evet, dediğim gibi, TFLite modelini alırsınız. Modeli kendiniz eğitebilir veya mevcut bir modeli bulabilirsiniz. Her iki yöntem de işe yarar.

PyTorch'tan dönüştürme işlemi yalnızca birkaç satır Python koduyla yapılabilir.

import litert_torch

model = my_models.Stylizer().eval()

# Convert with torch.export under the hood
edge_model = litert_torch.convert(
    model, sample_inputs)
edge_model.export("stylizer_f32.tflite")

LiteRT-Torch'u pip ile yükledikten sonra litert_torch.convert işlevini çağırıp rastgele girişler olabilecek sample_inputs değerlerini ileterek TFLite dosyasını dışa aktarabilirsiniz.

Bu arada, LiteRT-Torch, ai-edge-torch'un yeni adıdır.

Niceleme de yine çok basittir.

# Python
# previously ai_edge_quantizer
from litert_quantizer import quantizer, recipe

qt = quantizer.Quantizer("stylizer_f32.tflite")

# int8 weights, float activations
qt.load_quantization_recipe(
    recipe.dynamic_wi8_afp32())

qt.quantize().export_model("stylizer_int8.tflite")

Niceleyiciyi ve tarifi LiteRT Quantizer'dan içe aktarırsınız.

Niceleyiciyi oluştururken orijinal kayan nokta modelini ve GPU için önerdiğimiz standart tarifi kullanırsınız. Bu tarifte 8 bit tam sayı ağırlıkları kullanılır ancak etkinleştirmeler 32 bit kayan nokta olarak tutulur.

Ardından, quantize işlevini çağırıp çıkış modelini kaydedersiniz.export_model

Bu, çalıştırabileceğiniz, çok daha küçük ağırlıklara sahip ve daha verimli çalışan bir kuantize model olur.

Evet, CompiledModel API'si GPU'da gerçekten çok başarılı.

Chintan'ın da belirttiği gibi, eski TFLite GPU'ya kıyasla önemli bir hız artışı elde ediliyor.

Tam sayılar modelden modele biraz farklılık gösterse de 1, 4 kat artış makul bir beklentidir.

CPU çıkarımından 10 kat daha hızlı. Bu da büyük bir avantaj, değil mi?

Şu anda model kullananlarınızın çoğu muhtemelen bunları CPU'da çalıştırıyor ve GPU'dan elde edebileceğiniz performansın 10 katını kaçırıyor.

Bu gerçekten teşvik edici bir durum.

Hızlı olmasını sağlayan nedir?

Desteklediğimiz birçok özellik var. Örneğin, eşzamansız yürütme sayesinde bir AHardwareBuffer alıp doğrudan iletebilir veya bu kamera oluşturma ardışık düzeninden bir OpenGL arabelleği alıp doğrudan bir tensör arabelleğine iletebilirsiniz.

Sıfır kopyalama, desteklediğimiz sıfır kopyalamayı optimize eder. Böylece, düşük gecikme bütçesiyle işlem yapmaya çalışırken (ör. her kareyi birkaç on milisaniye içinde işlemeniz gerektiğinde) bellek arabelleğini kopyalamak bile önemli bir ek yük oluşturabilir.

Bu nedenle, sıfır kopyalama optimizasyonunu kullanmak istediğiniz yüksek gerçek zamanlı gereksinim uygulamaları için bunu destekliyoruz.

Ayrıca Chintan'ın da belirttiği gibi, GPU arka uçları olarak OpenGL, OpenCL ve Metal'i destekleyen platformlar arası bir araçtır.

Son olarak, ML Drift Optimizer açık kaynaklıdır.

Apache lisansı kapsamında kullanılabilir.

Google, bu modeli yakın zamanda açık kaynaklı hale getirdi.

Şimdi de uygulama koduna bakalım.

// Kotlin
// Build once, off the main thread.
private val model: CompiledModel =
    CompiledModel.create(
        context.assets,
        "stylizer_int8.tflite",
        // Simple GPU setup!
        CompiledModel.Options(Accelerator.GPU),
        environment
    )

// Reuse buffers across frames.
private val inputBuffers  = model.createInputBuffers()
private val outputBuffers = model.createOutputBuffers()

fun stylize(input: FloatArray): FloatArray {
    inputBuffers[0].writeFloat(input)
    model.run(inputBuffers, outputBuffers) // sync
    return outputBuffers[0].readFloat()
}

Gördüğünüz gibi oldukça küçük ve basit bir model.

Yani modeli bir kez oluşturup her karede yeniden kullanırsınız.

Bu nedenle, CompiledModel.create, .tflite dosyasını iletir.

GPU'da çalıştırmak istediğinizi belirtmeniz, ardından girişi ve outputBuffers oluşturmanız yeterlidir.

Ardından, her kareyi işlediğiniz ana döngüde, girişi ve çıkışı ileterek bu model.run öğesini çağırırsınız.

inputBuffers dosyasına yazdıktan sonra model.run işlevini çağırın ve ardından outputBuffers dosyasından okuyun.

Anladım.

Evet, orada GPU'yu belirtirseniz GPU'da çalışır.

Burada CPU ve GPU'yu da belirtirseniz GPU'yu çalıştırmayı dener.

GPU herhangi bir nedenle kullanılamıyorsa CPU'ya geri döner.

Bu nedenle, bazı durumlarda CPU yedekleme, uygulamanız için yeterince verimli olmayabilir. Bu durumda, GPU'yu bu şekilde belirtmeniz gerekir.

Genellikle CPU yedeklemesi kullanmak istersiniz.

Anladım.

Bu nedenle, henüz Google Play Hizmetleri'ni kullanmayan, paket halinde LiteRT ile oluşturduk.

Şimdi size Play Hizmetleri'nde LiteRT'yi nasıl kullanacağınızı göstereyim.

Yani üç değişiklik var: İlki bağımlılık değişikliği.

// Easier with CompiledModel API: 3 steps

// 1. app/build.gradle: replace litert with play-services-litert
- implementation 'com.google.ai.edge.litert:litert:...'
+ implementation 'com.google.android.gms:play-services-litert:17.0.0'  // also pulls in litert-api

Gradle dosyanızda veya başka bir yerde, kullandığınız derleme sisteminde, Maven paketi bağımlılıklarını belirttiğiniz her yerde değişiklik yapmanız gerekir.

litert bağımlılığını veya eski TensorFlow Lite Maven paketi bağımlılıklarından herhangi birini kaldırıp bunları play-services-litert ile değiştirirsiniz.

Bu işlem, litert-api paketini de yükler.

Yalnızca LiteRT'ye bağlı olan ancak çalışma zamanının uygulamadan mı yoksa Google Play Hizmetleri'nden mi geldiğini önemsemeyen bir orta katman yazıyorsanız LiteRT API'ye bağlı kalabilir ve giriş parametresi olarak bir ortam kullanabilirsiniz.

İkinci adım, ortam parametresidir.

Bağımlılık ekleme işlemini burada yaparsınız. Temel olarak, Play Hizmetleri LiteRT'yi kullanmak istediğinizi belirtirsiniz.

Bu nedenle, gms.litert.LiteRt öğesini içe aktarır ve Android etkinliğiniz olan bağlamı ileterek başlatma işlevini çağırırsınız.

// 2. Initialize the LiteRT Environment from Play services (context = your Activity)
- val environment = Environment.create(...)
+ import com.google.android.gms.litert.LiteRt
+ val environment = LiteRt.initialize(context).await()

// 3. Pass environment whenever you call CompiledModel.create

// That's it! The rest of your app uses the normal CompiledModel APIs from litert-api.

Bu eşzamansız bir işlem olduğundan .await yöntemini çağırmanız veya geri kalan kısmın bir geri çağırmaya dayalı olmasını sağlamanız gerekir.

Son olarak, bu ortamı oluşturduktan sonra CompiledModel.create işlevini her çağırdığınızda bu ortamı iletirsiniz.

Bu sayede, Play Hizmetleri'ndeki Play Hizmetleri LiteRT çalışma zamanını kullanır.

Hepsi bu kadar.

Yani uygulamanızın geri kalanı, LiteRT API'deki LiteRT CompiledModel API'lerinin aynısını kullanır.

Çıkarım kodunuzun geri kalanı, Play Hizmetleri'ni kullanmak için değişmez.

Bu taşıma işlemini kademeli olarak yapabilirsiniz.

Hepsini tek seferde yapmanız gerekmez. Bileşenleri tek tek taşıyabilirsiniz.

Büyük bir uygulamanız varsa LiteRT kullanan her bileşeni taşımanız mantıklı olur. Ardından, bileşenleri tek tek taşıyıp test edebilirsiniz.

Ancak, yalnızca boyut avantajı elde edersiniz. Alan tasarrufu, yalnızca paketlenmiş çalışma zamanına olan son bağımlılığı kaldırdığınızda gerçekleşir.

Ayrıca, Play Hizmetleri'ndeki LiteRT ile paket halinde sunulan LiteRT arasında nesneleri karıştırmamanız gerekir.

Bu nedenle, Play Hizmetleri'ndeki LiteRT'den tensörler, derlenmiş modeller veya yorumlayıcılar alıyorsanız bunları paket halinde sunulan LiteRT'ye aktarmamalısınız. Bunun tersi de geçerlidir.

Ancak bunun dışında, bu iki yöntemi bir arada kullanmak oldukça iyi sonuçlar verir.

Anladım.

Yeni bir uygulama oluşturma bu şekildeydi.

Şimdi mevcut bir uygulamayı nasıl yükselteceğinizden bahsedeceğim.

Dolayısıyla, Interpreter API'yi kullanan mevcut bir uygulamanız olabilir.

Bu, ana sınıf olarak yorumlayıcıyı kullanan eski TFLite API'sidir.

Solda Interpreter API'yi kullanan kodu, sağda ise yeni CompiledModel API kodunu görüyorsunuz.

// Dependencies (Gradle):
// play-services-tflite-java and/or litert (bundled)

// Init
TfLite.initialize(context).await()

// Load
val interpreterOptions =
    InterpreterApi.Options().apply {
      runtime = TfLiteRuntime.FROM_SYSTEM_ONLY
    }

val interpreter =
    InterpreterApi.create(modelFile, interpreterOptions)

// Prepare inputs/outputs
val inputs = …
val outputs = …

// Execute
interpreter.run(inputs, outputs)

// Dependencies (Gradle):
// play-services-litert

// Init
val environment =
  LiteRt.initialize(context).await()

// Load
val modelOptions = CompiledModel.Options(Accelerator.CPU)

val model =
    CompiledModel.create(modelPath, modelOptions, environment)

// Prepare inputs/outputs
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

// Execute
model.run(inputBuffers, outputBuffers

Yani TfLite.initialize değerini LiteRt.initialize olarak değiştiriyorsunuz ve bu artık bir ortam döndürüyor.

Ardından ortamı CompiledModel.create'a geçirirsiniz.

Bu küçük bir değişikliktir ve APK boyutunu artırmaz.

Bir sonraki slaytta, GPU ile nasıl yapılacağını göstereceğiz. Bu da başka bir seçenek.

GPU'yu etkinleştirmek için gereken ek kod budur.

// Dependencies (Gradle):
// play-services-tflite-java and/or litert (bundled)

// Init
val initOptions = TfLiteInitializationOptions.builder()
    .setEnableGpuDelegateSupport(true).build()
TfLite.initialize(context, initOptions).await()
val useGpu =
    TfLiteGpu.isGpuDelegateAvailable(context).await()

// Load
val interpreterOptions =
    InterpreterApi.Options().apply {
      runtime = TfLiteRuntime.FROM_SYSTEM_ONLY
    }
if (useGpu) {
    interpreterOptions.addDelegateFactory(
        GpuDelegateFactory());
}
val interpreter =
    InterpreterApi.create(modelFile, interpreterOptions)

// Prepare inputs/outputs
val inputs = …
val outputs = …

// Execute
interpreter.run(inputs, outputs)

// Dependencies (Gradle):
// play-services-litert

// Init
val initOptions = LiteRtInitializationOptions.builder()
    .setEnableGpu(true).build()
val environment = LiteRt.initialize(context, initOptions).await()

// Load
val modelOptions =
    CompiledModel.Options(Accelerator.CPU, Accelerator.GPU)

val model =
    CompiledModel.create(modelPath, modelOptions, environment)

// Prepare inputs/outputs
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

// Execute
model.run(inputBuffers, outputBuffers)

Gördüğünüz gibi, yeni API'de GPU'yu etkinleştirmek için kullanılan kod, önceki koda göre biraz daha basit.

Bu nedenle, LiteRT başlatma seçeneklerinde setEnableGpu için yapılan ilk çağrı LiteRt.initialize'e iletilir. Bu da GPU hızlandırıcı kodunun uygulamanıza yüklenmesine neden olur.

Ardından modelOptions oluşturup CompiledModel.create'e ilettiğinizde, belirli bir model için hangi hızlandırıcının kullanılacağını belirtirsiniz. Diğer modelin yalnızca GPU'da mı, CPU yedekli GPU'da mı yoksa yalnızca CPU'da mı çalışacağını seçebilirsiniz.

İşte böyle.

Gördüğünüz gibi, yeni API ile GPU'yu etkinleştirmek çok daha kolay.

Peki, bu özellikten nasıl yararlanabilirsiniz?

Chintan size anlatacak.

İşte böyle.

Teşekkürler Fergus.

Şimdi tüm bunların bize ne kazandırdığından bahsedelim.

Bir uygulama oluşturacağımızı söylemiştik. Şimdi ne oluşturduğumuza bakalım.

İşte bu benim. Burada yaptığımız şey, beni bulmak için ML Kiti'ni kullanmak oldu. Segmentasyon, ML Kiti gibi anahtar teslim bir API tarafından yapılıyor.

Yani, kafamı bulmaya çalışıyorum.

Ardından LiteRT, arka planı boyamak için stil aktarımına benzer başka bir model kullanır.

Bahsettiğimiz diğer avantajlar ise yaklaşık 8 MB alan tasarrufu sağlamanız, artık tüm uygulamalarınız arasında kullanılan veya en azından burada paylaşılan bir çalışma zamanına sahip olmanız, otomatik güncellemeler almanız ve zengin bir kullanıcı deneyimi için gerçek zamanlı olması gereken bir şeyde saniyede yaklaşık 30 kare elde etmenizi sağlayan daha hızlı bir GPU'ya sahip olmanızdır.

Ayrıca tüm bunları manuel olarak yapmanız gerekmez.

Android'de yeni kullanıma sunduğumuz bir beceri daha var. Temel olarak, cihaz üzerinde makine öğreniminizi dakikalar içinde yükselten bir Android LiteRT becerisi yayınladık.

Bu sayede, mevcut bir uygulamayı yükseltebilir, yeni bir uygulama oluşturabilir ve uygulamanızı bu yeni Play Hizmetleri entegrasyonunu kullanacak şekilde yükseltebilirsiniz.

Tüm bunlar kullanılabilir.

Bağlantı slaytta ve GitHub'da yer alıyor. Ayrıca dokümanlarımızda ve blogumuzda da gösterilecek.

Bu nedenle, yakın zamanda geçiş yapmayı düşünen herkes için faydalı olacaktır.

Fergus, bu sürecin bir sonraki aşamasını anlatacak.

Bu nedenle, LiteRT ile cihaz üzerinde yapay zekaya önem veriyoruz.

GPU hızlandırmayı ve model kapsamını iyileştirmek için önemli yatırımlar yapmaya devam ediyoruz. Ayrıca hem açık kaynaklı paketlenmiş LiteRT hem de Google Play Hizmetleri'ndeki LiteRT olan Google Play Hizmetleri LiteRT Maven paketi için LiteRT 2.x'e düzenli güncellemeler sunmaya devam ediyoruz.

Ayrıca geriye dönük uyumluluk sağlamaya devam edeceğiz.

Play Hizmetleri çalışma zamanı, eski SDK'larla oluşturulan uygulamaları desteklemeye devam edecek.

Evet.

Bu, kullanıcılarımız için çok önemli, bizim için de çok önemli.

LiteRT 1.x SDK'ları şu anda bakım modunda olduğundan yalnızca kritik güvenlik düzeltmeleri yapılır.

2024'te desteğini sonlandırdığımız NNAPI ise 2027'den itibaren kaldırılacak.

NNAPI kullanıyorsanız lütfen GPU hızlandırma veya paket halinde LiteRT ile NPU hızlandırmaya geçin.

Anladım.

Evet.

Bu nedenle, 2.x ve CompiledModel sürümüne ne kadar erken geçerseniz daha sonra yapmanız gerekenler o kadar az olur.

Özetle, üç noktaya dikkat etmeniz gerekir.

Bu nedenle, oluşturun.

ML Kiti ile başlayın. İhtiyaçlarınızı karşılıyorsa ne âlâ.

Ancak desteklemiyorsa özel modelleriniz için LiteRT'yi kullanın.

APK tasarrufu ve paylaşılan çalışma zamanı için Google Play Hizmetleri'nde LiteRT'ye geçin.

Daha hızlı ve basit GPU çıkarımı için CompiledModel API'yi kullanabilirsiniz.

Evet.

Her şey, AI Edge'deki LiteRT doküman sitemizde belgelenmiştir.

Evet.

Bize katıldığınız için teşekkür ederiz. Neler geliştireceğinizi görmek için sabırsızlanıyoruz.