Verbundenes Lernen

Überblick

In diesem Dokument werden Schnittstellen vorgestellt, die föderierte Lernaufgaben erleichtern, z. B. föderierte Schulungen oder Bewertungen mit vorhandenen in TensorFlow implementierten Modellen für maschinelles Lernen. Bei der Gestaltung dieser Schnittstellen war es unser primäres Ziel, das Experimentieren mit föderiertem Lernen zu ermöglichen, ohne dass Kenntnisse über die Funktionsweise unter der Haube erforderlich sind, und die implementierten föderierten Lernalgorithmen an einer Vielzahl bestehender Modelle und Daten zu evaluieren. Wir empfehlen Ihnen, einen Beitrag zur Plattform zu leisten. TFF wurde im Hinblick auf Erweiterbarkeit und Zusammensetzbarkeit entwickelt, und wir freuen uns über Beiträge; wir sind gespannt, was dir einfällt!

Die von dieser Schicht angebotenen Schnittstellen bestehen aus den folgenden drei wesentlichen Teilen:

  • Models. Klassen und Hilfsfunktionen, mit denen Sie Ihre vorhandenen Modelle für die Verwendung mit TFF umschließen können. Ein Modell Wrapping kann so einfach sein wie eine einzelne Wickelfunktion (zB Aufruf tff.learning.from_keras_model ) oder die Definition einer Unterklasse der tff.learning.Model Schnittstelle für volle Anpassbarkeit.

  • Federated Computation Builders. Hilfsfunktionen, die unter Verwendung Ihrer vorhandenen Modelle föderierte Berechnungen für das Training oder die Evaluierung erstellen.

  • Datensammlungen. Vorgefertigte Datensammlungen, die Sie in Python herunterladen und darauf zugreifen können, um sie bei der Simulation föderierter Lernszenarien zu verwenden. Obwohl föderiertes Lernen für die Verwendung mit dezentralisierten Daten konzipiert ist, die nicht einfach an einem zentralen Ort heruntergeladen werden können, ist es in der Forschungs- und Entwicklungsphase oft praktisch, erste Experimente mit Daten durchzuführen, die lokal heruntergeladen und manipuliert werden können, insbesondere für Entwickler, die möglicherweise neu im Ansatz.

Diese Schnittstellen sind in erster Linie in dem definierten tff.learning Namensraum, mit Ausnahme von Forschungsdatensätzen und anderen Simulationsbezogenen Funktionen , die in gruppiert wurden tff.simulation . Diese Schicht ist unter Verwendung niedrigeren Ebene - Schnittstellen von dem angebotenen Federated Kern (FC) , die auch eine Laufzeitumgebung zur Verfügung stellt.

Bevor Sie fortfahren, empfehlen wir , dass Sie zuerst die Tutorials auf eine Bewertung der Bildklassifikation und Textgenerierung , da sie die meisten Konzepte einzuführen hier beschriebenen konkreten Beispielen. Wenn Sie mehr darüber erfahren , interessiert sind , wie TFF funktioniert, können Sie die zu überfliegen benutzerdefinierte Algorithmen Tutorial als Einführung in die untergeordneten Schnittstellen verwenden wir die Logik der föderierten Berechnungen ausdrücken, und die vorhandene Implementierung der Studie tff.learning Schnittstellen.

Modelle

Architektonische Annahmen

Serialisierung

TFF zielt darauf ab, eine Vielzahl von verteilten Lernszenarien zu unterstützen, in denen der von Ihnen geschriebene Modellcode für maschinelles Lernen auf einer großen Anzahl heterogener Clients mit unterschiedlichen Fähigkeiten ausgeführt werden kann. Während diese Clients an einem Ende des Spektrums in einigen Anwendungen leistungsfähige Datenbankserver sein können, umfassen viele wichtige Anwendungen, die unsere Plattform unterstützen soll, mobile und eingebettete Geräte mit begrenzten Ressourcen. Wir können nicht davon ausgehen, dass diese Geräte Python-Laufzeiten hosten können; Wir können an dieser Stelle nur davon ausgehen, dass sie in der Lage sind, eine lokale TensorFlow-Laufzeit zu hosten. Daher ist eine grundlegende architektonische Annahme, die wir in TFF treffen, dass Ihr Modellcode als TensorFlow-Graphen serialisierbar sein muss.

