Cette page a été traduite par l'API Cloud Translation.

Créer un job d'apprentissage fédéré
Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Cette page explique comment utiliser les API de l'apprentissage fédéré fournies par la personnalisation sur l'appareil pour entraîner un modèle avec un processus d'apprentissage par moyenne fédérée et un bruit gaussien fixe.

Avant de commencer

Avant de commencer, procédez comme suit sur votre appareil de test:

Assurez-vous que le module OnDevicePersonalization est installé. Le module est disponible en tant que mise à jour automatique depuis avril 2024.
```
# List the modules installed on the device
adb shell pm list packages --apex-only --show-versioncode
```
Assurez-vous que le module suivant est listé avec un code de version 341717000 ou supérieur:

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

Si ce module ne s'affiche pas, accédez à Paramètres > Sécurité et confidentialité > Mises à jour > Mise à jour du système Google Play pour vous assurer que votre appareil est à jour. Sélectionnez Update (Mettre à jour) si nécessaire.

Activez toutes les nouvelles fonctionnalités liées à l'apprentissage fédéré.

# 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

Créer une tâche d'apprentissage fédéré

Topologie client-serveur de l'apprentissage fédéré avec huit étapes mises en évidence. — Schéma de la topologie client-serveur de l'apprentissage fédéré avec huit étapes mises en évidence.

Les chiffres du diagramme sont expliqués plus en détail dans les huit étapes suivantes.

Configurer un serveur Federated Compute

L'apprentissage fédéré est une méthode map-reduce exécutée sur le serveur de calcul fédéré (le réducteur) et un ensemble de clients (les mappeurs). Le serveur Federated Compute gère les métadonnées en cours d'exécution et les informations sur le modèle de chaque tâche d'apprentissage fédéré. De manière générale :

Un développeur de l'apprentissage fédéré crée une tâche et importe à la fois les métadonnées d'exécution de la tâche et les informations sur le modèle sur le serveur.
Lorsqu'un client Compute federated envoie une nouvelle requête d'attribution de tâche au serveur, celui-ci vérifie l'éligibilité de la tâche et renvoie les informations la concernant.
Une fois qu'un client Federated Compute a terminé les calculs locaux, il envoie les résultats de ces calculs au serveur. Le serveur effectue ensuite une agrégation et un bruitage sur ces résultats de calcul, puis applique le résultat au modèle final.

Pour en savoir plus sur ces concepts, consultez les ressources suivantes:

L'ODP utilise une version améliorée de l'apprentissage fédéré, dans laquelle un bruit calibré (centralisé) est appliqué aux agrégats avant d'être appliqué au modèle. L'échelle du bruit garantit que les agrégations préservent la confidentialité différentielle.

Étape 1 : Créer un serveur Federated Compute

Suivez les instructions du projet Federated Compute pour configurer votre propre serveur Federated Compute.

Étape 2 : Préparer un FunctionalModel enregistré

Préparez un fichier FunctionalModel enregistré. Vous pouvez utiliser 'functional_model_from_keras' pour convertir un modèle en FunctionalModel, puis save_functional_model pour sérialiser ce FunctionalModel en tant que SavedModel.

functional_model = tff.learning.models.functional_model_from_keras(keras_model=model)
tff.learning.models.save_functional_model(functional_model, saved_model_path)

Étape 3 : Créer une configuration de serveur Federated Compute

Préparez un fcp_server_config.json qui inclut les règles, la configuration de l'apprentissage fédéré et la configuration de la confidentialité différentielle. Exemple :

  # 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
  }

Étape 4 : Envoyez la configuration compressée au serveur Federated Compute.

Envoyez le fichier ZIP et fcp_server_config.json au serveur Federated Compute.

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

Le point de terminaison du serveur Federated Compute est le serveur que vous avez configuré à l'étape 1.

La bibliothèque d'opérateurs intégrée LiteRT n'est compatible qu'avec un nombre limité d'opérateurs TensorFlow (sélectionnez des opérateurs TensorFlow). L'ensemble d'opérateurs compatibles peut varier selon les versions du module OnDevicePersonalization. Pour garantir la compatibilité, un processus de validation de l'opérateur est effectué dans l'outil de création de tâches lors de la création de la tâche.

La version minimale compatible du module OnDevicePersonalization sera incluse dans les métadonnées de la tâche. Vous trouverez ces informations dans le message d'informations du générateur de tâches.

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"
}

Le serveur de calcul fédéré attribue cette tâche à tous les appareils équipés d'un module OnDevicePersonalization dont la version est supérieure à 341812000.

Si votre modèle inclut des opérations non compatibles avec les modules OnDevicePersonalization, un message d'erreur s'affiche lors de la création de la tâche.

