Föderierter Kern

Dieses Dokument stellt die Kernschicht aus TFF, die als Grundlage dient Federated Lernen , und mögliche zukünftige Nicht-Lernen föderierten Algorithmen.

Für eine sanfte Einführung in Federated Core lesen Sie bitte die folgenden Tutorials, da sie einige der grundlegenden Konzepte anhand von Beispielen vorstellen und Schritt für Schritt den Aufbau eines einfachen föderierten Mittelungsalgorithmus demonstrieren.

Wir würden empfehlen Ihnen , sich mit vertraut zu machen Federated Lernen und die damit verbundenen Tutorials auf Bildklassifikation und Textgenerierung , da die Verwendungen des Federated Core - API (FC API) für föderierte Lernen für einige wichtigen Kontext für die Entscheidungen , die wir gemacht haben in Gestaltung dieser Schicht.

Überblick

Ziele, Verwendungszwecke und Umfang

Federated Core (FC) wird am besten als Programmierumgebung zur Implementierung verteilter Berechnungen verstanden, dh Berechnungen, an denen mehrere Computer (Mobiltelefone, Tablets, eingebettete Geräte, Desktop-Computer, Sensoren, Datenbankserver usw.) beteiligt sind, die jeweils nicht- triviale Verarbeitung lokal und kommunizieren über das Netzwerk, um ihre Arbeit zu koordinieren.

Der Begriff verteilt ist sehr allgemein und TFF nicht alle möglichen Arten von verteilten Algorithmen Ziel gibt, so dass wir die weniger Gattungsbegriff föderierten Berechnung zu verwenden , bevorzugen die Arten von Algorithmen zu beschreiben , die in diesem Rahmen zum Ausdruck gebracht werden können.

Den Begriff föderierten Berechnung in einer vollständig formale Weise denken , ist außerhalb der Anwendungsbereich dieses Dokuments, um Sie über die Arten von Algorithmen ausgedrückt könnte sehe in Pseudo - Code in einer bei der Festlegung der Forschungsveröffentlichung , die beschreibt einen neuen verteilten Lernalgorithmus.

Das Ziel des FC, in einem nusthell, ist ähnlich kompakte Darstellung zu ermöglichen, zu einer ähnlichen Pseudoartigen Ebene der Abstraktion, der Programmlogik , die nicht Pseudo - Code, sondern vielmehr, dass in einer Vielzahl von Zielumgebungen ausführbar ist.

Das wichtigste definierende Merkmal der Arten von Algorithmen, die FC zum Ausdruck bringen soll, besteht darin, dass Aktionen von Systemteilnehmern in einer kollektiven Weise beschrieben werden. So neigen wir über jede Vorrichtung lokal transformierenden Daten, und die Vorrichtungen zu koordinieren Arbeit von einem zentralen Koordinator Rundfunk, Sammeln oder Aggregieren deren Ergebnisse zu sprechen.

Während TFF wurde über einfache Client-Server - Architekturen gehen zu können , entwickelt, ist der Begriff der kollektiven Verarbeitung von grundlegender Bedeutung. Dies liegt an den Ursprüngen von TFF im föderierten Lernen, einer Technologie, die ursprünglich entwickelt wurde, um Berechnungen von potenziell sensiblen Daten zu unterstützen, die unter der Kontrolle von Client-Geräten bleiben und die aus Datenschutzgründen nicht einfach an einen zentralen Ort heruntergeladen werden dürfen. Während jeder Kunde in solchen Systemen Daten und Verarbeitungsleistung dazu beiträgt, ein Ergebnis durch das System zu berechnen (ein Ergebnis, von dem wir im Allgemeinen erwarten, dass es für alle Teilnehmer von Wert ist), bemühen wir uns auch, die Privatsphäre und Anonymität jedes Kunden zu wahren.

Während also die meisten Frameworks für verteiltes Computing darauf ausgelegt sind, die Verarbeitung aus der Perspektive einzelner Teilnehmer auszudrücken – d , TFF des Federated Kern ist so konzipiert , das Verhalten des Systems aus der globalen systemweite Perspektive (ähnlich wie zB beschreibt MapReduce ).

Folglich während verteilte Rahmen für allgemeine Zwecke Operationen wie Sende bieten kann und erhalten als Bausteine, stellt FC Bausteine wie tff.federated_sum , tff.federated_reduce oder tff.federated_broadcast dass encapsulate einfache Protokolle verteilt.