Sie können (und sollten) Ihren TF-Code weiterhin nach den neuesten Best Practices entwickeln, z. B. mit dem Eager-Modus. Allerdings muss der endgültige Code sein serializable (zB kann als gewickelt werden tf.function für eifrige-Modus - Code). Dies stellt sicher , dass jeder Zustand oder Python Steuerung zur Ausführungszeit erforderlich fließen kann (mit Hilfe von möglicherweise serialisiert werden Autograph ).

Derzeit unterstützt TensorFlow das Serialisieren und Deserialisieren von TensorFlow im Eager-Modus nicht vollständig. Somit Serialisierung in TFF folgt derzeit das TF 1.0 - Muster, in dem alle Code muss in einen konstruiert werden tf.Graph dass TFF Kontrollen. Dies bedeutet, dass TFF derzeit kein bereits erstelltes Modell verbrauchen kann; Stattdessen Logik die Modelldefinition wird in einer nicht-Arg- Funktion verpackt ein , dass Rückkehr tff.learning.Model . Diese Funktion wird dann von TFF aufgerufen, um sicherzustellen, dass alle Komponenten des Modells serialisiert werden. Darüber hinaus ist eine stark typisierte Umgebung TFF wird ein wenig zusätzlichen Metadaten benötigen, wie zum Beispiel einer Angabe Ihres Eingabetypen des Modells.

Anhäufung

Wir meisten Anwender Konstrukt Modelle mit Keras finden Sie in den stark empfehlen Konverter für Keras Abschnitt weiter unten. Diese Wrapper verarbeiten die Aggregation von Modellaktualisierungen sowie alle für das Modell definierten Metriken automatisch. Allerdings kann es immer noch nützlich sein , um zu verstehen , wie die Aggregation für eine allgemeine Handhabung tff.learning.Model .

Beim föderierten Lernen gibt es immer mindestens zwei Aggregationsebenen: lokale geräteinterne Aggregation und geräteübergreifende (oder föderierte) Aggregation:

  • Lokale Aggregation. Diese Aggregationsebene bezieht sich auf die Aggregation über mehrere Batches von Beispielen, die einem einzelnen Kunden gehören. Dies gilt sowohl für die Modellparameter (Variablen), die sich sequentiell weiterentwickeln, wenn das Modell lokal trainiert wird, als auch für die von Ihnen berechneten Statistiken (wie durchschnittlicher Verlust, Genauigkeit und andere Metriken), die Ihr Modell wieder lokal aktualisiert während es über den lokalen Datenstrom jedes einzelnen Clients iteriert.

    Die Durchführung der Aggregation auf dieser Ebene liegt in der Verantwortung Ihres Modellcodes und wird mithilfe von TensorFlow-Standardkonstrukten erreicht.

    Die allgemeine Struktur der Verarbeitung sieht wie folgt aus:

    • Das Modell konstruiert ersten tf.Variable s zu halten , Aggregate, wie beispielsweise die Anzahl der Chargen , oder die Anzahl von Beispielen verarbeitet, wobei die Summe der pro-batch oder per-Beispiel Verlusten usw.

    • TFF ruft die forward_pass Methode auf Ihrem Model mehr Male nacheinander über nachfolgende Chargen von Kundendaten, die die Variablen halten verschiedene Aggregate als Nebeneffekt zu aktualisieren.

    • Schließlich ruft TFF die report_local_outputs Methode auf Ihrem Modell Ihr Modell zu erlauben , alle zusammenfassende Statistiken zu kompilieren es in einem kompakten Satz von Metriken gesammelt durch den Kunden exportiert werden. Hier kann Ihr Modellcode beispielsweise die Summe der Verluste durch die Anzahl der verarbeiteten Beispiele dividieren, um den durchschnittlichen Verlust zu exportieren usw.

  • Federated Aggregation. Diese Aggregationsebene bezieht sich auf die Aggregation über mehrere Mandanten (Geräte) im System. Dies gilt wiederum sowohl für die Modellparameter (Variablen), die über die Clients gemittelt werden, als auch für die Metriken, die Ihr Modell als Ergebnis der lokalen Aggregation exportiert.

    Die Durchführung der Aggregation auf dieser Ebene liegt in der Verantwortung von TFF. Als Modellersteller können Sie diesen Prozess jedoch steuern (mehr dazu weiter unten).

    Die allgemeine Struktur der Verarbeitung sieht wie folgt aus:

    • Das anfängliche Modell und alle für das Training erforderlichen Parameter werden von einem Server an eine Untergruppe von Clients verteilt, die an einer Trainings- oder Evaluierungsrunde teilnehmen.

    • Auf jedem Client wird Ihr Modellcode unabhängig und parallel wiederholt in einem Strom lokaler Datenbatches aufgerufen, um einen neuen Satz von Modellparametern (beim Training) und einen neuen Satz lokaler Metriken zu erzeugen, wie oben beschrieben (dies ist lokal). Anhäufung).

    • TFF führt ein verteiltes Aggregationsprotokoll aus, um die Modellparameter und lokal exportierten Metriken im gesamten System zu akkumulieren und zu aggregieren. Diese Logik wird in einer deklarativen Weise unter Verwendung von TFF eigener föderierten Berechnungssprache (nicht in TensorFlow) ausgedrückt, in dem Modell federated_output_computation. Sehen Sie sich die benutzerdefinierte Algorithmen für mehr auf die Aggregation API - Tutorial.

