Auf dieser Seite wird beschrieben, wie Sie mit den Federated Learning APIs von On-Device Personalization ein Modell mit einem Lernprozess mit föderiertem Durchschnitt und festem Gaußschen Rauschen trainieren.
Hinweis
Führen Sie vor dem Start die folgenden Schritte auf Ihrem Testgerät aus:
Prüfen Sie, ob das Modul „OnDevicePersonalization“ installiert ist. Das Modul wurde im April 2024 als automatisches Update verfügbar.
# List the modules installed on the device adb shell pm list packages --apex-only --show-versioncodePrüfen Sie, ob das folgende Modul mit dem Versionscode 341717000 oder höher aufgeführt ist:
package:com.google.android.ondevicepersonalization versionCode:341717000Wenn das Modul nicht aufgeführt ist, rufen Sie Einstellungen > Sicherheit & Datenschutz > Updates > Google Play-Systemupdate auf, um zu prüfen, ob Ihr Gerät auf dem neuesten Stand ist. Wählen Sie bei Bedarf Aktualisieren aus.
Alle neuen Funktionen für Federated Learning aktivieren.
# Enable On-Device Personalization apk. adb shell device_config put on_device_personalization global_kill_switch false # Enable On-Device Personalization APIs. adb shell device_config put on_device_personalization enable_ondevicepersonalization_apis true # Enable On-Device Personalization overriding. adb shell device_config put on_device_personalization enable_personalization_status_override true adb shell device_config put on_device_personalization personalization_status_override_value true # Enable Federated Compute apk. adb shell device_config put on_device_personalization federated_compute_kill_switch false
Aufgabe für föderiertes Lernen erstellen
Die Zahlen im Diagramm werden in den folgenden acht Schritten genauer erläutert.
Federated Compute-Server konfigurieren
Föderiertes Lernen ist ein MapReduce-Prozess, der auf dem Federated Compute Server (dem Reducer) und einer Reihe von Clients (den Mappern) ausgeführt wird. Auf dem Federated Compute-Server werden die laufenden Metadaten und Modellinformationen jeder Aufgabe für föderiertes Lernen gespeichert. Auf oberster Ebene:
- Ein Entwickler für föderiertes Lernen erstellt eine neue Aufgabe und lädt sowohl Metadaten zur Ausführung der Aufgabe als auch Modellinformationen auf den Server hoch.
- Wenn ein Federated Compute-Client eine neue Anfrage zur Aufgabenzuweisung an den Server sendet, prüft der Server, ob die Aufgabe infrage kommt, und gibt Informationen zu infrage kommenden Aufgaben zurück.
- Sobald ein Federated Compute-Client die lokalen Berechnungen abgeschlossen hat, sendet er die Berechnungsergebnisse an den Server. Der Server führt dann die Aggregation und das Hinzufügen von Rauschen für diese Berechnungsergebnisse durch und wendet das Ergebnis auf das endgültige Modell an.
Weitere Informationen zu diesen Konzepten finden Sie hier:
- Föderiertes Lernen: Kollaboratives maschinelles Lernen ohne zentrale Trainingsdaten
- Towards Federated Learning at Scale: System Design (SysML 2019)
Bei ODP wird eine erweiterte Version von Federated Learning verwendet, bei der den Aggregaten kalibrierter (zentralisierter) Rauschen hinzugefügt wird, bevor sie auf das Modell angewendet werden. Das Ausmaß des Rauschens sorgt dafür, dass die Aggregate Differential Privacy wahren.
Schritt 1: Föderierten Compute-Server erstellen
Folgen Sie der Anleitung im Projekt für Federated Compute, um einen eigenen Federated Compute-Server einzurichten.
Schritt 2: Gespeichertes FunctionalModel vorbereiten
Bereiten Sie eine gespeicherte FunctionalModel-Datei vor. Sie können 'functional_model_from_keras' verwenden, um ein 'Model' in ein 'FunctionalModel' zu konvertieren, und 'save_functional_model', um dieses 'FunctionalModel' als 'SavedModel' zu serialisieren.
functional_model = tff.learning.models.functional_model_from_keras(keras_model=model)
tff.learning.models.save_functional_model(functional_model, saved_model_path)
Schritt 3: Federated Compute Server-Konfiguration erstellen
Erstellen Sie ein fcp_server_config.json mit Richtlinien, der Einrichtung von föderiertem Lernen und der Einrichtung von Differential Privacy. Beispiel:
# Identifies the set of client devices that will participate.
population_name: "my_new_population"
# Options you can choose:
# * TRAINING_ONLY: Only one training task will be generated under this
# population.
# * TRAINING_AND_EVAL: One training task and one evaluation task will be
# generated under this population.
# * EVAL_ONLY: Only one evaluation task will be generated under this
# population.
mode: TRAINING_AND_EVAL
policies {
# Policy for sampling on-device examples. It is checked every time a
# device attempts to start a new training.
min_separation_policy {
# The minimum number of rounds before the same client participated.
minimum_separation: 3
}
# Policy for releasing training results to developers. It is checked
# when uploading a new task to the Federated Compute Server.
model_release_policy {
# Server stops training when number of training rounds reaches this
# number.
num_max_training_rounds: 1000
}
}
# Federated learning setups. They are applied inside Task Builder.
federated_learning {
learning_process {
# Use FED_AVG to build federated learning process. Options you can
# choose:
# * FED_AVG: Federated Averaging algorithm
# (https://arxiv.org/abs/2003.00295)
# * FED_SDG: Federated SGD algorithm
# (https://arxiv.org/abs/1602.05629)
type: FED_AVG
# Optimizer used at client side training. Options you can choose:
# * ADAM
# * SGD
client_optimizer: SGD
# Learning rate used at client side training.
client_learning_rate: 0.01
# Optimizer used at server side training. Options you can choose:
# * ADAM
# * SGD
server_optimizer: ADAM
# Learning rate used at server side training.
sever_learning_rate: 1
runtime_config {
# Number of participating devices for each round of training.
report_goal: 2000
}
# List of metrics to be evaluated by the model during training and
# evaluation. Federated Compute Server provides a list of allowed
# metrics.
metrics {
name: "auc-roc"
}
metrics {
name: "binary_accuracy"
}
}
# Whether or not to generate a corresponding evaluation task under the same
# population. If this field isn't set, only one training task is
# generated under this population.
evaluation {
# The task id under the same population of the source training task that
# this evaluation task evaluates.
source_training_task_id: 1
# Decides how checkpoints from the training task are chosen for
# evaluation.
# * every_k_round: the evaluation task randomly picks one checkpoint
# from the past k rounds of training task checkpoints.
# * every_k_hour: the evaluation task randomly picks one checkpoint
# from the past k hours of training task checkpoints.
checkpoint_selector: "every_1_round"
# The traffic of this evaluation task in this population.
evaluation_traffic: 0.1
# Number of participating devices for each round of evaluation.
report_goal: 200
}
}
# Differential Privacy setups. They are applied inside the Task Builder.
differential_privacy {
# The DP aggregation algorithm you want to use. Options you can choose:
# * FIXED_GAUSSIAN: Federated Learning DP-SGD with fixed clipping norm
# described in "Learning Differentially Private Recurrent
# Language Models" (https://arxiv.org/abs/1710.06963).
# * ADAPTIVE_GAUSSIAN: Federated Learning DP-SGD with quantile-based clip
# norm estimation described in "Differentially Private
# Learning with Adaptive Clipping"
# (https://arxiv.org/abs/1905.03871).
# * TREE: DP-FTRL algorithm described in "Practical and Private (Deep)
# Learning without Sampling or Shuffling"
# (https://arxiv.org/abs/2103.00039).
# * ADADPTIVE_TREE: DP-FTRL with adaptive clipping norm descirbed in
# "Differentially Private Learning with Adaptive Clipping"
# (https://arxiv.org/abs/1905.03871).
type: FIXED_GAUSSIAN
# Noise multiplier for the Gaussian noise.
noise_multiplier: 0.1
# The value of the clipping norm.
clip_norm: 0.1
}
Schritt 4: Senden Sie die ZIP-Konfiguration an den Federated Compute-Server.
Senden Sie die ZIP-Datei und fcp_server_config.json an den Federated Compute-Server.
task_builder_client --task_builder_server='http://{federated_compute_server_endpoint}' --saved_model='saved_model' --task_config='fcp_server_config.json'
Der Federated Compute Server-Endpunkt ist der Server, den Sie in Schritt 1 eingerichtet haben.
Die integrierte LiteRT-Operatorbibliothek unterstützt nur eine begrenzte Anzahl von TensorFlow-Operatoren (siehe „TensorFlow-Operatoren auswählen“). Die unterstützten Operatoren können je nach Version des OnDevicePersonalization-Moduls variieren. Um die Kompatibilität zu gewährleisten, wird während der Aufgabenerstellung im Task Builder eine Operatorüberprüfung durchgeführt.
Die mindestens unterstützte Version des OnDevicePersonalization-Moduls ist in den Metadaten der Aufgabe enthalten. Diese Informationen finden Sie in der Infomeldung des Task-Builders.
I1023 22:16:53.058027 139653371516736 task_builder_client.py:109] Success! Tasks are built, and artifacts are uploaded to the cloud. I1023 22:16:53.058399 139653371516736 task_builder_client.py:112] applied_algorithms { learning_algo: FED_AVG client_optimizer: SGD server_optimizer: SGD dp_aggregator: FIXED_GAUSSIAN } metric_results { accepted_metrics: "binary_accuracy, binary_crossentropy, recall, precision, auc-roc, auc-pr" } dp_hyperparameters { dp_delta: 0.000001 dp_epsilon: 6.4 noise_multiplier: 1.0 dp_clip_norm: 1.0 num_training_rounds: 10000 } I1023 22:16:53.058594 139653371516736 task_builder_client.py:113] training_task { min_client_version: "341912000" } eval_task { min_client_version: "341812000" }Der Federated Compute-Server weist diese Aufgabe allen Geräten zu, die mit einem OnDevicePersonalization-Modul mit einer Version höher als 341812000 ausgestattet sind.
Wenn Ihr Modell Vorgänge enthält, die von keinem OnDevicePersonalization-Modul unterstützt werden, wird bei der Aufgabenerstellung eine Fehlermeldung generiert.
common.TaskBuilderException: Cannot build the ClientOnlyPlan: Please contact Google to register these ops: {'L2Loss': 'L2LossOp<CPUDevice, float>'} . Stop building remaining artifacts.Eine detaillierte Liste der unterstützten flexiblen Vorgänge finden Sie auf GitHub.
Android-APK für föderierte Berechnungen erstellen
Wenn Sie eine APK für Android Federated Compute erstellen möchten, müssen Sie in Ihrer AndroidManifest.xml den URL-Endpunkt des Federated Compute-Servers angeben, mit dem sich Ihr Federated Compute-Client verbindet.
Schritt 5: URL-Endpunkt des Federated Compute-Servers angeben
Geben Sie die URL des Federated Compute-Serverendpunkts (die Sie in Schritt 1 eingerichtet haben) in Ihrem AndroidManifest.xml an, mit dem sich Ihr Federated Compute-Client verbindet.
<!-- Contents of AndroidManifest.xml -->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.odpsample" >
<application android:label="OdpSample">
<!-- XML resource that contains other ODP settings. -->
<property android:name="android.ondevicepersonalization.ON_DEVICE_PERSONALIZATION_CONFIG"
android:resource="@xml/OdpSettings"></property>
<!-- The service that ODP will bind to. -->
<service android:name="com.example.odpsample.SampleService"
android:exported="true" android:isolatedProcess="true" />
</application>
</manifest>
In der im <property>-Tag angegebenen XML-Ressourcendatei muss die Dienstklasse auch in einem <service>-Tag deklariert werden. Außerdem muss der URL-Endpunkt des Federated Compute-Servers angegeben werden, mit dem sich der Federated Compute-Client verbinden soll:
<!-- Contents of res/xml/OdpSettings.xml -->
<on-device-personalization>
<!-- Name of the service subclass -->
<service name="com.example.odpsample.SampleService">
<!-- If you want to use federated compute feature to train a model,
specify this tag. -->
<federated-compute-settings url="https://fcpserver.com/" />
</service>
</on-device-personalization>
Schritt 6: IsolatedWorker#onTrainingExample API implementieren
Implementieren Sie die öffentliche API für die On-Device-Personalisierung IsolatedWorker#onTrainingExample, um Trainingsdaten zu generieren.
Code, der in der IsolatedProcess ausgeführt wird, hat keinen direkten Zugriff auf das Netzwerk, lokale Festplatten oder andere Dienste, die auf dem Gerät ausgeführt werden. Die folgenden APIs sind jedoch verfügbar:
- getRemoteData: Unveränderliche Schlüssel/Wert-Daten, die gegebenenfalls von Remote-Backends heruntergeladen werden, die vom Entwickler betrieben werden.
- getLocalData: Änderbare Schlüssel/Wert-Daten, die von Entwicklern lokal gespeichert werden, sofern zutreffend.
- UserData: Nutzerdaten, die von der Plattform bereitgestellt werden.
- 'getLogReader': Gibt ein DAO für die Tabellen REQUESTS und EVENTS zurück.
Beispiel:
@Override public void onTrainingExample(
@NonNull TrainingExampleInput input,
@NonNull Consumer<TrainingExampleOutput> consumer) {
// Check if the incoming training task is the task we want.
if (input.getPopulationName() == "my_new_population") {
TrainingExampleOutput result = new TrainingExampleOutput.Builder():
RequestLogRecord record = this.getLogReader().getRequestLogRecord(1);
int count = 1;
// Iterate logging event table.
for (ContentValues contentValues: record.rows()) {
Features features = Features.newBuilder()
// Retrieve carrier from user info.
.putFeature("carrier", buildFeature(mUserData.getCarrier()))
// Retrieve features from logging info.
.putFeature("int_feature_1",
buildFeature(contentValues.get("int_feature_1")
result.addTrainingExample(
Example.newBuilder()
.setFeatures(features).build().toByteArray())
.addResumptionToken(
String.format("token%d", count).getBytes()))
.build();
count++;
}
consumer.accept(result.build());
}
}
Schritt 7: Wiederkehrende Trainingsaufgabe planen
Die On-Device-Personalisierung bietet eine FederatedComputeScheduler für Entwickler, um föderierte Berechnungsjobs zu planen oder abzubrechen. Es gibt verschiedene Möglichkeiten, sie über IsolatedWorker aufzurufen, entweder nach einem Zeitplan oder wenn ein asynchroner Download abgeschlossen ist. Nachfolgend finden Sie Beispiele für beide.
Zeitplanbasierte Option Rufen Sie
FederatedComputeScheduler#scheduleinIsolatedWorker#onExecutean.@Override public void onExecute( @NonNull ExecuteInput input, @NonNull Consumer<ExecuteOutput> consumer ) { if (input != null && input.getAppParams() != null && input.getAppParams().getString("schedule_training") != null) { if (input.getAppParams().getString("schedule_training").isEmpty()) { consumer.accept(null); return; } TrainingInterval interval = new TrainingInterval.Builder() .setMinimumInterval(Duration.ofSeconds(10)) .setSchedulingMode(2) .build(); FederatedComputeScheduler.Params params = new FederatedComputeScheduler .Params(interval); FederatedComputeInput fcInput = new FederatedComputeInput.Builder() .setPopulationName( input.getAppParams().getString("schedule_training")).build(); mFCScheduler.schedule(params, fcInput); ExecuteOutput result = new ExecuteOutput.Builder().build(); consumer.accept(result); } }Option „Download abgeschlossen“ Rufen Sie
FederatedComputeScheduler#scheduleinIsolatedWorker#onDownloadCompletedauf, wenn die Planung einer Trainingsaufgabe von asynchronen Daten oder Prozessen abhängt.
Validierung
In den folgenden Schritten wird beschrieben, wie Sie prüfen, ob der Federated Learning-Vorgang ordnungsgemäß ausgeführt wird.
Schritt 8: Prüfen Sie, ob die Federated Learning-Aufgabe ordnungsgemäß ausgeführt wird.
Bei jeder Runde der serverseitigen Aggregation werden ein neuer Modell-Checkpoint und eine neue Messwertdatei generiert.
Die Messwerte befinden sich in einer JSON-formatierten Datei mit Schlüssel/Wert-Paaren. Die Datei wird anhand der Liste der Metrics generiert, die Sie in Schritt 3 definiert haben. Ein Beispiel für eine JSON-Datei mit repräsentativen Messwerten:
{"server/client_work/train/binary_accuracy":0.5384615659713745, "server/client_work/train/binary_crossentropy":0.694046676158905, "server/client_work/train/recall":0.20000000298023224, "server/client_work/train/precision":0.3333333432674408, "server/client_work/train/auc-roc":0.3500000238418579, "server/client_work/train/auc-pr":0.44386863708496094, "server/finalizer/update_non_finite":0.0}
Sie können ein ähnliches Skript wie das folgende verwenden, um Modellmesswerte abzurufen und die Trainingsleistung zu überwachen:
import collections
import json
import matplotlib.pyplot as plt
from google.cloud import storage
# The population_name you set in fcp_server_config.json in Step 3.
POPULATION_NAME = 'my_new_population'
# The Google Cloud storage you set in Step 1.
GCS_BUCKET_NAME = 'fcp-gcs'
NUM_TRAINING_ROUND = 1000
storage_client = storage.Client()
bucket = storage_client.bucket(GCS_BUCKET_NAME)
metrics = collections.defaultdict(list)
for i in range(NUM_TRAINING_ROUND):
blob = bucket.blob('{}/{}/1/{}/s/0/metrics'.format(GCS_BUCKET_NAME, POPULATION_NAME, i+1))
with blob.open("r") as f:
metric = json.loads(f.read())
for metric_name in metric.keys():
metrics[metric_name].append(metric[metric_name])
for metric_name in metrics:
print(metric_name)
plt.plot(metrics[metric_name])
plt.show()
Beachten Sie im vorherigen Beispieldiagramm Folgendes:
- Die x-Achse gibt die Anzahl der Trainingsrunden an.
- Die y-Achse ist der Wert von „auc-roc“ für jede Runde.
Bildklassifizierungsmodell für die Personalisierung auf dem Gerät trainieren
In dieser Anleitung wird das EMNIST-Dataset verwendet, um zu veranschaulichen, wie ein Federated Learning-Vorgang in ODP ausgeführt wird.
Schritt 1: tff.learning.models.FunctionalModel erstellen
def get_image_classification_input_spec():
return (
tf.TensorSpec([None, 28, 28, 1], tf.float32),
tf.TensorSpec([None, 1], tf.int64),
)
def create_and_save_image_classification_functional_model(
model_path: str,
) -> None:
keras_model = emnist_models.create_original_fedavg_cnn_model(
only_digits=True
)
functional_model = tff.learning.models.functional_model_from_keras(
keras_model=keras_model,
input_spec=get_image_classification_input_spec(),
loss_fn=tf.keras.losses.SparseCategoricalCrossentropy(),
)
tff.learning.models.save_functional_model(functional_model, model_path)
- Details zum EMNIST-Keras-Modell finden Sie unter emnist_models.
- TfLite bietet noch keine gute Unterstützung für tf.sparse.SparseTensor oder tf.RaggedTensor. Verwenden Sie beim Erstellen des Modells möglichst oft tf.Tensor.
- Der ODP Task Builder überschreibt alle Messwerte beim Erstellen des Lernprozesses. Sie müssen also keine Messwerte angeben. Dieses Thema wird in Schritt 2 ausführlicher behandelt. Erstellen Sie die Konfiguration für den Task Builder.
Es werden zwei Arten von Modelleingaben unterstützt:
Typ 1 Ein Tupel(features_tensor, label_tensor).
- Beim Erstellen des Modells sieht input_spec so aus:
def get_input_spec(): return ( tf.TensorSpec([None, 28, 28, 1], tf.float32), tf.TensorSpec([None, 1], tf.int64), )- Kombinieren Sie das oben Genannte mit der folgenden Implementierung der öffentlichen ODP-API IsolatedWorker#onTrainingExamples, um Trainingsdaten auf dem Gerät zu generieren:
return tf.train.Example( features=tf.train.Features( feature={ 'x': tf.train.Feature( float_list=tf.train.FloatList(value=[1.0] * 784) ), 'y': tf.train.Feature( int64_list=tf.train.Int64List( value=[1] ) ), } ) ).SerializeToString()Typ 2 Ein
Tuple(Dict[feature_name, feature_tensor], label_tensor)- Beim Erstellen des Modells sieht input_spec so aus:
def get_input_spec() -> ( Tuple[collections.OrderedDict[str, tf.TensorSpec], tf.TensorSpec] ): return ( collections.OrderedDict( [('feature-1', tf.TensorSpec([None, 1], tf.float32)), ('feature-2', tf.TensorSpec([None, 1], tf.float32))] ), tf.TensorSpec([None, 1], tf.int64), )- Kombinieren Sie das oben Genannte mit der folgenden Implementierung der öffentlichen ODP-API IsolatedWorker#onTrainingExamples, um Trainingsdaten zu generieren:
return tf.train.Example( features=tf.train.Features( feature={ 'feature-1': tf.train.Feature( float_list=tf.train.FloatList(value=[1.0]) ), 'feature-2': tf.train.Feature( float_list=tf.train.FloatList(value=[2.0]) ), 'my_label': tf.train.Feature( int64_list=tf.train.Int64List( value=[1] ) ), } ) ).SerializeToString()- Vergessen Sie nicht, den label_name in der Konfiguration des Task-Builders zu registrieren.
mode: TRAINING_AND_EVAL # Task execution mode population_name: "my_example_model" label_name: "my_label"
ODP verarbeitet DP automatisch beim Erstellen des Lernprozesses. Daher ist es nicht erforderlich, beim Erstellen des funktionalen Modells Rauschen hinzuzufügen.
Die Ausgabe dieses gespeicherten funktionalen Modells sollte dem Beispiel in unserem GitHub-Repository entsprechen.
Schritt 2: Konfiguration für den Aufgaben-Builder erstellen
Beispiele für die Konfiguration des Task Builders finden Sie in unserem GitHub-Repository.
Messwerte für Training und Bewertung
Da Messwerte Nutzerdaten enthalten können, wird im Task Builder eine Liste der Messwerte angezeigt, die im Lernprozess generiert und freigegeben werden können. Die vollständige Liste finden Sie in unserem GitHub-Repository.
Hier sehen Sie ein Beispiel für eine Messwertliste beim Erstellen einer neuen Konfiguration für den Task Builder:
federated_learning { learning_process { metrics { name: "binary_accuracy" } metrics { name: "binary_crossentropy" } metrics { name: "recall" } metrics { name: "precision" } metrics { name: "auc-roc" } metrics { name: "auc-pr" } } }
Wenn die gewünschten Messwerte nicht in der Liste enthalten sind, kontaktieren Sie uns.
DP-Konfigurationen
Es gibt einige DP-bezogene Konfigurationen, die angegeben werden müssen:
policies { min_separation_policy { minimum_separation: 1 } model_release_policy { num_max_training_rounds: 1000 dp_target_epsilon: 10 dp_delta: 0.000001 } } differential_privacy { type: FIXED_GAUSSIAN clip_norm: 0.1 noise_multiplier: 0.1 }- Entweder
dp_target_epsilonodernoise_mulitipilerist vorhanden, um die Validierung zu bestehen: (noise_to_epsilonepislon_to_noise). - Diese Standardeinstellungen finden Sie in unserem GitHub-Repository.
- Entweder
Schritt 3: Gespeichertes Modell und Task Builder-Konfiguration in den Cloud-Speicher eines beliebigen Entwicklers hochladen
Denken Sie daran, die Felder artifact_building zu aktualisieren, wenn Sie die Task Builder-Konfiguration hochladen.
Schritt 4: Optional: Artefakt erstellen, ohne eine neue Aufgabe zu erstellen
cd ${odp_fcp_github_repo}/python
bazel run //python/taskbuilder:task_builder_client -- --saved_model=${path_of_cloud_storage}/mnist_model/ --task_config=${path_of_cloud_storage}/mnist_cnn_task_config_build_artifact_only.pbtxt --build_artifact_only=true --task_builder_server=${task_builder_server_endpoint}
Das Beispielmodell wird sowohl über die Flex-Ops-Prüfung als auch über die DP-Prüfung validiert. Sie können skip_flex_ops_check und skip_dp_check hinzufügen, um die Validierung zu umgehen. Dieses Modell kann aufgrund einiger fehlender Flex-Ops nicht in der aktuellen Version des ODP-Clients bereitgestellt werden.
cd ${odp_fcp_github_repo}/python
bazel run //python/taskbuilder:task_builder_client -- --saved_model=${path_of_cloud_storage}/mnist_model/ --task_config=${path_of_cloud_storage}/mnist_cnn_task_config_build_artifact_only.pbtxt --build_artifact_only=true --task_builder_server=${task_builder_server_endpoint} --skip_flex_ops_check=True --skip_dp_check=True
flex_ops_check: Die integrierte TensorFlow Lite-Operatorbibliothek unterstützt nur eine begrenzte Anzahl von TensorFlow-Operatoren (TensorFlow Lite- und TensorFlow-Operatorkompatibilität). Alle inkompatiblen TensorFlow-Operationen müssen mit dem Flex-Delegate (Android.bp) installiert werden. Wenn ein Modell nicht unterstützte Vorgänge enthält, wenden Sie sich an uns, um sie zu registrieren:
Cannot build the ClientOnlyPlan: Please contact Google to register these ops: {...}Am besten debuggen Sie einen Task Builder, indem Sie ihn lokal starten:
# Starts a server at localhost:5000 bazel run //python/taskbuilder:task_builder # Links to a server at localhost:5000 by removing task_builder_server flag bazel run //python/taskbuilder:task_builder_client -- --saved_model=${path_of_cloud_storage}/mnist_model/ --task_config=${path_of_cloud_storage}/mnist_cnn_task_config_build_artifact_only.pbtxt --build_artifact_only=true --skip_flex_ops_check=True --skip_dp_check=True
Die resultierenden Artefakte finden Sie im Cloud Storage-Speicherort, der in der Konfiguration angegeben ist. Es sollte in etwa so aussehen wie das Beispiel in unserem GitHub-Repository.
Schritt 5: Erstellen Sie Artefakte und ein neues Paar von Trainings- und Auswertungsaufgaben auf dem FCP-Server.
Entfernen Sie das Flag build_artifact_only. Die erstellten Artefakte werden dann auf den FCP-Server hochgeladen. Prüfen Sie, ob ein Paar von Trainings- und Evaluierungsaufgaben erfolgreich erstellt wurde.
cd ${odp_fcp_github_repo}/python
bazel run //python/taskbuilder:task_builder_client -- --saved_model=${path_of_cloud_storage}/mnist_model/ --task_config=${path_of_cloud_storage}/mnist_cnn_task_config.pbtxt --task_builder_server=${task_builder_server_endpoint}
Schritt 6: Clientseitige Vorbereitung für FCP
- Implementieren Sie die öffentliche ODP-API
IsolatedWorker#onTrainingExamples, um Trainingsdaten zu generieren. - Rufen Sie
FederatedComputeScheduler#scheduleauf. - Einige Beispiele finden Sie in unserem Android-Quellcode-Repository.
Schritt 7: Monitoring
Servermesswerte
Einrichtungsanleitung in unserem GitHub-Repository
- Modellmesswerte
Es ist möglich, Messwerte aus verschiedenen Läufen in einem Diagramm zu vergleichen. Beispiel:
- Die lila Linie entspricht
noise_multiplier0,1. - Die rosa Linie entspricht
noise_multipiler= 0,3.