common.TaskBuilderException: Cannot build the ClientOnlyPlan: Please contact Google to register these ops: {'L2Loss': 'L2LossOp<CPUDevice, float>'}
. Stop building remaining artifacts.

Vous trouverez une liste détaillée des opérations flex compatibles sur GitHub.

Créer un APK Android Federated Compute

Pour créer un APK Android Federated Compute, vous devez spécifier le point de terminaison de l'URL du serveur Federated Compute dans votre AndroidManifest.xml, auquel votre client Federated Compute se connecte.

Étape 5 : Spécifier le point de terminaison de l'URL du serveur Compute fédéré

Spécifiez le point de terminaison de l'URL du serveur de calcul fédéré (que vous avez configuré à l'étape 1) dans votre fichier AndroidManifest.xml, auquel votre client de calcul fédéré se connecte.

<!-- 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>

Le fichier de ressources XML spécifié dans la balise <property> doit également déclarer la classe de service dans une balise <service> et spécifier le point de terminaison d'URL du serveur de calcul fédéré auquel le client de calcul fédéré se connectera:

<!-- 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>

Étape 6 : Implémenter l'API `IsolatedWorker#onTrainingExample`

Implémentez l'API publique de personnalisation sur l'appareil IsolatedWorker#onTrainingExample pour générer des données d'entraînement.

Le code exécuté dans le IsolatedProcess n'a pas d'accès direct au réseau, aux disques locaux ni aux autres services exécutés sur l'appareil. Toutefois, les API suivantes sont disponibles:

"getRemoteData" : données clé-valeur immuables téléchargées à partir de backends distants gérés par le développeur, le cas échéant.
'getLocalData' : données clé-valeur modifiables conservées localement par les développeurs, le cas échéant.
"UserData" : données utilisateur fournies par la plate-forme.
'getLogReader' : renvoie un DAO pour les tables REQUESTS et EVENTS.

Exemple :

@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());
    }
}

Étape 7 : Planifier une tâche d'entraînement récurrente

La personnalisation sur l'appareil fournit un FederatedComputeScheduler permettant aux développeurs de planifier ou d'annuler des tâches de calcul fédérées. Il existe différentes options pour l'appeler via IsolatedWorker, soit de manière planifiée, soit à la fin d'un téléchargement asynchrone. Vous trouverez ci-dessous des exemples des deux.

Option basée sur la planification. Appelez FederatedComputeScheduler#schedule à IsolatedWorker#onExecute.

@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 "Téléchargement terminé". Appelez FederatedComputeScheduler#schedule dans IsolatedWorker#onDownloadCompleted si la planification d'une tâche d'entraînement dépend de données ou de processus asynchrones.

Validation

Les étapes suivantes décrivent comment vérifier si la tâche de l'apprentissage fédéré s'exécute correctement.

Étape 8 : Vérifiez si la tâche de l'apprentissage fédéré s'exécute correctement.

Un nouveau point de contrôle du modèle et un nouveau fichier de métriques sont générés à chaque cycle d'agrégation côté serveur.

Les métriques se trouvent dans un fichier au format JSON contenant des paires clé-valeur. Le fichier est généré à partir de la liste de Metrics que vous avez définie à l'étape 3. Voici un exemple de fichier JSON de métriques représentatif:

{"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}

Vous pouvez utiliser un script semblable au script suivant pour obtenir les métriques du modèle et surveiller les performances d'entraînement:

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()

Exemple de graphique illustrant l'apparence de la métrique auc-roc lorsqu'elle est tracée.

Notez que dans l'exemple de graphique précédent:

L'axe X correspond au nombre d'entraînements.
L'axe des ordonnées correspond à la valeur de l'AUC-ROC de chaque tour.

Entraîner un modèle de classification d'images pour la personnalisation sur l'appareil

Dans ce tutoriel, l'ensemble de données EMNIST est utilisé pour montrer comment exécuter une tâche d'apprentissage fédéré sur l'ODP.

Étape 1 : Créer un tff.learning.models.FunctionalModel

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)

Vous trouverez les détails du modèle Keras emnist dans emnist_models.
TfLite n'est pas encore compatible avec tf.sparse.SparseTensor ni tf.RaggedTensor. Essayez d'utiliser tf.Tensor autant que possible lorsque vous créez le modèle.
L'outil de création de tâches ODP écrase toutes les métriques lors de la création du processus d'apprentissage. Vous n'avez donc pas besoin de spécifier de métriques. Nous reviendrons sur ce sujet dans la étape 2. Créez la configuration du générateur de tâches.