Abstrakte Schnittstellen

Diese grundlegende Konstruktor + Metadaten - Schnittstelle wird durch die Schnittstelle dargestellt tff.learning.Model , wie folgt:

  • Der Konstruktor, forward_pass und report_local_outputs Methoden sollten Modellvariablen, Vorwärtslauf, konstruieren und Statistiken , die Sie möchten Bericht entsprechend. Der mit diesen Methoden erstellte TensorFlow muss wie oben beschrieben serialisierbar sein.

  • Die input_spec Eigenschaft, sowie die drei Eigenschaften , die Rückkehr Teilmengen Ihrer trainierbar, nicht trainierbar und lokale Variablen stellen die Metadaten. TFF verwendet diese Informationen, um zu bestimmen, wie Teile Ihres Modells mit den föderierten Optimierungsalgorithmen verbunden werden, und um interne Typsignaturen zu definieren, um die Korrektheit des konstruierten Systems zu überprüfen (damit Ihr Modell nicht über Daten instanziiert werden kann, die nicht mit dem übereinstimmen das Modell ist auf Konsum ausgelegt).

Darüber hinaus ist die abstrakte Schnittstelle tff.learning.Model macht eine Eigenschaft federated_output_computation , die zusammen mit der report_local_outputs Eigenschaft bereits erwähnt, können Sie den Prozess der Aggregation zusammenfassende Statistiken steuern.

Sie können Beispiele finden , wie Sie eigene definieren tff.learning.Model im zweiten Teil unserer Bildklassifizierung Tutorial, sowie in den Beispielmodellen , die wir zum Testen in verwenden model_examples.py .

Konverter für Keras

Fast alle Informationen , die von TFF erforderlich ist kann durch den Aufruf abgeleitet werden tf.keras Schnittstellen, wenn Sie also ein Keras Modell haben, können Sie sich verlassen tff.learning.from_keras_model eine konstruieren tff.learning.Model .

Beachten Sie, dass TFF noch will , dass Sie einen Konstruktor zur Verfügung zu stellen - ein No-Argument Modellfunktion wie die folgenden:

def model_fn():
  keras_model = ...
  return tff.learning.from_keras_model(keras_model, sample_batch, loss=...)

Zusätzlich zum Modell selbst stellen Sie einen Beispieldatensatz bereit, den TFF verwendet, um den Typ und die Form der Eingabe Ihres Modells zu bestimmen. Dadurch wird sichergestellt, dass TFF das Modell für die Daten, die tatsächlich auf Clientgeräten vorhanden sind, richtig instanziieren kann (da wir davon ausgehen, dass diese Daten zum Zeitpunkt der Erstellung des zu serialisierenden TensorFlow nicht allgemein verfügbar sind).

Die Verwendung von Keras Wrapper wird in unserer dargestellten Bildklassifikation und Textgenerierung Tutorials.

Federated Computing Builder

Das tff.learning Paket bietet mehrere Builder für tff.Computation s , die durchführen Lernbezogene Aufgaben; wir gehen davon aus, dass sich die Menge solcher Berechnungen in Zukunft erweitern wird.

