Nucleo federato

Questo documento introduce al livello core delle TFF che funge da base per federati Learning , e le possibili future non di apprendimento algoritmi federati.

Per una breve introduzione a Federated Core, leggere i seguenti tutorial, poiché introducono alcuni dei concetti fondamentali tramite esempi e dimostrano passo dopo passo la costruzione di un semplice algoritmo di media federato.

Vorremmo anche incoraggiarvi a familiarizzare con federati di apprendimento e le esercitazioni associato sulla classificazione di immagini e la generazione del testo , come gli usi della API Federated core (FC API) per l'apprendimento federata fornire un presupposto fondamentale per alcune delle scelte che abbiamo fatto in progettare questo strato.

Panoramica

Obiettivi, usi previsti e ambito

Federated Core (FC) è meglio inteso come un ambiente di programmazione per l'implementazione di calcoli distribuiti, ovvero calcoli che coinvolgono più computer (telefoni cellulari, tablet, dispositivi incorporati, computer desktop, sensori, server di database, ecc.) che possono eseguire ciascuno non elaborazione banale localmente e comunicare attraverso la rete per coordinare il loro lavoro.

Il termine distribuito è molto generico, e TFF non bersaglia tutti i possibili tipi di algoritmi distribuiti fuori, quindi si preferisce utilizzare il calcolo federata meno termine generico per descrivere i tipi di algoritmi che possono essere espresse in questo contesto.

Durante la definizione del calcolo federata termine in maniera del tutto formale è al di fuori della portata di questo documento, si pensi ai tipi di algoritmi si potrebbe Sede ha espresso in pseudocodice in una pubblicazione di ricerca che descrive un nuovo algoritmo di apprendimento distribuito.

L'obiettivo di FC, in una nusthell, è quello di consentire la rappresentazione simile compatto, ad un livello pseudocodice simile simile di astrazione, di logica di programma che non è pseudocodice, ma piuttosto, che è eseguibile in una varietà di ambienti di destinazione.

La caratteristica chiave che definisce i tipi di algoritmi che FC è progettato per esprimere è che le azioni dei partecipanti al sistema sono descritte in modo collettivo. Così, si tende a parlare di ogni dispositivo trasformazione a livello locale dei dati, ed i dispositivi coordinare il lavoro da una trasmissione coordinatore centralizzato, raccolta, o aggregando i loro risultati.

Mentre TFF è stato progettato per essere in grado di andare al di là di semplici architetture client-server, la nozione di elaborazione collettiva è fondamentale. Ciò è dovuto alle origini di TFF nell'apprendimento federato, una tecnologia originariamente progettata per supportare calcoli su dati potenzialmente sensibili che rimangono sotto il controllo dei dispositivi client e che non possono essere semplicemente scaricati in una posizione centralizzata per motivi di privacy. Mentre ogni cliente in tali sistemi contribuisce con dati e potenza di elaborazione al calcolo di un risultato dal sistema (un risultato che generalmente ci aspetteremmo di essere di valore per tutti i partecipanti), ci sforziamo anche di preservare la privacy e l'anonimato di ciascun cliente.

Pertanto, mentre la maggior parte dei framework per il calcolo distribuito sono progettati per esprimere l'elaborazione dal punto di vista dei singoli partecipanti, ovvero a livello di scambi di messaggi individuali punto-punto e l'interdipendenza delle transizioni dello stato locale del partecipante con i messaggi in entrata e in uscita , di TFF Federated core è progettato per descrivere il comportamento del sistema dal punto di vista a livello di sistema globale (analogamente a, per esempio, MapReduce ).

Di conseguenza, mentre i quadri distribuiti per scopi generali possono offrire operazioni come inviare e ricevere in blocchi da costruzione, FC fornisce blocchi costruttivi quali tff.federated_sum , tff.federated_reduce o tff.federated_broadcast che incapsulano semplici protocolli distribuito.

Lingua

Interfaccia Python

