 TensorFlow.org'da görüntüleyin |  Google Colab'da çalıştırın |  Kaynağı GitHub'da görüntüleyin |  Not defterini indir |
Bu öğretici kullanarak TensorFlow Federe federe algoritmalar (TFF) ait özel türleri nasıl uygulanacağını gösteren bir iki bölümlük dizinin ilk bölümü olan Federe Çekirdek (FC) - Bir vakıf olarak hizmet alt düzey arabirimleri kümesi bunun üzerine biz hayata geçirdik Federe Öğrenme (FL) katmanı.
Bu ilk kısım daha kavramsaldır; TFF'de kullanılan bazı temel kavramları ve programlama soyutlamalarını tanıtıyoruz ve bunların kullanımını dağıtılmış bir dizi sıcaklık sensörü ile çok basit bir örnek üzerinde gösteriyoruz. Gelen bu serinin ikinci bölümünde , biz federe eğitim ve değerlendirme algoritmaları basit versiyonunu uygulamaya burada tanıtmak mekanizmaları kullanır. Bir takibinde, biz çalışmaya teşvik uygulaması içinde federe ortalama alınmasının tff.learning .
Bu dizinin sonunda, Federated Core uygulamalarının mutlaka öğrenmeyle sınırlı olmadığını anlamış olacaksınız. Sunduğumuz programlama soyutlamaları oldukça geneldir ve örneğin, dağıtılmış veriler üzerinde analitik ve diğer özel hesaplama türlerini uygulamak için kullanılabilir.
Bu öğretici kendine yeten olarak tasarlanmış olsa da, biz ilk okuma öğreticiler için teşvik görüntü sınıflandırma ve metin nesil TensorFlow Federe çerçevesi ve daha yüksek bir düzey ve daha nazik tanıtımı için Federe Öğrenme API'leri ( tff.learning olarak,) burada tanımladığımız kavramları bağlam içine koymanıza yardımcı olacaktır.
Kullanım Amacı
Özetle, Federal Çekirdek (FC) kompakt program mantığı ifade etmek mümkün kılan bir geliştirme ortamı olduğu dağıtılan iletişim kullanılan bu gibi operatörler ile birleşerek TensorFlow kodu Federal Ortalaması - işlem dağıtılmış toplamlar ortalamalar ve diğer türlerdeki sistemdeki bir dizi istemci cihaz üzerinde dağıtılmış toplamaların, bu cihazlara model ve parametrelerin yayınlanması vb.
Sen farkında olabilir tf.contrib.distribute ve bu noktada sorulması doğal bir soru olabilir: hangi yollarla bu çerçeve farkı nedir? Her iki çerçeve de sonuçta TensorFlow hesaplamalarını dağıtmaya çalışır.
Arasında belirtilen amaç ise bunu düşünmek bir yolu, yani tf.contrib.distribute kullanıcıların dağıtılan eğitim görebilecek minimal değişikliklerle mevcut modeller ve eğitim kodunu kullanmak için izin vermektir, ve çok odak dağıtılan altyapı yararlanmak için nasıl olduğunu mevcut eğitim kodunu daha verimli hale getirmek için, TFF'nin Federe Çekirdeğinin amacı, araştırmacılara ve uygulayıcılara sistemlerinde kullanacakları belirli dağıtılmış iletişim kalıpları üzerinde açık kontrol sağlamaktır. FC'nin odak noktası, dağıtılmış veri akışı algoritmalarını ifade etmek için somut bir uygulamalı dağıtılmış eğitim yeteneklerinden ziyade esnek ve genişletilebilir bir dil sağlamaktır.
TFF'nin FC API'sinin birincil hedef kitlelerinden biri, yeni birleşik öğrenme algoritmalarını denemek ve dağıtılmış sistemdeki veri akışının düzenlenme şeklini etkileyen ince tasarım seçimlerinin sonuçlarını değerlendirmek isteyebilecek araştırmacılar ve uygulayıcılardır. sistem uygulama ayrıntılarıyla çıkmaza girmeden. FC API'nin hedeflediği soyutlama düzeyi, bir araştırma yayınındaki birleşik öğrenme algoritmasının mekaniğini - sistemde hangi verilerin bulunduğunu ve bunların nasıl dönüştürüldüğünü, ancak bunun düzeyine düşmeden - tanımlamak için kullanılabilecek sözde koda kabaca karşılık gelir. bireysel noktadan noktaya ağ mesaj alışverişi.
TFF, bir bütün olarak, verilerin dağıtıldığı ve bu şekilde kalması gereken senaryoları hedeflemektedir, örneğin, gizlilik nedenleriyle ve tüm verilerin merkezi bir konumda toplanmasının uygun bir seçenek olmayabileceği durumlarda. Bu, tüm verilerin bir veri merkezindeki merkezi bir konumda toplanabileceği senaryolara kıyasla, daha yüksek derecede açık kontrol gerektiren makine öğrenimi algoritmalarının uygulanması üzerinde bir etkiye sahiptir.
Başlamadan önce
Koda dalmadan önce, ortamınızın doğru şekilde kurulduğundan emin olmak için lütfen aşağıdaki "Merhaba Dünya" örneğini çalıştırmayı deneyin. İşe yaramazsa, bakınız Kurulum talimatları için rehber.
!pip install --quiet --upgrade tensorflow-federated-nightly
!pip install --quiet --upgrade nest-asyncio
import nest_asyncio
nest_asyncio.apply()
import collections
import numpy as np
import tensorflow as tf
import tensorflow_federated as tff
@tff.federated_computation
def hello_world():
return 'Hello, World!'
hello_world()
b'Hello, World!'
Birleşik veriler
TFF ayırt edici özelliklerinden biri de hangi kompakt federe verilere TensorFlow tabanlı hesaplamaları ifade olanak sağlamasıdır. Biz dağıtılmış sistemdeki cihazların bir grup sitede barındırılan veri öğelerinin bir koleksiyon başvurmak için bu eğitimde süreli federe verileri kullanarak olacaktır. Örneğin, mobil cihazlarda çalışan uygulamalar, verileri merkezi bir konuma yüklemeden yerel olarak toplayabilir ve depolayabilir. Veya bir dizi dağıtılmış sensör, sıcaklık okumalarını konumlarında toplayabilir ve saklayabilir.
TFF'nin tedavi edilir Yukarıdaki örneklerde olduğu gibi Federe veri birinci sınıf vatandaş yani, onlar parametreleri ve fonksiyonların sonuçları olarak görünebilir ve onlar türleri vardır. Bu kavramı pekiştirmek için, federe değerler gibi federe veri kümelerine veya federe türlerinden değerleri olarak sevk edecektir.
Anlaşılması gereken önemli nokta, tüm cihazlarda tüm veri öğeleri koleksiyonunu (örneğin, dağıtılmış bir dizideki tüm sensörlerden alınan tüm toplama sıcaklığı okumaları) tek bir birleşik değer olarak modelliyor olmamızdır.
Örneğin, burada bir TFF istemci cihaz grubu tarafından barındırılan bir federe şamandıra türünü tanımlayacak nasıl. Bir dizi dağıtılmış sensörde gerçekleşen bir sıcaklık okumaları koleksiyonu, bu birleşik türün bir değeri olarak modellenebilir.
federated_float_on_clients = tff.type_at_clients(tf.float32)
Daha genel olarak, TFF bir birleşik tip türü belirterek tanımlanan T üye bileşenlerinin - veri öğeleri ayrı ayrı cihazlara bulunuyorsa ve grup olduğu G , bu tip birleşik değerleri barındırıldığı aygıtların (artı bir üçüncü isteğe bağlı bilgi parçası birazdan bahsedeceğiz). Bu grupla bakın G değerin yerleşim olarak federe değeri barındıran cihazların. Bu nedenle, tff.CLIENTS bir yerleşimin bir örnektir.
str(federated_float_on_clients.member)
'float32'
str(federated_float_on_clients.placement)
'CLIENTS'
Üye bileşenleri ile bir birleşik tipi T ve yerleştirme G kompakt olarak temsil edilebilir {T}@G , aşağıda gösterildiği gibi,.
str(federated_float_on_clients)
'{float32}@CLIENTS'
Küme parantezleri {} Bu, Özlü size sıcaklık sensör okumaları, örneğin beklendiği gibi bir grup olarak istemcilerin ortaklaşa ev sahipliği böylece üye bileşenleri (farklı cihazlarda veri öğeleri), farklı olabileceğini bir hatırlatma olarak hizmet notasyonu multi -SET arasında T birlikte birleşik bir değer teşkil ürün -typed.
Bu bir federe değerin üye bileşenleri yani programcı genellikle opak olan, federe değer basit olarak düşünülebilir gerektiğini not etmek önemlidir dict sisteminde bir cihazın bir tanımlayıcı anahtarlı - bu değerler amaçlanan birlikte yalnızca soyut (örneğin, toplama gibi) dağıtılmış iletişim protokolleri çeşitli temsil birleşik operatör tarafından transforme edilebilir. Bu size çok soyut geliyorsa endişelenmeyin - buna birazdan döneceğiz ve somut örneklerle açıklayacağız.
TFF'deki federe tipler iki çeşittir: federe bir değerin üye bileşenlerinin farklı olabileceği (yukarıda görüldüğü gibi) ve hepsinin eşit olduğu bilinenler. Bu üçüncü, isteğe bağlı bir tarafından kontrol edilir all_equal parametre tff.FederatedType kurucusuna (varsaymak False ).
federated_float_on_clients.all_equal
False
Bir yerleşim ile birleşik tipi G her hangi T üye bileşenleri kompakt olarak temsil edilebilir eşit olduğu bilinmektedir -typed T@G aksine ( {T}@G kıvırcık ayraçlar ile, yansıtacak şekilde düştü çok kümeli üye bileşenlerinin tek bir öğeden oluşması).
str(tff.type_at_clients(tf.float32, all_equal=True))
'float32@CLIENTS'
Pratik senaryolarda ortaya çıkabilecek bu tür bir birleşik değere bir örnek, bir sunucu tarafından birleşik eğitime katılan bir cihaz grubuna yayınlanan bir hiperparametredir (öğrenme hızı, kırpma normu vb.).
Başka bir örnek, sunucuda önceden eğitilmiş, daha sonra bir grup istemci cihazına yayınlanan ve her kullanıcı için kişiselleştirilebilecekleri bir makine öğrenimi modeli için bir dizi parametredir.
Örneğin, bir çift olduğunu varsayın float32 parametreler a ve b basit tek boyutlu lineer regresyon modeli için. Bu tür modellerin (federe olmayan) tipini TFF'de kullanılmak üzere aşağıdaki gibi yapılandırabiliriz. Açı ayraçları <> baskılı tip dizesinde adlandırılmış veya isimsiz tuplelar için kompakt TFF notasyonu vardır.
simple_regression_model_type = (
tff.StructType([('a', tf.float32), ('b', tf.float32)]))
str(simple_regression_model_type)
'<a=float32,b=float32>'
Biz sadece belirtme olduğunu Not dtype ler yukarıda. Skaler olmayan türler de desteklenir. Yukarıdaki kodda tf.float32 daha genel için bir kısa notasyon tff.TensorType(dtype=tf.float32, shape=[]) .
Bu model istemcilere yayınlandığında, elde edilen birleşik değerin türü aşağıda gösterildiği gibi temsil edilebilir.
str(tff.type_at_clients(
simple_regression_model_type, all_equal=True))
'<a=float32,b=float32>@CLIENTS'
Yukarıda federe şamandıra ile simetri uyarınca, federe başlığın diye bir tip sevk edecektir. Daha genel olarak, sık sık üye bileşenleri XYZ -like olduğu federe değere başvurmak için terim federe XYZ kullanacağız. Böylece, böylece federe küpe, federe dizileri, federe modeller ve benzeri şeyleri bahsedeceğiz.
Şimdi, hiç geri gelme float32@CLIENTS - bu birden fazla cihaz üzerinden çoğaltılmış görünür iken, aslında tek olan float32 tüm üye aynı olduğundan,. Genel olarak, yani herhangi bir all-eşit federe tip formu birini düşünebilir T@G olmayan bir federe tip izomorf olarak, T her iki durumda da, aslında sadece tek bir (potansiyel olarak çoğaltılmış olsa) öğesi olduğundan beri, tipi T .
Arasındaki İzomorfizma Verilen T ve T@G , herhangi eğer, ikincisi tipleri hizmet olabilir ne amaçla, merak edebilir. Okumaya devam etmek.
yerleşimler
Tasarıma Genel Bakış
Yukarıdaki bölümde, yerleşim kavramını geliştirdik - müştereken olmak federe değeri barındıran olabilir sistem katılımcı grupları ve biz kullanımını göstermiş tff.CLIENTS bir yerleşime örnektir şartname olarak.
Bir yerleşim kavramı biz TFF tipi sisteme dahil edilmesinin gerekli böylece temel neden açıklamak için, biz TFF'nin amaçlanan kullanımlarından bazıları hakkında bu yazının başında da belirtildiği neler olduğunu hatırlamak.
Bu öğreticide, yalnızca simüle edilmiş bir ortamda yerel olarak yürütülen TFF kodunu göreceksiniz, ancak amacımız, TFF'nin, potansiyel olarak mobil veya gömülü cihazlar dahil olmak üzere, dağıtılmış bir sistemdeki fiziksel cihaz gruplarında yürütmek için dağıtabileceğiniz kod yazmayı etkinleştirmesini sağlamaktır. Android'i çalıştırıyor. Bu aygıtların her biri, sistemde oynadığı role (son kullanıcı aygıtı, merkezi bir koordinatör, çok katmanlı mimaride bir ara katman, vb.) bağlı olarak yerel olarak yürütmek üzere ayrı bir talimat seti alacaktır. Hangi aygıt alt kümelerinin hangi kodu çalıştırdığını ve verilerin farklı bölümlerinin fiziksel olarak nerede gerçekleşebileceğini akıl yürütebilmek önemlidir.
Bu, örneğin mobil cihazlarda uygulama verileriyle uğraşırken özellikle önemlidir. Veriler özel ve hassas olabileceğinden, bu verilerin cihazdan asla ayrılmayacağını statik olarak doğrulama (ve verilerin nasıl işlendiğine dair gerçekleri kanıtlama) yeteneğine ihtiyacımız var. Yerleştirme özellikleri, bunu desteklemek için tasarlanmış mekanizmalardan biridir.
TFF veri merkezli programlama ortamı olarak tasarlanmıştır ve olmuştur gibi, aksine bu işlemler aday olabileceğini nerede operasyonlar odaklama ve TFF verilerine veri gerçekleşmesi ve nasıl dönüştürdü ediliyor odaklanması mevcut çerçevelerin bazıları. Sonuç olarak, yerleştirme, veri üzerindeki işlemlerin bir özelliği olarak değil, TFF'de verinin bir özelliği olarak modellenmiştir. Gerçekten de, bir sonraki bölümde göreceğiniz gibi, bazı TFF operasyonları lokasyonlara yayılıyor ve tek bir makine veya bir grup makine tarafından yürütülmek yerine, tabiri caizse "ağ içinde" çalışıyor.
Gibi belirli bir değerin türünü temsil T@G veya {T}@G (sadece karşıt olarak T TFF yazılmış programların statik analizi ile birlikte) veri yerleştirme kararları açık hale getirir ve bu sağlamak için bir temel olarak hizmet verebilir hassas cihaz verileri için resmi gizlilik garantileri.
Bu noktada nota gereken önemli bir nokta, ancak, biz katılan cihazların gruplar hakkında açık olmak TFF kullanıcıları teşvik ederken ev sahibi verileri (yerleşimleri), programcı bireysel katılımcıların ham veri veya kimlikleri ile anlaşma asla olmasıdır .
TFF kod gövdesi içinde, tasarım ile temsil edilen bir grup oluşturan cihazların numaralandırmak için bir yolu yoktur tff.CLIENTS veya grup belirli bir cihazın varlığını sondaya. Federated Core API, temel mimari soyutlamalar kümesi veya simülasyonları desteklemek için sağladığımız çekirdek çalışma zamanı altyapısının hiçbir yerinde bir cihaz veya istemci kimliği kavramı yoktur. Yazdığınız tüm hesaplama mantığı, tüm müşteri grubu üzerinde işlemler olarak ifade edilecektir.
Hatırlama burada ne Python aksine olmanın federe türlerinin değerleri hakkında Daha önce de belirttiğimiz dict sadece kendi üye bileşenlerini numaralandırmak olamayacağını birinde. TFF program mantığınızın manipüle ettiği değerleri, bireysel katılımcılardan ziyade yerleşimlerle (gruplarla) ilişkili olarak düşünün.
Yerleşimler yanı TFF'nin birinci sınıf vatandaş olacak şekilde tasarlanmıştır ve parametreler ve sonuçları olarak görünebilir placement (temsil edilecek tip tff.PlacementType API). Gelecekte, yerleşimleri dönüştürmek veya birleştirmek için çeşitli operatörler sağlamayı planlıyoruz, ancak bu, bu eğitimin kapsamı dışındadır. Şimdilik, bu düşünmek yeterli placement olarak opak ilkel yerleşik benzer TFF, tip nasıl int ve bool opak yerleşik olan Python türleriyle tff.CLIENTS değil aksine bu tip sabit değişmezi olmak 1 tipi, sabit bir hazır olmak int .
Yerleşimleri Belirtme
TFF iki temel yerleştirme değişmezleri sağlar tff.CLIENTS ve tff.SERVER birden çok istemci cihazlar ile doğal olarak istemci-sunucu mimarileri olarak modellenir pratik senaryolar, (cep telefonları, gömülü cihazlar, dağıtık veritabanları zengin bir çeşitlilik ifade etmek kolay bunu yapmak için, tek bir merkezi sunucu koordinatörü tarafından organize sensörler, vs.). TFF ayrıca özel yerleşimleri, birden çok müşteri grubunu, çok katmanlı ve diğer daha genel dağıtılmış mimarileri desteklemek için tasarlanmıştır, ancak bunları tartışmak bu eğitimin kapsamı dışındadır.
TFF ya belirtilmemiştir tff.CLIENTS veya tff.SERVER aslında temsil eder.
Özellikle, tff.SERVER Tek bir fiziksel cihazı (a tek grubunun üyesi) olabilir, ama böylesi daha iyi bir hataya dayanıklı küme çalışan durum makinesi çoğaltmaya kopyalarından oluşan bir grup olabilir - herhangi bir özel mimari yapmazlar varsayımlar. Aksine, kullandığımız all_equal genelde sunucuda verilerin sadece tek bir öğe ile uğraşıyoruz gerçeğini ifade etmek önceki bölümde belirtilen bit.
Aynı şekilde, tff.CLIENTS bazı uygulamalarda sistemdeki tüm müşterilerine temsil edebilir - ne federe öğrenme bazen de, örneğin nüfus dediğimiz fakat bağlamında Federe Ortalaması Alma üretim uygulamaları , bir grubunu temsil edebilir - bir alt kümesini belirli bir eğitim turunda sabır için seçilen müşteriler. Soyut olarak tanımlanmış yerleşimlere, göründükleri bir hesaplama yürütme için konuşlandırıldığında (veya bu öğreticide gösterildiği gibi, simüle edilmiş bir ortamda bir Python işlevi gibi çağrıldığında) somut anlam verilir. Yerel simülasyonlarımızda, müşteri grubu, girdi olarak sağlanan birleşik veriler tarafından belirlenir.
Birleşik hesaplamalar
Birleşik hesaplamaları bildirme
TFF, modüler geliştirmeyi destekleyen, türü kesin olarak belirlenmiş bir işlevsel programlama ortamı olarak tasarlanmıştır.
Giriş olarak birleşik değerleri kabul ve çıkış olarak birleşik değerler döndürebilir mantık bölümü - TFF bileşimin temel birimi birleşik hesaplama. Önceki örneğimizden sensör dizisi tarafından rapor edilen sıcaklıkların ortalamasını hesaplayan bir hesaplamayı şu şekilde tanımlayabilirsiniz.
@tff.federated_computation(tff.type_at_clients(tf.float32))
def get_average_temperature(sensor_readings):
return tff.federated_mean(sensor_readings)
Diye düşünebilirsiniz, bu noktada Yukarıdaki kod baktığımızda - edilmez zaten orada yapılara dekoratör gibi composable birimlerini tanımlamak için tf.function TensorFlow içinde ve eğer öyleyse, neden bir yenisini tanıtmak ve bunun farkı nedir?
Kısa cevap tarafından oluşturulan kod olmasıdır tff.federated_computation bir iç platformdan bağımsız tutkal dilinde dağıtılmış sistemin bir şartname var - ne TensorFlow, ne de Python sarıcı. Bu noktada, bu şüphesiz kulağa gizemli gelecektir, ancak lütfen birleştirilmiş bir hesaplamanın bu sezgisel yorumunu, dağıtılmış bir sistemin soyut bir özelliği olarak aklınızda bulundurun. Bir dakika içinde açıklayacağız.
İlk olarak, tanımla biraz oynayalım. TFF hesaplamaları genellikle işlevler olarak modellenir - parametreli veya parametresiz, ancak iyi tanımlanmış tip imzaları ile. Bunu sorgulayarak bir hesaplama türü imzasını yazdırabilirsiniz type_signature aşağıda gösterildiği gibi, mülk.
str(get_average_temperature.type_signature)
'({float32}@CLIENTS -> float32@SERVER)'
Tür imzası bize, hesaplamanın istemci cihazlarda farklı sensör okumalarının bir koleksiyonunu kabul ettiğini ve sunucuda tek bir ortalama döndürdüğünü söyler.
Daha ileri gitmeden önce, en bir dakika bu yansıtmak izin - Bu hesaplamanın giriş ve çıkış (farklı yerlerde olan CLIENTS de vs SERVER ). Biz TFF işlemleri konumlarda yayılan ve ağda çalıştırmak ve ne biz sadece dağıtık sistemlerin soyut özelliklere temsil ettiği federe hesaplamaları hakkında söylediği nasıl ilgili yerleşimlerde önceki bölümde söylediklerini hatırlayın. Sadece böyle bir hesaplamayı tanımladık - verilerin istemci cihazlarda tüketildiği ve toplu sonuçların sunucuda ortaya çıktığı basit bir dağıtılmış sistem.
Birçok pratik senaryolarda, üst düzey görevleri temsil hesaplamaları onların girişlerini kabul ve sunucu kendi çıktılarını rapor eğiliminde olacaktır - bu hesaplamalar köken ve sunucuda sonlandırmak sorgular tarafından tetiklenen olabileceği fikrini yansıtmaktadır.
Ancak, FC API bu varsayımı empoze etmez ve yapı taşları birçok biz (sayısız dahil içten kullanmak tff.federated_... yüzden genel olarak yapmanız gerekir, farklı yerleşimlerle girişleri ve çıkışları var sen API bulabilir operatörler) sunucuda çalışan veya bir sunucu tarafından yürütülen bir şey olarak federe hesaplama düşünmüyorum. Sunucu, birleşik bir hesaplamada yalnızca bir tür katılımcıdır. Bu tür hesaplamaların mekaniği hakkında düşünürken, tek bir merkezi koordinatörün perspektifinden ziyade her zaman küresel ağ çapında perspektifi varsayılan olarak kullanmak en iyisidir.
Genel olarak, işlevsel bir tip imzalar kompakt olarak temsil edilir (T -> U) tipleri için T ve U sırasıyla giriş ve çıkışların. Resmi parametresinin türü (örneğin, sensor_readings bu durumda) dekoratör argüman olarak belirtilir. Sonucun türünü belirtmeniz gerekmez - otomatik olarak belirlenir.
TFF sınırlı polimorfizm biçimleri sunsa da, programcıların çalıştıkları veri türleri konusunda açık olmaları şiddetle tavsiye edilir, çünkü bu, kodunuzun özelliklerini anlamayı, hata ayıklamayı ve resmi olarak doğrulamayı kolaylaştırır. Bazı durumlarda, türleri açıkça belirtmek bir gerekliliktir (örneğin, polimorfik hesaplamalar şu anda doğrudan yürütülebilir değildir).
Birleşik hesaplamaları yürütme
Geliştirme ve hata ayıklamayı desteklemek için TFF, aşağıda gösterildiği gibi Python işlevleri olarak bu şekilde tanımlanan hesaplamaları doğrudan çağırmanıza izin verir. Hesaplama ile federe türde bir değer beklediği Nerede all_equal için bit kümesi False , bir düz olarak besleyebilir list Python ve birlikte federe türleri için all_equal için bit kümesi True , sadece doğrudan (tek) besleyebilir üye kurucu. Sonuçlar da bu şekilde size geri bildirilir.
get_average_temperature([68.5, 70.3, 69.8])
69.53334
Simülasyon modunda bunun gibi hesaplamaları çalıştırırken, aslında burada olduğu gibi, ağdaki herhangi bir yerde girdi sağlama ve çıktı tüketme yeteneğine sahip, sistem çapında bir görünüme sahip harici bir gözlemci olarak hareket edersiniz - müşteri değerlerini sağladınız girişte ve sunucu sonucunu tüketti.
Şimdi, nota edelim dönüş daha önce hakkında yapılan tff.federated_computation bir tutkal dilde kod yayan dekoratör. TFF hesaplamaların mantığı Python sıradan fonksiyonları olarak ifade edilebilir olsa da (sadece onları süslemek için ihtiyaç tff.federated_computation yukarıda yaptığımız gibi) ve sadece bu başka Python fonksiyonları gibi Python argümanlarla onları çağırmak doğrudan can Daha önce de belirttiğimiz gibi defter, perde arkasında, TFF hesaplamaları aslında Python değildir.
Ne bu demek Python yorumlayıcısı ile süslü bir işlevi karşılaştığında olmasıdır tff.federated_computation , bir zamanlar (tanım anda) bu işlevin vücudunda ifadeleri izleri ve sonra inşa seri hale getirilmiş gösterimi ileride kullanılmak üzere hesaplama en mantığının - ister yürütme için veya başka bir hesaplamaya bir alt bileşen olarak dahil edilmek üzere.
Aşağıdaki gibi bir print ifadesi ekleyerek bunu doğrulayabilirsiniz:
@tff.federated_computation(tff.type_at_clients(tf.float32))
def get_average_temperature(sensor_readings):
print ('Getting traced, the argument is "{}".'.format(
type(sensor_readings).__name__))
return tff.federated_mean(sensor_readings)
Getting traced, the argument is "ValueImpl".
Birleşik bir hesaplamayı tanımlayan Python kodunu, hevesli olmayan bir bağlamda bir TensorFlow grafiği oluşturan Python kodunu nasıl düşündüğünüze benzer şekilde düşünebilirsiniz (TensorFlow'un hevesli olmayan kullanımlarına aşina değilseniz, Python kodu, daha sonra yürütülecek bir işlem grafiğini tanımlar, ancak aslında onları anında çalıştırmaz). TensorFlow'daki hevesli olmayan grafik oluşturma kodu Python'dur, ancak bu kod tarafından oluşturulan TensorFlow grafiği platformdan bağımsızdır ve seri hale getirilebilir.
Benzer şekilde, TFF hesaplamaları Python'da tanımlandığı gibidir, ancak bu şekilde, vücutları Python ifadeleri tff.federated_mean örnekte, tek gösterilen weve, başlık altında taşınabilir ve platformdan bağımsız seri temsil derlenir.
Bir geliştirici olarak, hiçbir zaman doğrudan onunla çalışmanız gerekmeyeceğinden, bu gösterimin ayrıntılarıyla ilgilenmenize gerek yoktur, ancak varlığının, TFF hesaplamalarının temelde hevesli olmadığı gerçeğinin farkında olmalısınız, ve keyfi Python durumunu yakalayamaz. Süslenmiş Python işlevinin beden zaman TFF hesaplama vücudunda bulunan Python kodu, tanım sırasında yürütülür tff.federated_computation tefrika almadan önce izlenmesini. Çağrı sırasında tekrar izlenmez (fonksiyonun polimorfik olduğu durumlar dışında; ayrıntılar için lütfen dokümantasyon sayfalarına bakın).
Neden özel bir Python dışı temsili sunmayı seçtiğimizi merak edebilirsiniz. Bunun bir nedeni, nihai olarak, TFF hesaplamalarının gerçek fiziksel ortamlarda konuşlandırılabilir olması ve Python'un kullanılamadığı mobil veya gömülü cihazlarda barındırılmasıdır.
Diğer bir neden de, TFF hesaplamalarının, bireysel katılımcıların yerel davranışlarını ifade eden Python programlarının aksine, dağıtılmış sistemlerin küresel davranışını ifade etmesidir. Sen özel operatör ile, yukarıda basit örnekte görebilirsiniz tff.federated_mean istemci cihazlardaki verileri, ancak mevduat sunucudaki sonuçları kabul eder.
Operatör tff.federated_mean yerel olarak çalıştırmak olmadığından kolayca Python sıradan bir operatör olarak modellenmiş edilemez - daha önce belirtildiği gibi, bir dağıtılmış sistem temsil ettiği koordinatları birçok sistem katılımcılarının davranış. Biz Python sıradan (yerel) operatörleri ayırt etmek, federe operatörler gibi operatörler sevk edecektir.
TFF tipi sistem ve TFF'nin dilinde desteklenen temel işlemler dizisi, bu nedenle Python'dakilerden önemli ölçüde sapar ve özel bir temsilin kullanılmasını gerektirir.
Birleşik hesaplamalar oluşturma
Yukarıda belirtildiği gibi, birleşik hesaplamalar ve bileşenleri en iyi şekilde dağıtılmış sistem modelleri olarak anlaşılır ve birleşik hesaplamaları daha basit olanlardan daha karmaşık dağıtılmış sistemler oluşturmak olarak düşünebilirsiniz. Aklınıza gelebilecek tff.federated_mean yerleşik şablon federe hesaplama türüdür imzayla bir tür olarak operatör ({T}@CLIENTS -> T@SERVER) (gerçekten, yazdığınız sadece hesaplamaları gibi, bu operatörün de karmaşık vardır yapı - kaputun altında daha basit operatörlere ayırıyoruz).
Aynı şey birleşik hesaplamalar oluşturmak için de geçerlidir. Hesaplama get_average_temperature süslenmiş başka Python işlevinin bir vücutta çağrılmış olabilir tff.federated_computation - Bunu yaparken, bu ebeveyn gövdesine gömülü neden olur hemen aynı şekilde tff.federated_mean kendi vücut önceki gömülü edildi.
Önemli bir kısıtlama ile dekore Python fonksiyonları organları olmasıdır farkında olmak tff.federated_computation yani sadece federe operatörlerin oluşmalıdır, bunlar doğrudan TensorFlow işlemlerini içeremez. Örneğin, doğrudan kullanamazsınız tf.nest federe değerlerin bir çifti eklemek için arayüzler. TensorFlow kodu ile dekore kod blokları içinde kalmalıdır tff.tf_computation aşağıdaki kısmında tartışılmıştır. Bu şekilde sarılmış Yalnızca sarılmış TensorFlow kodu gövdesinde çağrılabilen tff.federated_computation .
Bu ayırma nedenleri (bu gibi operatörler hile zor teknik olan tf.add mimari gibi olmayan tensörlerle ile çalışmak için). Birleşik hesaplamaların dili (yani, dekore Python fonksiyonları tefrika organları yapılmış mantık tff.federated_computation ), platformdan bağımsız bir yapıştırıcı dil olarak hizmet etmek üzere tasarlanmıştır. Bu birleştirici dil şu anda (sınırlı TensorFlow kod gömülü kesitlerden yapı dağıtık sistemler için kullanılan tff.tf_computation blokları). Zamanı gelince, bu tür giriş boru hatlarını temsil edebilir ilişkisel veritabanı sorguları gibi diğer non-TensorFlow mantığının gömmek bölümden ihtiyacını, hepsi aynı tutkal dili (ile birbirlerine bağlanan tahmin tff.federated_computation blok).
TensorFlow mantığı
TensorFlow hesaplamalarını bildirme
TFF, TensorFlow ile kullanılmak üzere tasarlanmıştır. Bu nedenle, TFF'ye yazacağınız kodun büyük kısmı muhtemelen sıradan (yani yerel olarak yürütülen) TensorFlow kodu olacaktır. Yukarıda belirtildiği gibi TFF ile böyle kodunu kullanmak için, bu sadece süslenmiş gereken tff.tf_computation .
Örneğin, burada bir sayı alır ve ekler bir işlevi uygulamak gibi uygulayabilirsiniz 0.5 ona.
@tff.tf_computation(tf.float32)
def add_half(x):
return tf.add(x, 0.5)
Biz başka dekoratör tanımlamalıdır neden kez daha, bu bakarak merak ediyor olabilirsiniz tff.tf_computation basitçe gibi varolan mekanizmasını kullanmak yerine tf.function . Önceki bölümden farklı olarak, burada sıradan bir TensorFlow kodu bloğu ile ilgileniyoruz.
Bunun tam tedavisi bu eğitimin kapsamını aşan birkaç nedeni vardır, ancak asıl olanı adlandırmaya değer:
- TensorFlow kodu kullanılarak federe hesaplamaların gövdelerine uygulanan yeniden kullanılabilir yapı taşlarını gömmek için, tanım zamanında izlenme ve serileştirilme, tür imzalarına sahip olma vb. gibi belirli özellikleri karşılamaları gerekir. Bu genellikle bir tür dekoratör gerektirir.
Genel olarak, örneğin, bileşim için TensorFlow doğal mekanizmalar kullanılarak tavsiye tf.function istekli fonksiyonları ile TFF dekoratör etkileşime beklenebilecek kesin bir şekilde gelişmeye olarak mümkün olan her yerde,.
Şimdi, örnek koduna gelen geri hesaplama, yukarıda pasajı add_half biz sadece tanımlı tıpkı diğer TFF hesaplama gibi TFF tarafından tedavi edilebilir. Özellikle TFF tipi bir imzaya sahiptir.
str(add_half.type_signature)
'(float32 -> float32)'
Bu tür imzanın yerleşimleri olmadığını unutmayın. TensorFlow hesaplamaları, birleşik türleri tüketemez veya döndüremez.
Ayrıca artık kullanabilirsiniz add_half diğer hesaplamalarda bir yapı taşı olarak. Örneğin, aşağıda kullanabileceğiniz nasıl tff.federated_map uygulamak için operatöre add_half istemci cihazlarda federe şamandıranın tüm üye bileşenlerine noktasal.
@tff.federated_computation(tff.type_at_clients(tf.float32))
def add_half_on_clients(x):
return tff.federated_map(add_half, x)
str(add_half_on_clients.type_signature)
'({float32}@CLIENTS -> {float32}@CLIENTS)'
TensorFlow hesaplamalarını yürütme
İle tanımlanan hesaplamaların Yürütme tff.tf_computation biz için tarif edilen ile aynı kurallara aşağıdaki tff.federated_computation . Aşağıdaki gibi Python'da sıradan çağrılabilirler olarak çağrılabilirler.
add_half_on_clients([1.0, 3.0, 2.0])
[<tf.Tensor: shape=(), dtype=float32, numpy=1.5>, <tf.Tensor: shape=(), dtype=float32, numpy=3.5>, <tf.Tensor: shape=(), dtype=float32, numpy=2.5>]
Bir kez daha, hesaplama çağırma dikkati çekiyor add_half_on_clients bu şekilde dağıtılmış sürecini taklit eder. Veriler istemcilerde tüketilir ve istemcilerde döndürülür. Gerçekten de, bu hesaplama her istemcinin yerel bir eylem gerçekleştirmesini sağlar. Hiçbir yoktur tff.SERVER açıkça (hatta pratikte ise, bu tür işleme düzenlediğini birini içerebilir) Bu sistemde sözü. Kavramsal olarak benzer olarak bu şekilde tanımlanan bir hesaplama düşünün Map sahnede MapReduce .
Ayrıca, ne TFF hesaplamaları tanımı anda tefrika alma hakkında önceki bölümde sözü için geçerliliğini korumaktadır unutmayın tff.tf_computation Python vücut - yanı kodu add_half_on_clients tanım saatte bir kez takip alır. Sonraki çağrılarda TFF, serileştirilmiş temsilini kullanır.
Python dekore yöntemleri arasındaki tek fark tff.federated_computation ve süslenmiş olan tff.tf_computation (eski doğrudan bu gömülü TensorFlow kodu içeren izin verilmez ise) ikinci TensorFlow grafik olarak tefrika olmasıdır.
Kaputun altında, süslenmiş her yöntem tff.tf_computation geçici hesaplama yapısı çekilecek izin vermek için istekli yürütme devre dışı bırakır. İstekli yürütme yerel olarak devre dışı bırakılırken, hesaplamanızın mantığını doğru şekilde seri hale getirilebilecek şekilde yazdığınız sürece istekli TensorFlow, AutoGraph, TensorFlow 2.0 yapıları vb. kullanabilirsiniz.
Örneğin, aşağıdaki kod başarısız olacaktır:
try:
# Eager mode
constant_10 = tf.constant(10.)
@tff.tf_computation(tf.float32)
def add_ten(x):
return x + constant_10
except Exception as err:
print (err)
Attempting to capture an EagerTensor without building a function.
Çünkü yukarıda başarısız constant_10 zaten bu grafik dışında inşa edilmiştir tff.tf_computation gövdesine dahili olarak inşa add_ten seri işlemi sırasında.
Öte yandan, bir iç adlandırılan mevcut grafik değiştirme piton fonksiyonlar çağırarak tff.tf_computation gayet:
def get_constant_10():
return tf.constant(10.)
@tff.tf_computation(tf.float32)
def add_ten(x):
return x + get_constant_10()
add_ten(5.0)
15.0
TensorFlow'daki serileştirme mekanizmalarının geliştiğini ve TFF'nin hesaplamaları nasıl seri hale getirdiğinin ayrıntılarının da gelişmesini beklediğimizi unutmayın.
Çalışma tf.data.Dataset s
Daha önce belirtildiği gibi, benzersiz bir özellik tff.tf_computation ler onlar ile çalışmak size izin vermesidir tf.data.Dataset kodunuz tarafından biçimsel parametre olarak soyut bir biçimde tanımlanmış s. Veri setleri kullanılarak bildirilmesi gerekir gibi parametreler TensorFlow temsil edilecek tff.SequenceType yapıcısı.
Örneğin, özellikleri tff.SequenceType(tf.float32) TFF flot elemanlarının soyut dizisini tanımlar. Diziler, tensörler veya karmaşık iç içe yapılar içerebilir (bunların örneklerini daha sonra göreceğiz). Bir sekansın kısa temsilidir T ürün -typed olan T* .
float32_sequence = tff.SequenceType(tf.float32)
str(float32_sequence)
'float32*'
Suppose that in our temperature sensor example, each sensor holds not just one temperature reading, but multiple. Here's how you can define a TFF computation in TensorFlow that calculates the average of temperatures in a single local data set using the tf.data.Dataset.reduce operator.
@tff.tf_computation(tff.SequenceType(tf.float32))
def get_local_temperature_average(local_temperatures):
sum_and_count = (
local_temperatures.reduce((0.0, 0), lambda x, y: (x[0] + y, x[1] + 1)))
return sum_and_count[0] / tf.cast(sum_and_count[1], tf.float32)
str(get_local_temperature_average.type_signature)
'(float32* -> float32)'
In the body of a method decorated with tff.tf_computation , formal parameters of a TFF sequence type are represented simply as objects that behave like tf.data.Dataset , ie, support the same properties and methods (they are currently not implemented as subclasses of that type - this may change as the support for data sets in TensorFlow evolves).
You can easily verify this as follows.
@tff.tf_computation(tff.SequenceType(tf.int32))
def foo(x):
return x.reduce(np.int32(0), lambda x, y: x + y)
foo([1, 2, 3])
6
Keep in mind that unlike ordinary tf.data.Dataset s, these dataset-like objects are placeholders. They don't contain any elements, since they represent abstract sequence-typed parameters, to be bound to concrete data when used in a concrete context. Support for abstractly-defined placeholder data sets is still somewhat limited at this point, and in the early days of TFF, you may encounter certain restrictions, but we won't need to worry about them in this tutorial (please refer to the documentation pages for details).
When locally executing a computation that accepts a sequence in a simulation mode, such as in this tutorial, you can feed the sequence as Python list, as below (as well as in other ways, eg, as a tf.data.Dataset in eager mode, but for now, we'll keep it simple).
get_local_temperature_average([68.5, 70.3, 69.8])
69.53333
Like all other TFF types, sequences like those defined above can use the tff.StructType constructor to define nested structures. For example, here's how one could declare a computation that accepts a sequence of pairs A , B , and returns the sum of their products. We include the tracing statements in the body of the computation so that you can see how the TFF type signature translates into the dataset's output_types and output_shapes .
@tff.tf_computation(tff.SequenceType(collections.OrderedDict([('A', tf.int32), ('B', tf.int32)])))
def foo(ds):
print('element_structure = {}'.format(ds.element_spec))
return ds.reduce(np.int32(0), lambda total, x: total + x['A'] * x['B'])
element_structure = OrderedDict([('A', TensorSpec(shape=(), dtype=tf.int32, name=None)), ('B', TensorSpec(shape=(), dtype=tf.int32, name=None))])
str(foo.type_signature)
'(<A=int32,B=int32>* -> int32)'
foo([{'A': 2, 'B': 3}, {'A': 4, 'B': 5}])
26
The support for using tf.data.Datasets as formal parameters is still somewhat limited and evolving, although functional in simple scenarios such as those used in this tutorial.
Putting it all together
Now, let's try again to use our TensorFlow computation in a federated setting. Suppose we have a group of sensors that each have a local sequence of temperature readings. We can compute the global temperature average by averaging the sensors' local averages as follows.
@tff.federated_computation(
tff.type_at_clients(tff.SequenceType(tf.float32)))
def get_global_temperature_average(sensor_readings):
return tff.federated_mean(
tff.federated_map(get_local_temperature_average, sensor_readings))
Note that this isn't a simple average across all local temperature readings from all clients, as that would require weighing contributions from different clients by the number of readings they locally maintain. We leave it as an exercise for the reader to update the above code; the tff.federated_mean operator accepts the weight as an optional second argument (expected to be a federated float).
Also note that the input to get_global_temperature_average now becomes a federated float sequence . Federated sequences is how we will typically represent on-device data in federated learning, with sequence elements typically representing data batches (you will see examples of this shortly).
str(get_global_temperature_average.type_signature)
'({float32*}@CLIENTS -> float32@SERVER)'
Here's how we can locally execute the computation on a sample of data in Python. Notice that the way we supply the input is now as a list of list s. The outer list iterates over the devices in the group represented by tff.CLIENTS , and the inner ones iterate over elements in each device's local sequence.
get_global_temperature_average([[68.0, 70.0], [71.0], [68.0, 72.0, 70.0]])
70.0
This concludes the first part of the tutorial... we encourage you to continue on to the second part .