Architektonische Annahmen

Ausführung

Es gibt zwei verschiedene Phasen beim Ausführen einer föderierten Berechnung.

  • Compile: TFF kompiliert erste föderierte Lernalgorithmen in eine abstrakte serialisierte Darstellung des gesamten verteilten Berechnung. Dies ist der Zeitpunkt, an dem die TensorFlow-Serialisierung stattfindet, aber andere Transformationen können stattfinden, um eine effizientere Ausführung zu unterstützen. Wir verweisen auf die Darstellung serialisierten vom Compiler als föderierte Berechnung emittiert.

  • Führen TFF Möglichkeiten bietet , diese Berechnungen auszuführen. Derzeit wird die Ausführung nur über eine lokale Simulation (zB in einem Notebook mit simulierten dezentralen Daten) unterstützt.

Eine föderierte Berechnung erzeugt durch TFF des Federated Learning API, wie beispielsweise eine Trainingsalgorithmus, Verwendungen Federated Lungsmodell oder einer föderierten Bewertung, enthält eine Reihe von Elementen, insbesondere:

  • Eine serialisierte Form des Modells Code sowie zusätzliche TensorFlow Code durch das Framework Federated Learning aufgebaut Ihres Modells Ausbildung / Evaluation Schleife fahren (wie zB den Bau Optimizern Anwendung Modell - Updates, iterieren tf.data.Dataset s, und die Berechnung Metriken, und Anwenden des aggregierten Updates auf dem Server, um nur einige zu nennen).

  • Eine deklarative Spezifikation der Kommunikation zwischen den Clients und einem Server (typischerweise verschiedene Formen von Aggregation über die Client - Geräte, und an alle Clients vom Server Broadcasting), und wie diese verteilte Kommunikation mit der Client-lokalen oder server lokaler Ausführung verschachtelt des TensorFlow-Codes.

Die föderierte Berechnungen in dieser serialisierten Form dargestellt sind , in einer plattformunabhängigen internen Sprache unterscheidet sich von Python ausgedrückt, aber die Federated Learning - API zu verwenden, werden Sie nicht Sorge brauchen , um sich mit den Einzelheiten dieser Darstellung. Die Berechnungen werden in Ihrem Python - Code als Objekte vom Typ dargestellt tff.Computation , die zum größten Teil , den Sie als undurchsichtiger Python behandeln callable s.

In den Tutorials rufen Sie diese föderierten Berechnungen auf, als wären es reguläre Python-Funktionen, die lokal ausgeführt werden. Jedoch ist TFF entworfen föderierten Berechnungen in einer Weise , Agnostiker zu dem meisten Aspekten der Ausführungsumgebung zum Ausdruck bringen, so dass sie potentiell einsetzbaren sein können, zum Beispiel Gruppen von Geräten mit Android oder zu Clustern in einem Rechenzentrum. Die wichtigste Folge davon sind starke Annahmen über die Wieder - Serialisierung . Insbesondere dann , wenn rufen Sie eine der build_... Methoden unterhalb der Berechnung beschrieben wird vollständig serialisiert.

Modellierungsstatus

TFF ist eine funktionale Programmierumgebung, jedoch sind viele Prozesse, die für das föderierte Lernen von Interesse sind, zustandsbehaftet. Zum Beispiel kann eine Trainingsschleife , die mehrere Runden von föderierten Modellmittelung beinhaltet ist ein Beispiel dessen , was wir als Stateful Prozess klassifizieren könnte. In diesem Prozess umfasst der Zustand, der sich von Runde zu Runde entwickelt, den Satz von Modellparametern, die trainiert werden, und möglicherweise einen zusätzlichen Zustand, der dem Optimierer zugeordnet ist (z. B. einen Impulsvektor).

Da TFF funktional ist, werden zustandsbehaftete Prozesse in TFF als Berechnungen modelliert, die den aktuellen Zustand als Eingabe akzeptieren und dann den aktualisierten Zustand als Ausgabe bereitstellen. Um einen zustandsbehafteten Prozess vollständig zu definieren, muss man auch angeben, woher der Anfangszustand kommt (sonst können wir den Prozess nicht booten). Dies wird in der Definition der Hilfsklasse erfasst tff.templates.IterativeProcess , wobei die 2 Eigenschaften initialize und next entsprechend der Initialisierung und Iteration sind.