Sprache

Python-Schnittstelle

TFF verwendet eine interne Sprache Federated Berechnungen darstellen, die Syntax der die durch die Darstellung in serializable definiert computation.proto . Benutzer der FC-API müssen jedoch im Allgemeinen nicht direkt mit dieser Sprache interagieren. Vielmehr stellen wir einen Python API (der tff - Namensraum) , dass wickelt es als Weg arounds Berechnungen zu definieren.

Insbesondere stellt TFF Funktion Dekorateure Python wie tff.federated_computation dass Spuren die Körper der eingerichteten Funktionen und erzeugen serialisiert Darstellungen der föderierten Berechnungslogik in der Sprache des TFF. Eine Funktion mit dekorierten tff.federated_computation fungiert als Träger solchen serialisierten Darstellung, und kann als ein Baustein in dem Körper eines anderen Rechens einbetten, oder auf Bedarf ausgeführt wird, wenn aufgerufen.

Hier ist nur ein Beispiel; Weitere Beispiele finden sich in den zu finden benutzerdefinierte Algorithmen Tutorials.

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

Leser vertraut mit nicht-eifrig TensorFlow werden diesen Ansatz analog finden Python - Code zu schreiben , dass Anwendungen Funktionen wie tf.add oder tf.reduce_sum in einem Abschnitt von Python - Code, der eine TensorFlow Diagramm definiert. Wenn auch der Code in Python technisch ausgedrückt wird, ist sein Zweck eine serializable Darstellung eines zu konstruieren tf.Graph darunter, und es ist die grafische Darstellung, nicht der Code , Python, die intern von der TensorFlow Laufzeit ausgeführt wird. Ebenso kann man sich vorstellen tff.federated_mean als Verbund op in einer föderierten Berechnung durch Einsetzen dargestellt get_average_temperature .

Ein Grund dafür, dass FC eine Sprache definiert, hat zum Teil mit der Tatsache zu tun, dass, wie oben erwähnt, föderierte Berechnungen verteiltes kollektives Verhalten spezifizieren und als solches ihre Logik nicht lokal ist. Zum Beispiel stellt TFF Operatoren bereit, deren Eingaben und Ausgaben an verschiedenen Stellen im Netzwerk vorhanden sein können.

Dies erfordert eine Sprache und ein Typensystem, die den Begriff der Verteiltheit erfassen.

Typensystem

Federated Core bietet die folgenden Kategorien von Typen. Bei der Beschreibung dieser Typen verweisen wir auf die Typkonstruktoren und führen eine kompakte Notation ein, da sie eine praktische Methode zur Beschreibung von Berechnungsarten und Operatoren ist.

Hier sind zunächst die Kategorien von Typen, die konzeptionell denen in bestehenden Mainstream-Sprachen ähnlich sind:

  • Tensor - Typen ( tff.TensorType ). So wie in TensorFlow, haben diese dtype und shape . Der einzige Unterschied ist , dass Objekte dieser Art sind nicht beschränkt auf tf.Tensor Instanzen in Python , die Ausgänge der TensorFlow ops in einem TensorFlow Graphen dar, sondern kann auch Einheiten von Daten , die erzeugt werden können, beispielsweise als eine Ausgabe eines verteilten Aggregationsprotokoll. Somit ist der TFF-Tensortyp einfach eine abstrakte Version einer konkreten physikalischen Darstellung eines solchen Typs in Python oder TensorFlow.

    Die kompakte Notation für Tensor - Typen ist dtype oder dtype[shape] . Zum Beispiel int32 und int32[10] sind die Arten von ganzen Zahlen und int - Vektoren, respectively.

  • Sequenztypen ( tff.SequenceType ). Dies sind TFF abstrakte Äquivalent TensorFlow des konkreten Konzept der tf.data.Dataset s. Elemente von Sequenzen können sequentiell konsumiert werden und können komplexe Typen umfassen.

    Die kompakte Darstellung der Sequenztypen ist T* , wobei T die Art des Elements ist. Zum Beispiel int32* eine ganze Zahl Sequenz.

  • Benannt Tupel - Typen ( tff.StructType ). Dies sind TFF Weg von Tupeln und Wörterbuch-ähnlichen Strukturen erstellt, die eine vorgegebene Anzahl von Elementen mit bestimmten Typen haben, mit dem Namen oder unbenannte. Wichtig ist, dass das Konzept der benannten Tupel von TFF das abstrakte Äquivalent zu den Argumenttupeln von Python umfasst, dh Sammlungen von Elementen, von denen einige, aber nicht alle, benannt sind und einige positionell sind.

    Die kompakte Notation für benannte Tupeln <n_1=T_1, ..., n_k=T_k> , wo n_k sind optional Elementnamen und T_k sind Elementtypen. Zum Beispiel <int32,int32> ist eine kompakte Notation für ein Paar unbenannte Zahlen und <X=float32,Y=float32> ist eine kompakte Notation für ein Paar Schwimmer namens X und Y , die einen Punkt auf einer Ebene darstellen . Tupeln mit anderen Arten sowie gemischten verschachtelt werden, zB <X=float32,Y=float32>* würde für eine Folge von Punkten eine kompakte Notation sein.

  • Funktionstypen ( tff.FunctionType ). TFF ist eine funktionale Programmierung Rahmen, mit Funktionen behandelt , als erstklassige Werte . Funktionen haben höchstens ein Argument und genau ein Ergebnis.

    Die kompakte Notation für Funktionen ist (T -> U) , wobei T die Art eines Arguments ist, und U ist die Art des Resultats, oder ( -> U) wenn es kein Argument (obwohl kein Argument Funktionen ein degeneriert sind Konzept, das meist nur auf Python-Ebene existiert). Zum Beispiel (int32* -> int32) ist eine Bezeichnung für eine Art von Funktionen , die eine Ganzzahl - Sequenz an einen einzelnen ganzzahligen Wert reduzieren.

