Diese Seite wurde von der Cloud Translation API übersetzt.

Job für föderiertes Lernen erstellen
Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Auf dieser Seite wird beschrieben, wie Sie die APIs für die föderierte Lerntechnologie von der On-Device-Personalisierung verwenden, um ein Modell mit einem föderierten Lernprozess mit gaussianischem Rauschen zu trainieren.

Hinweis

Führen Sie die folgenden Schritte auf Ihrem Testgerät aus:

Das Modul „OnDevicePersonalization“ muss installiert sein. Das Modul wurde im April 2024 als automatisches Update verfügbar gemacht.
```
# List the modules installed on the device
adb shell pm list packages --apex-only --show-versioncode
```
Das folgende Modul muss mit dem Versionscode 341717000 oder höher aufgeführt sein:

package:com.google.android.ondevicepersonalization versionCode:341717000

Wenn dieses Modul nicht aufgeführt ist, rufen Sie Einstellungen > Sicherheit und 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 im Zusammenhang mit föderiertem Lernen 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 Client-Server-Topologie für föderiertes Lernen mit acht hervorgehobenen Schritten. — Diagramm der Client-Server-Topologie für föderiertes Lernen mit acht hervorgehobenen Schritten.

Die Ziffern im Diagramm werden in den folgenden acht Schritten genauer erläutert.

Federated Compute-Server konfigurieren

Federated Learning ist ein Map-Reduce-Verfahren, das auf dem Federated Compute Server (dem Reducer) und einer Reihe von Clients (den Mappern) ausgeführt wird. Der Federated Compute-Server verwaltet die Metadaten und Modellinformationen der einzelnen föderierten Lernaufgaben. 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 die Eignung der Aufgabe und gibt Informationen zur berechtigten Aufgabe zurück.
Sobald ein Federated Compute-Client die lokalen Berechnungen abgeschlossen hat, sendet er die Ergebnisse an den Server. Der Server führt dann eine Aggregation und Rauschunterdrückung dieser Berechnungsergebnisse durch und wendet das Ergebnis auf das endgültige Modell an.

Weitere Informationen zu diesen Konzepten finden Sie unter:

ODP verwendet eine erweiterte Version des föderierten Lernens, bei der vor der Anwendung auf das Modell ein kalibrierter (zentralisierter) Rauschen auf die Aggregate angewendet wird. Durch das Ausmaß des Rauschens wird sichergestellt, dass die Aggregationen die Differential Privacy-Bedingungen erfüllen.

Schritt 1: Föderierten Compute-Server erstellen

Folgen Sie der Anleitung im Federated Compute-Projekt, um einen eigenen Federated Compute-Server einzurichten.

Schritt 2: Gespeichertes FunctionalModel vorbereiten

Bereiten Sie eine gespeicherte Datei vom Typ FunctionalModel vor. Mit 'functional_model_from_keras' können Sie ein 'Model' in ein 'FunctionalModel' konvertieren und mit 'save_functional_model' dieses 'FunctionalModel' als 'SavedModel' 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: Konfiguration für einen föderierten Compute-Server erstellen

Erstellen Sie eine fcp_server_config.json mit Richtlinien, der Einrichtung für föderiertes Lernen und der Einrichtung für 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: Reichen Sie die ZIP-Konfiguration beim Federated Compute-Server ein.

Reichen Sie die ZIP-Datei und fcp_server_config.json beim Federated Compute-Server ein.

task_builder_client --task_builder_server='http://{federated_compute_server_endpoint}' --saved_model='saved_model' --task_config='fcp_server_config.json'

Der Endpunkt des Federated Compute-Servers ist der Server, den Sie in Schritt 1 eingerichtet haben.

Die integrierte LiteRT-Operatorbibliothek unterstützt nur eine begrenzte Anzahl von TensorFlow-Operatoren (ausgewählte TensorFlow-Operatoren). Die unterstützten Betreiber können je nach Version des OnDevicePersonalization-Moduls variieren. Zur Gewährleistung der Kompatibilität wird beim Erstellen von Aufgaben im Aufgaben-Builder ein Vorgang zur Bestätigung des Betreibers durchgeführt.