Deux types d'entrées de modèle sont acceptés:

Type 1. Un tuple(features_tensor, label_tensor).

Lorsque vous créez le modèle, input_spec se présente comme suit:

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

Associez ce qui précède à l'implémentation suivante de l'API publique ODP IsolatedWorker#onTrainingExamples pour générer des données d'entraînement sur l'appareil:

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()

Type 2. Tuple(Dict[feature_name, feature_tensor], label_tensor)

Lorsque vous créez le modèle, input_spec se présente comme suit:

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),
  )

Associez ce qui précède à l'implémentation suivante de l'API publique ODP IsolatedWorker#onTrainingExamples pour générer des données d'entraînement:

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()

N'oubliez pas d'enregistrer label_name dans la configuration de l'outil de création de tâches.

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

L'ODP gère automatiquement la DP lors de la création du processus d'apprentissage. Il n'est donc pas nécessaire d'ajouter du bruit lors de la création du modèle fonctionnel.
La sortie de ce modèle fonctionnel enregistré devrait ressembler à l'exemple de notre dépôt GitHub.

Étape 2 : Créer la configuration du générateur de tâches

Vous trouverez des exemples de configuration du générateur de tâches dans notre dépôt GitHub.

Métriques d'entraînement et d'évaluation

Étant donné que les métriques peuvent divulguer des données utilisateur, l'outil de création de tâches contient une liste des métriques que le processus d'apprentissage peut générer et publier. Vous trouverez la liste complète dans notre dépôt GitHub.

Voici un exemple de liste de métriques lorsque vous créez une configuration de l'outil de création de tâches:

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"
    }
  }
}

Si les métriques qui vous intéressent ne figurent pas dans la liste actuelle, contactez-nous.

Configurations DP

Vous devez spécifier quelques configurations liées aux DP:

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
}

dp_target_epsilon ou noise_mulitipiler est présent pour réussir la validation: (noise_to_epsilon epislon_to_noise).
Vous trouverez ces paramètres par défaut dans notre dépôt GitHub.

Étape 3 : Importer le modèle enregistré et la configuration du générateur de tâches dans l'espace de stockage cloud de n'importe quel développeur

N'oubliez pas de mettre à jour les champs artifact_building lorsque vous importez la configuration de l'outil de création de tâches.

Étape 4 : (Facultatif) Tester la création d'artefacts sans créer de tâche

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}

L'exemple de modèle est validé à la fois par la vérification des opérations flexibles et par la vérification des dp. Vous pouvez ajouter skip_flex_ops_check et skip_dp_check pour contourner la validation (ce modèle ne peut pas être déployé dans la version actuelle du client ODP en raison de quelques opérations flexibles manquantes).

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: la bibliothèque d'opérateurs intégrée de TensorFlow Lite n'est compatible qu'avec un nombre limité d'opérateurs TensorFlow (Compatibilité de TensorFlow Lite et des opérateurs TensorFlow). Toutes les opérations TensorFlow incompatibles doivent être installées à l'aide du délégué flex (Android.bp). Si un modèle contient des opérations non compatibles, contactez-nous pour les enregistrer:
```
Cannot build the ClientOnlyPlan: Please contact Google to register these ops: {...}
```

Le meilleur moyen de déboguer un outil de création de tâches consiste à en démarrer un localement:

# 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

Vous pouvez trouver les artefacts générés dans le stockage cloud spécifié dans la configuration. Il doit ressembler à l'exemple de notre dépôt GitHub.

Étape 5 : Créez des artefacts et une paire de tâches d'entraînement et d'évaluation sur le serveur FCP.

Supprimez l'indicateur build_artifact_only. Les artefacts compilés seront alors importés sur le serveur FCP. Vous devez vérifier qu'une paire de tâches d'entraînement et d'évaluation a bien été créée.

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}

Étape 6 : Préparer le côté client de FCP

Implémentez l'API publique ODP IsolatedWorker#onTrainingExamples pour générer des données d'entraînement.
Appelez FederatedComputeScheduler#schedule.
Vous trouverez quelques exemples dans notre dépôt source Android.

Étape 7 : Surveillance

Métriques de serveur

Vous trouverez les instructions de configuration dans notre dépôt GitHub.

Graphique du temps de traitement de l'itération.

Graphique des itérations au fil du temps.

Métriques du modèle

Graphique illustrant une comparaison des métriques de différentes exécutions.

Vous pouvez comparer les métriques de différentes exécutions dans un même diagramme. Exemple :

La ligne violette correspond à noise_multiplier 0,1.
La ligne rose correspond à noise_multipiler 0,3.

Créer un job d'apprentissage fédéré Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.