Die folgenden Typen behandeln den Aspekt verteilter Systeme von TFF-Berechnungen. Da diese Begriffe etwas einzigartig TFF, empfehlen wir Ihnen , auf die Bezug zu nehmen benutzerdefinierte Algorithmen für zusätzliche Erläuterungen und Beispiele Tutorial.

  • Praktikumsart. Dieser Typ ist noch nicht in der Öffentlichkeit API andere als in Form von 2 Literale ausgesetzt tff.SERVER und tff.CLIENTS , dass Sie als Konstanten dieser Art denken. Es wird jedoch intern verwendet und wird in zukünftigen Versionen in der öffentlichen API eingeführt. Die kompakte Darstellung dieser Art ist die placement .

    Eine Platzierung repräsentiert ein Kollektiv von Systemteilnehmern , die eine besondere Rolle spielen. Die erste Version zielt auf Client-Server - Berechnungen, in denen es zwei Teilnehmergruppen: Kunden und einem Server (Sie können als Singleton Gruppe der letzteren denken). In ausgeklügelteren Architekturen könnten jedoch andere Rollen vorhanden sein, wie z die Kunden.

    Der primäre Zweck der Begriff der Platzierungen zu definieren , ist als Grundlage für föderierte Typen definieren.

  • Federated Typen ( tff.FederatedType ). Ein Wert eines föderierten Typ ist eine , die durch eine bestimmte Anordnung (wie definiert durch eine Gruppe von Systemteilnehmern gehostet wird tff.SERVER oder tff.CLIENTS ). Ein föderierte Typ wird durch die Platzierung Wert definiert (also es ist ein abhängiger Typ ), die Art des Mitglied Bestandteile (welche Art von Inhalt jeder der Teilnehmer lokal gehostet wird ) und das zusätzliche Bit all_equal , den angibt , ob alle Teilnehmer lokal Hosting des gleichen Artikels.

    Die kompakte Notation für föderierte Art von Werten , die Elemente (member Bestandteile) des Typs umfassen T , die jeweils von gehosteten Gruppe (Platzierung) G ist T@G oder {T}@G mit dem all_equal Bit gesetzt oder nicht gesetzt sind.

    Zum Beispiel:

    • {int32}@CLIENTS stellt einen Wert, der föderierte potentiell verschiedener ganze Zahlen aus einer Menge besteht, einen pro Client - Gerät. Beachten Sie, dass wir als umfasst mehrere Elemente der Daten über einen einzigen föderierten Wert sprechen , die an mehreren Standorten über das Netzwerk angezeigt werden . Eine Möglichkeit , darüber nachzudenken ist als eine Art Tensor mit einer „Netzwerk“ Dimension, obwohl diese Analogie nicht perfekt ist , weil TFF nicht erlaubt wahlfreien Zugriff auf Mitglied Bestandteile eines föderierten Wertes.

    • {<X=float32,Y=float32>*}@CLIENTS stellt eine föderierte Datensatz, einen Wert, der aus mehreren Sequenzen besteht XY - Koordinaten, eine Sequenz pro Client - Gerät.

    • <weights=float32[10,5],bias=float32[5]>@SERVER stellen ein benanntes Tupel von Gewicht und Voreingenommenheit Tensoren auf dem Server. Da wir die geschweiften Klammern fallen gelassen haben, zeigt dies das all_equal Bit gesetzt ist, das heißt, es gibt nur ein einziges Tupel (unabhängig davon , wie viele Server Repliken es in einem Cluster sein könnte diesen Wert - Hosting).