TFF utilizza un linguaggio interno per rappresentare elaborazioni federati, la cui sintassi è definita dalla rappresentazione serializzabile in computation.proto . Tuttavia, gli utenti dell'API FC generalmente non avranno bisogno di interagire direttamente con questo linguaggio. Piuttosto, forniamo un'API Python (la tff namespace) che avvolge Arounds come un modo per definire calcoli.

Specificamente, TFF fornisce decoratori funzione Python come tff.federated_computation che traccia i corpi delle funzioni decorati e produrre rappresentazioni serializzata logica computazione federata nel linguaggio di TFF. Una funzione decorato con tff.federated_computation agisce da carrier di tale rappresentazione serializzata, e può incorporare come un elemento nel corpo di un altro calcolo, o eseguirlo su richiesta quando viene richiamato.

Ecco solo un esempio; altri esempi si possono trovare negli algoritmi personalizzati tutorial.

@tff.federated_computation(tff.type_at_clients(tf.float32))
def get_average_temperature(sensor_readings):
  return tff.federated_mean(sensor_readings)

Lettori familiarità con tensorflow non ansiosi troveranno questo approccio analogo a scrivere codice Python che utilizza funzioni come tf.add o tf.reduce_sum in una sezione di codice Python che definisce un grafico tensorflow. Sebbene il codice è tecnicamente espressa in Python, il suo scopo è quello di costruire una rappresentazione serializzabile di un tf.Graph sotto, ed è il grafico, non il codice Python, che viene eseguito internamente dal runtime tensorflow. Allo stesso modo, si può pensare tff.federated_mean l'inserimento di un op federata in un calcolo federata rappresentato da get_average_temperature .

Una parte del motivo per cui FC definisce un linguaggio ha a che fare con il fatto che, come notato sopra, i calcoli federati specificano comportamenti collettivi distribuiti e, in quanto tali, la loro logica non è locale. Ad esempio, TFF fornisce operatori, i cui input e output possono esistere in diversi punti della rete.

Ciò richiede un linguaggio e un sistema di tipi che catturino la nozione di distribuzione.

Tipo di sistema

Federated Core offre le seguenti categorie di tipi. Nel descrivere questi tipi, indichiamo i costruttori di tipo e introduciamo una notazione compatta, poiché è un modo pratico o descrive tipi di calcoli e operatori.

Innanzitutto, ecco le categorie di tipi concettualmente simili a quelle che si trovano nei linguaggi tradizionali esistenti:

  • Tipi tensore ( tff.TensorType ). Proprio come in tensorflow, questi hanno dtype e shape . L'unica differenza è che oggetti di questo tipo non sono limitati a tf.Tensor istanze in Python che rappresentano le uscite della OPS tensorflow in un grafico tensorflow, ma può anche comprendere unità di dati che possono essere prodotti, ad esempio, come un'uscita di una distribuita protocollo di aggregazione. Pertanto, il tipo di tensore TFF è semplicemente una versione astratta di una rappresentazione fisica concreta di tale tipo in Python o TensorFlow.

    La notazione compatto per tipi tensoriali è dtype o dtype[shape] . Ad esempio, int32 e int32[10] sono i tipi di interi e vettori int, rispettivamente.

  • Tipi di sequenze ( tff.SequenceType ). Questi sono equivalenti astratti di TFF del concetto concreto di tensorflow di tf.data.Dataset s. Gli elementi delle sequenze possono essere utilizzati in modo sequenziale e possono includere tipi complessi.

    La rappresentazione compatta tipi sequenza è T* , dove T è il tipo di elementi. Ad esempio int32* rappresenta un numero intero sequenza.

  • Tipi tuple Named ( tff.StructType ). Questi sono il modo di TFF di costruire tuple e le strutture che hanno un numero predefinito di elementi con tipi specifici, denominati o senza nome simile ai dizionari. È importante sottolineare che il concetto di tupla denominata di TFF comprende l'equivalente astratto delle tuple di argomenti di Python, ovvero raccolte di elementi di cui alcuni, ma non tutti, sono denominati e alcuni sono posizionali.

    La notazione compatta per tuple nome è <n_1=T_1, ..., n_k=T_k> , dove n_k sono nomi degli elementi opzionali, e T_k sono tipi di elementi. Ad esempio, <int32,int32> è una notazione compatta per una coppia di numeri interi senza nome, e <X=float32,Y=float32> è una notazione compatta per una coppia di galleggianti denominato X e Y che può rappresentare un punto su un piano . Tuple possono essere annidato nonché miscelato con altri tipi, ad esempio, <X=float32,Y=float32>* sarebbe una notazione compatta per una sequenza di punti.

  • Tipi di funzione ( tff.FunctionType ). TFF è un framework di programmazione funzionale, con funzioni trattate come valori di prima classe . Le funzioni hanno al massimo un argomento ed esattamente un risultato.

    La notazione compatto per funzioni è (T -> U) , dove T è il tipo di un argomento, e U è il tipo del risultato, o ( -> U) se non c'è nessun argomento (sebbene funzioni senza argomenti sono un degenerato concetto che esiste principalmente solo a livello di Python). Ad esempio (int32* -> int32) è una notazione per un tipo di funzioni che riducono una successione di interi a un singolo valore intero.