Die Mindestversion des unterstützten OnDevicePersonalization-Moduls ist in den Aufgabenmetadaten enthalten. Diese Informationen finden Sie in der Informationsmeldung des Aufgabenerstellers.

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 beim Erstellen der Aufgabe 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 Flex-Ops findest du auf GitHub.

Android-APK für die verbundbasierte Datenverarbeitung erstellen

Wenn Sie ein Android Federated Compute-APK erstellen möchten, müssen Sie in Ihrer AndroidManifest.xml den URL-Endpunkt des Federated Compute-Servers angeben, mit dem Ihr Federated Compute-Client eine Verbindung herstellt.

Schritt 5: Federated Compute Server-URL-Endpunkt angeben

Geben Sie in Ihrer AndroidManifest.xml den URL-Endpunkt des Federated Compute-Servers an, den Sie in Schritt 1 eingerichtet haben und 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>

Die im <property>-Tag angegebene XML-Ressourcendatei muss auch die Dienstklasse in einem <service>-Tag deklarieren und den URL-Endpunkt des Federated Compute-Servers angeben, mit dem der Federated Compute-Client eine Verbindung herstellen wird:

<!-- 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 IsolatedWorker#onTrainingExample für die On-Device-Personalisierung, um Trainingsdaten zu generieren.

Code, der in der IsolatedProcess ausgeführt wird, hat keinen direkten Zugriff auf das Netzwerk, lokale Laufwerke 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 von Entwicklern betrieben werden.
'getLocalData': Veränderliche Schlüssel/Wert-Daten, die von Entwicklern lokal gespeichert werden, sofern zutreffend.
„UserData“: Von der Plattform bereitgestellte Nutzerdaten.
'getLogReader': Gibt eine 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: Planen Sie eine wiederkehrende Trainingsaufgabe.

Die On-Device-Personalisierung bietet Entwicklern eine FederatedComputeScheduler, mit der sie föderierte Compute-Jobs planen oder abbrechen können. Es gibt verschiedene Möglichkeiten, die Funktion über IsolatedWorker aufzurufen, entweder nach einem Zeitplan oder wenn ein asynchroner Download abgeschlossen ist. Im Folgenden finden Sie Beispiele für beide.

Zeitplanbasierte Option. Rufen Sie FederatedComputeScheduler#schedule in IsolatedWorker#onExecute an.

@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#schedule in IsolatedWorker#onDownloadCompleted auf, wenn die Planung einer Trainingsaufgabe von asynchronen Daten oder Prozessen abhängt.

Validierung

In den folgenden Schritten wird beschrieben, wie Sie prüfen, ob die Aufgabe für die föderierte Lerntechnologie richtig ausgeführt wird.

Schritt 8: Prüfen Sie, ob die Aufgabe für die föderierte Lerntechnologie ordnungsgemäß ausgeführt wird.

Bei jeder 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 von Metrics generiert, die Sie in Schritt 3 definiert haben. Hier 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 Script 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()

Beispielgrafik für die Darstellung des Messwerts „AUC-ROC“.

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 On-Device-Personalisierung trainieren

In dieser Anleitung wird anhand des Datasets EMNIST veranschaulicht, wie eine föderierte Lernaufgabe 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)

Die Details zum Emnist-Keras-Modell finden Sie unter emnist_models.
TfLite unterstützt tf.sparse.SparseTensor oder tf.RaggedTensor noch nicht gut. Verwenden Sie beim Erstellen des Modells nach Möglichkeit tf.Tensor.
Der ODP-Aufgaben-Builder überschreibt alle Messwerte beim Erstellen des Lernprozesses. Es müssen keine Messwerte angegeben werden. Dieses Thema wird in Schritt 2 ausführlicher behandelt. Erstellen Sie die Task-Builder-Konfiguration.