Verfügbare Builder

Im Moment bietet TFF zwei Builder-Funktionen, die die Verbundberechnungen für das Verbundtraining und die Auswertung generieren:

Datensätze

Architektonische Annahmen

Kundenauswahl

Im typischen Szenario Federated Lernen wir eine große Population von potenziell Hunderten von Millionen von Client - Geräten haben, von denen nur ein kleiner Teil kann für die Ausbildung zu einem bestimmten Zeitpunkt (zB aktiv und verfügbar sein, kann dies für die Kunden beschränkt, die an eine Stromquelle angeschlossen, nicht an ein gemessenes Netzwerk und ansonsten im Leerlauf). Im Allgemeinen liegt die Anzahl der Clients, die für die Teilnahme an Schulungen oder Evaluierungen zur Verfügung stehen, außerhalb der Kontrolle des Entwicklers. Ferner kann , wie es unpraktisch ist Millionen von Kunden zu koordinieren, eine typische Trainingsrunde oder die Bewertung nur einen Bruchteil der verfügbaren Clients umfassen, die werden zu beproben .

Die wichtigste Konsequenz daraus ist, dass föderierte Berechnungen konstruktionsbedingt auf eine Weise ausgedrückt werden, die die genaue Anzahl der Teilnehmer nicht kennt; die gesamte Verarbeitung wird als Aggregat Operationen auf einer abstrakten Gruppe von anonymen Kunden ausgedrückt, und diese Gruppe von einer Runde der Ausbildung zum anderen variieren können. Die tatsächliche Bindung der Berechnung an die konkreten Teilnehmer und damit an die konkreten Daten, die sie in die Berechnung einspeisen, wird somit außerhalb der Berechnung selbst modelliert.

Um eine realistische Bereitstellung Ihres föderierten Lerncodes zu simulieren, schreiben Sie im Allgemeinen eine Trainingsschleife, die wie folgt aussieht:

trainer = tff.learning.build_federated_averaging_process(...)
state = trainer.initialize()
federated_training_data = ...

def sample(federate_data):
  return ...

while True:
  data_for_this_round = sample(federated_training_data)
  state, metrics = trainer.next(state, data_for_this_round)

Um dies zu erleichtern, wenn TFF in Simulationen wird föderierten Daten als Python akzeptiert list s, mit einem Element pro teilnehmenden Client - Gerät des betreffenden Geräts lokal darstellen tf.data.Dataset .

Abstrakte Schnittstellen

Um mit simulierten Federated Datensätze zu standardisieren handelt, stellt eine abstrakte Schnittstelle TFF tff.simulation.datasets.ClientData , die man um den Satz von Clients ermöglicht aufzuzählen, und einen konstruieren tf.data.Dataset , die die Daten eines bestimmten enthält Klient. Diejenigen tf.data.Dataset s kann direkt als Eingabe in die erzeugten Federated Berechnungen in eifrigen Modus zugeführt werden.

Es sollte beachtet werden, dass die Möglichkeit, auf Client-Identitäten zuzugreifen, eine Funktion ist, die nur von den Datensätzen zur Verwendung in Simulationen bereitgestellt wird, bei denen die Möglichkeit zum Trainieren mit Daten von bestimmten Teilmengen von Clients erforderlich sein kann (z Kundentypen). Die kompilierten Berechnungen und die darunter liegende Laufzeit beinhalten keine Vorstellung von Client - Identität. Sobald die Daten aus einer bestimmten Untergruppe von Clients als Eingang ausgewählt wurden, beispielsweise in einem Aufruf von tff.templates.IterativeProcess.next , Client - Identitäten erscheinen nicht mehr drin.

Verfügbare Datensätze

Wir haben den Namensraum gewidmet tff.simulation.datasets für Datensätze , die die Implementierung tff.simulation.datasets.ClientData Schnittstelle zur Verwendung in Simulationen und ausgesät es mit zwei Datensätzen , die zur Unterstützung der Bildklassifikation und Textgenerierung Tutorials. Wir möchten Sie ermutigen, Ihre eigenen Datensätze zur Plattform beizutragen.