I seguenti tipi affrontano l'aspetto dei sistemi distribuiti dei calcoli TFF. Dal momento che questi concetti sono in qualche modo unico al TFF, ti invitiamo a fare riferimento al algoritmi personalizzati tutorial per commenti e ulteriori esempi.

  • Tipo di posizionamento. Questo tipo non è ancora esposta nella API pubblica se non in forma di 2 letterali tff.SERVER e tff.CLIENTS che si può pensare come costanti di questo tipo. Tuttavia, viene utilizzato internamente e verrà introdotto nell'API pubblica nelle versioni future. La rappresentazione compatta di questo tipo è placement .

    Un posizionamento rappresenta un collettivo di partecipanti al sistema che giocano un ruolo particolare. La versione iniziale si rivolge calcoli client-server, in cui ci sono 2 gruppi di partecipanti: clienti e un server (si può pensare di quest'ultimo come gruppo Singleton). Tuttavia, in architetture più elaborate, potrebbero esserci altri ruoli, come aggregatori intermedi in un sistema multilivello, che potrebbero eseguire diversi tipi di aggregazione o utilizzare diversi tipi di compressione/decompressione dei dati rispetto a quelli utilizzati dal server o i clienti.

    Lo scopo primario di definire la nozione di tirocini è come base per definire i tipi di federate.

  • Tipi federati ( tff.FederatedType ). Un valore di un tipo federata è uno che è ospitato da un gruppo di partecipanti al sistema definito da un posizionamento specifico (come ad esempio tff.SERVER o tff.CLIENTS ). Un tipo federata è definito dal valore di collocamento (in tal modo, si tratta di un tipo dipendente ), il tipo di componenti di membri (che tipo di contenuti ciascuno dei partecipanti è localmente hosting), e il bit aggiuntivo all_equal che specifica se tutti i partecipanti sono localmente ospitare lo stesso elemento.

    La notazione compatta per tipo federata di valori che comprendono elementi costituenti (utente) di tipo T , ciascuno ospitato da gruppo (stage) G è T@G o {T}@G con la all_equal bit impostato o non impostata, rispettivamente.

    Per esempio:

    • {int32}@CLIENTS rappresenta un valore federata che consiste di un insieme di numeri interi potenzialmente distinti, uno per ogni dispositivo client. Si noti che stiamo parlando di un singolo valore federata nel senso che comprende più elementi di dati che appaiono in più sedi in tutta la rete. Un modo di pensare è come una sorta di tensore con una dimensione "rete", anche se questa analogia non è perfetta perché TFF non consente l'accesso casuale ai componenti membri di un valore federata.

    • {<X=float32,Y=float32>*}@CLIENTS rappresenta un insieme di dati federata, un valore che è costituito da più sequenze di XY coordinate, una sequenza per dispositivo client.

    • <weights=float32[10,5],bias=float32[5]>@SERVER rappresenta un nome tupla di peso e di polarizzazione tensori sul server. Da quando abbiamo lasciato cadere la parentesi graffe, questo indica il all_equal bit è impostato, vale a dire, c'è solo un singolo tupla (indipendentemente dal numero di server di repliche ci potrebbe essere in un cluster che ospita questo valore).

Costruzioni

Il linguaggio della Federated Core è una forma di lambda-calcolo , con alcuni elementi aggiuntivi.

Fornisce le seguenti astrazioni di programmazione attualmente esposte nell'API pubblica:

  • Tensorflow calcoli ( tff.tf_computation ). Questi sono sezioni di codice tensorflow avvolto come componenti riutilizzabili in TFF utilizzando la tff.tf_computation decoratore. Hanno sempre tipi funzionali e, a differenza delle funzioni in TensorFlow, possono accettare parametri strutturati o restituire risultati strutturati di un tipo di sequenza.

    Ecco un esempio, un calcolo di tipo TF (int32* -> int) che utilizza l' tf.data.Dataset.reduce all'operatore di calcolare una somma di numeri interi:

    @tff.tf_computation(tff.SequenceType(tf.int32))
    def add_up_integers(x):
      return x.reduce(np.int32(0), lambda x, y: x + y)
    
  • Intrinseche o operatori federate ( tff.federated_... ). Questa è una libreria di funzioni come tff.federated_sum o tff.federated_broadcast che costituiscono la maggior parte della FC API, la maggior parte dei quali rappresentano distribuito operatori di comunicazione per l'utilizzo con TFF.

    Ci riferiamo a questi come intrinseci perché, un po 'come funzioni intrinseche , sono un, set estensibile indeterminato di operatori che sono comprese da TFF, e compilato giù nel codice di livello inferiore.

    La maggior parte di questi operatori ha parametri e risultati di tipi federati e la maggior parte sono modelli che possono essere applicati a vari tipi di dati.

    Ad esempio, tff.federated_broadcast può essere pensato come un operatore modello di tipo funzionale T@SERVER -> T@CLIENTS .

  • Espressioni lambda ( tff.federated_computation ). Un'espressione lambda in TFF è l'equivalente di un lambda o def in Python; è costituito dal nome del parametro e da un corpo (espressione) che contiene riferimenti a questo parametro.

    Nel codice Python, questi possono essere generati da decorare funzioni Python con tff.federated_computation e definente un argomento.

    Ecco un esempio di un'espressione lambda che abbiamo già menzionato in precedenza:

    @tff.federated_computation(tff.type_at_clients(tf.float32))
    def get_average_temperature(sensor_readings):
      return tff.federated_mean(sensor_readings)
    
  • Letterali posizionamento. Per ora, solo tff.SERVER e tff.CLIENTS per consentire la definizione di semplici calcoli client-server.

  • Invocazioni di funzione ( __call__ ). Tutto ciò che ha un tipo funzionale può essere richiamato utilizzando lo standard di Python __call__ sintassi. L'invocazione è un'espressione, il cui tipo è lo stesso del tipo del risultato della funzione invocata.

    Per esempio:

    • add_up_integers(x) rappresenta un'invocazione del calcolo tensorflow definito in precedenza su un argomento x . Il tipo di questa espressione è int32 .

    • tff.federated_mean(sensor_readings) rappresenta un'invocazione dell'operatore media federata su sensor_readings . Il tipo di questa espressione è float32@SERVER (supponendo contesto dall'esempio precedente).

  • Formando tuple e selezionando i loro elementi. Espressioni pitone della forma [x, y] , x[y] , o xy che appaiono nei corpi di funzioni decorati con tff.federated_computation .