Bausteine

Die Sprache der Federated Core ist eine Form von lambda-Kalkül , mit einigen zusätzlichen Elementen.

Es bietet die folgenden Programmierabstraktionen, die derzeit in der öffentlichen API verfügbar sind:

  • TensorFlow Berechnungen ( tff.tf_computation ). Dies sind Abschnitte von TensorFlow Code eingewickelt als wiederverwendbare Komponenten in TFF mit dem tff.tf_computation Dekorateur. Sie haben immer funktionale Typen und können im Gegensatz zu Funktionen in TensorFlow strukturierte Parameter annehmen oder strukturierte Ergebnisse eines Sequenztyps zurückgeben.

    Hier ist ein Beispiel, ein TF Berechnung vom Typ (int32* -> int) , der die verwendet tf.data.Dataset.reduce Operator eine Summe von ganzen Zahlen zu berechnen:

    @tff.tf_computation(tff.SequenceType(tf.int32))
    def add_up_integers(x):
      return x.reduce(np.int32(0), lambda x, y: x + y)
    
  • Intrinsics oder föderierte Operatoren ( tff.federated_... ). Dies ist eine Bibliothek von Funktionen wie tff.federated_sum oder tff.federated_broadcast , die den Großteil des FC API bilden, von denen die meisten Kommunikationsbetreiber für die Verwendung mit TFF verteilt darzustellen.

    Wir bezeichnen diese als intrinsics da, ein wenig wie intrinsische Funktionen , sie sind ein offener, erweiterbarer Satz von Operatoren , die von TFF verstanden werden, und zusammengestellt nach unten in der unteren Ebene Code.

    Die meisten dieser Operatoren haben Parameter und Ergebnisse föderierter Typen, und die meisten sind Vorlagen, die auf verschiedene Arten von Daten angewendet werden können.

    Zum Beispiel tff.federated_broadcast kann als Vorlage Betreiber eines funktionellen Typs gedacht wird T@SERVER -> T@CLIENTS .

  • Lambda - Ausdrücke ( tff.federated_computation ). Ein Lambda - Ausdruck in TFF ist das Äquivalent eines lambda oder def in Python; es besteht aus dem Parameternamen und einem Hauptteil (Ausdruck), der Verweise auf diesen Parameter enthält.

    In Python - Code, kann diese durch die Dekoration Python - Funktionen mit erstellt werden tff.federated_computation und definieren ein Argument.

    Hier ist ein Beispiel für einen Lambda-Ausdruck, den wir bereits erwähnt haben:

    @tff.federated_computation(tff.type_at_clients(tf.float32))
    def get_average_temperature(sensor_readings):
      return tff.federated_mean(sensor_readings)
    
  • Placement - Literale. Vorerst nur tff.SERVER und tff.CLIENTS zur Definition von einfachen Client-Server - Berechnungen zu ermöglichen.

  • Funktionsaufrufe ( __call__ ). Alles , was einen Funktionstyp hat , kann unter Verwendung des Standard Python aufgerufen werden __call__ Syntax. Der Aufruf ist ein Ausdruck, dessen Typ dem Typ des Ergebnisses der aufgerufenen Funktion entspricht.

    Zum Beispiel:

    • add_up_integers(x) stellt einen Aufruf des Berechnungs TensorFlow früher auf einem Argument definierten x . Die Art dieses Ausdrucks ist int32 .

    • tff.federated_mean(sensor_readings) stellt einen Aufruf des föderierten Lungs Operator auf sensor_readings . Die Art dieses Ausdrucks ist float32@SERVER (unter der Annahme Kontext aus dem Beispiel oben).

  • Bilden Tupeln und deren Elemente ausgewählt wird . Python Ausdrücke der Form [x, y] , x[y] oder xy , die mit verziert in den Körpern der Funktionen erscheinen tff.federated_computation .