Es werden zwei Arten von Modellinputs unterstützt:

Typ 1. Ein Tupel(features_tensor, label_tensor).

Beim Erstellen des Modells sieht die Eingabespezifikation so aus:

def get_input_spec():
  return (
      tf.TensorSpec([None, 28, 28, 1], tf.float32),
      tf.TensorSpec([None, 1], tf.int64),
  )

Kombinieren Sie das Vorangehende 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 die Eingabespezifikation 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 Vorangehende 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()

Denken Sie daran, label_name in der Konfiguration des Aufgabengenerators zu registrieren.

mode: TRAINING_AND_EVAL  # Task execution mode
population_name: "my_example_model"
label_name: "my_label"

ODP verarbeitet die DP automatisch beim Erstellen des Lernprozesses. Beim Erstellen des funktionalen Modells müssen also keine Störungen hinzugefügt werden.
Die Ausgabe dieses gespeicherten funktionalen Modells sollte wie das Beispiel in unserem GitHub-Repository aussehen.

Schritt 2: Konfiguration für den Aufgaben-Builder erstellen

In unserem GitHub-Repository finden Sie Beispiele für die Konfiguration von Task-Buildern.

Messwerte für Training und Bewertung

Da Messwerte Nutzerdaten preisgeben können, enthält der Aufgaben-Builder eine Liste der Messwerte, die der Lernprozess generieren und freigeben kann. Die vollständige Liste finden Sie in unserem GitHub-Repository.

Hier ist eine Beispielliste für Messwerte beim Erstellen einer neuen Konfiguration für den Aufgabenersteller:

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_epsilon oder noise_mulitipiler ist vorhanden, um die Validierung zu bestehen: (noise_to_epsilon epislon_to_noise).
Diese Standardeinstellungen finden Sie in unserem GitHub-Repository.

Schritt 3: Laden Sie das gespeicherte Modell und die Konfigurationsdatei des Aufgabenerstellers in den Cloud-Speicher eines beliebigen Entwicklers hoch.

Denken Sie daran, die Felder artifact_building beim Hochladen der Task-Builder-Konfiguration zu aktualisieren.

Schritt 4: Optional: Artefakt-Erstellung testen, 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 durch die Flex-Ops- als auch 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-Ops müssen mit dem Flex-Delegierten (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 starten Sie einen Task-Builder lokal, um ihn zu debuggen:

# 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

Sie finden die resultierenden Artefakte im in der Konfiguration angegebenen Cloud-Speicher. Sie sollte in etwa so aussehen wie das Beispiel in unserem GitHub-Repository.

Schritt 5: Erstellen Sie Artefakte und erstellen Sie auf dem FCP-Server ein neues Paar aus Trainings- und Bewertungsaufgaben.

Entferne das Flag build_artifact_only, damit die erstellten Artefakte auf den FCP-Server hochgeladen werden. Prüfen Sie, ob ein Paar aus Trainings- und Bewertungsaufgaben 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: FCP clientseitig vorbereiten

Implementieren Sie die öffentliche ODP API IsolatedWorker#onTrainingExamples, um Trainingsdaten zu generieren.
Rufen Sie FederatedComputeScheduler#schedule auf.
In unserem Android-Quell-Repository finden Sie einige Beispiele.

Schritt 7: Monitoring

Servermesswerte

Eine Anleitung zur Einrichtung finden Sie in unserem GitHub-Repository.

Diagramm der Verarbeitungszeit der Iteration.

Diagramm der Iterationen im Zeitverlauf.

Modellmesswerte

Diagramm, das einen Vergleich von Messwerten aus verschiedenen Ausführungen zeigt

Es ist möglich, Messwerte aus verschiedenen Läufen in einem Diagramm zu vergleichen. Beispiel:

Die lila Linie entspricht noise_multiplier 0.1.
Die rosa Linie entspricht noise_multipiler 0,3.

Job für föderiertes Lernen erstellen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.