Ta strona została przetłumaczona przez Cloud Translation API.

Tworzenie zadania sfederowanego uczenia się

Na tej stronie opisujemy, jak korzystać z interfejsów API sfederowanego uczenia się udostępnianych przez usługę personalizacji na urządzeniu, aby trenować model za pomocą sfederowanego procesu uczenia się z użyciem średniej i stałych zakłóceń Gaussa.

Zanim zaczniesz

Zanim zaczniesz, wykonaj te czynności na urządzeniu testowym:

Upewnij się, że moduł OnDevicePersonalization jest zainstalowany. Moduł został udostępniony jako automatyczna aktualizacja w kwietniu 2024 r.
```
# List the modules installed on the device
adb shell pm list packages --apex-only --show-versioncode
```
Upewnij się, że wymieniony poniżej moduł ma kod wersji 341717000 lub nowszy:

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

Jeśli modułu nie ma na liście, kliknij Ustawienia > Bezpieczeństwo i prywatność > Aktualizacje > Aktualizacja systemowa Google Play, aby upewnić się, że urządzenie jest aktualne. W razie potrzeby kliknij Aktualizuj.

Włącz wszystkie nowe funkcje związane z sfederowanym uczeniem się.

# 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

Tworzenie zadania sfederowanego uczenia się

Topologia sfederowanego uczenia się na serwerze i na kliencie z wyróżnionymi 8 krokami — Diagram przedstawiający topologię sfederowanego uczenia się klient–serwer z 8 zaznaczonymi krokami.

Liczby na diagramie zostały bardziej szczegółowo wyjaśnione w 8 kolejnych krokach.

Konfigurowanie serwera obliczeniowego federacji

Sfederowane uczenie się to technika map-reduce, która działa na serwerze obliczeniowym sfederowanym (reduktorze) i na zestawie klientów (maperów). Serwer Federated Compute przechowuje metadane i informacje o modelu dotyczące każdego zadania sfederowanego uczenia się. Ogólnie:

Deweloperzy korzystający z federowanego uczenia maszynowego tworzą nowe zadanie i przesyłają na serwer metadane dotyczące jego wykonywania oraz informacje o modelu.
Gdy klient usługi Federated Compute inicjuje na serwerze nowe zadanie przypisywania zadań, serwer sprawdza, czy zadanie kwalifikuje się do wykonania, i zwraca informacje o kwalifikujących się zadaniach.
Gdy klient sfederowanego przetwarzania danych zakończy obliczenia lokalne, wysyła wyniki obliczeń na serwer. Następnie serwer agreguje te wyniki i dodaje do nich szum, a potem stosuje je w modelu końcowym.

Aby dowiedzieć się więcej o tych pojęciach, przeczytaj:

ODP korzysta z ulepszonej wersji sfederowanego uczenia się, w której do agregatów przed zastosowaniem do modelu dodawany jest scentralizowany szum. Skala szumu zapewnia, że dane zbiorcze zachowują prywatność różnicową.

Krok 1. Tworzenie federacyjnego serwera obliczeniowego

Aby skonfigurować własny serwer federacyjnego przetwarzania, postępuj zgodnie z instrukcjami w projekcie federacyjnego przetwarzania.

Krok 2. Przygotuj zapisany model funkcjonalny

Przygotuj zapisany plik „FunctionalModel”. Możesz użyć funkcji 'functional_model_from_keras', aby przekonwertować 'Model' na 'FunctionalModel', a funkcję 'save_functional_model', aby zserializować ten 'FunctionalModel' jako 'SavedModel'.

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

Krok 3. Tworzenie konfiguracji sfederowanego serwera Compute Server

Przygotuj dokument fcp_server_config.json, który zawiera zasady, sfederowane uczenie się i konfigurację prywatności różnicowej. Przykład:

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

Krok 4. Prześlij skompresowaną konfigurację na serwer Federated Compute.

Prześlij plik ZIP i zasadę fcp_server_config.json na serwer Federated Compute Server.

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

Punkt końcowy zfederowanego serwera Compute to serwer skonfigurowany w kroku 1.

Wbudowana biblioteka operatorów LiteRT obsługuje tylko ograniczoną liczbę operatorów TensorFlow (wybrane operatory TensorFlow). Zestaw obsługiwanych operatorów może się różnić w zależności od wersji modułu Personalizacja na urządzeniu. Aby zapewnić zgodność, podczas tworzenia zadania w kreatorze zadań przeprowadzany jest proces weryfikacji operatora.

Minimalna obsługiwana wersja modułu OnDevicePersonalization będzie podana w metadanych zadania. Te informacje znajdziesz w komunikacie informacyjnym kreatora zadań.

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

Serwer Federated Compute przypisze to zadanie do wszystkich urządzeń wyposażonych w moduł OnDevicePersonalization w wersji wyższej niż 341812000.

Jeśli Twój model zawiera operacje, które nie są obsługiwane przez żadne moduły usługi personalizacji na urządzeniu, podczas tworzenia zadania zostanie wygenerowany komunikat o błędzie.

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

Szczegółową listę obsługiwanych operacji Flex znajdziesz na GitHub.

Tworzenie pakietu APK sfederowanego Compute na Androida

Aby utworzyć pakiet APK na Androida Federated Compute Server, musisz w AndroidManifest.xml określić punkt końcowy adresu URL sfederowanego serwera Compute Server, z którym łączy się Twój klient sfederowanego Compute.

Krok 5. Określ punkt końcowy adresu URL sfederowanego serwera Compute

W pliku AndroidManifest.xml określ adres URL punktu końcowego serwera obliczeniowego federacji (skonfigurowany w kroku 1), z którym łączy się klient obliczeniowy federacji.

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

Plik zasobów XML określony w tagu <property> musi też zadeklarować klasę usługi w tagu <service> i określić punkt końcowy URL sfederowanego serwera Compute Server, z którym połączy się sfederowany klient obliczeniowy:

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

Krok 6. Wdrażanie interfejsu `IsolatedWorker#onTrainingExample` API

Zaimplementuj publiczny interfejs API personalizacji na urządzeniu IsolatedWorker#onTrainingExample, aby generować dane treningowe.

Kod działający w ramach IsolatedProcess nie ma bezpośredniego dostępu do sieci, dysków lokalnych ani innych usług działających na urządzeniu. Dostępne są jednak te interfejsy API:

'getRemoteData' – stałe dane pary klucz-wartość pobierane ze zdalnych backendów obsługiwanych przez dewelopera (w stosownych przypadkach).
'getLocalData' – zmienne dane pary klucz-wartość są zapisywane lokalnie przez deweloperów (w stosownych przypadkach).
„UserData” – dane użytkownika dostarczane przez platformę.
'getLogReader' – zwraca identyfikator DAO dla tabel REQUESTS i EVENTS.

Przykład:

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

Krok 7. Zaplanuj cykliczne zadanie trenowania.

Personalizacja na urządzeniu zapewnia FederatedComputeScheduler dla programistów, aby mogli zaplanować lub anulować zadania obliczeniowe w federacji. Można ją wywoływać przez IsolatedWorker na różne sposoby: zgodnie z harmonogramem lub po zakończeniu pobierania asynchronicznego. Poniżej znajdziesz przykłady obu typów treści.

Opcja oparta na harmonogramie. Zadzwoń do firmy 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);
    }
}

Opcja pobierania zakończenia. W funkcji FederatedComputeScheduler#schedule w funkcji IsolatedWorker#onDownloadCompleted, jeśli planowanie zadania treningowego zależy od danych lub procesów asynchronicznych.

Weryfikacja

Podane niżej kroki pokazują, jak sprawdzić, czy zadanie sfederowane uczenie się działa prawidłowo.

Krok 8. Sprawdź, czy zadanie federacyjnego uczenia się działa prawidłowo.

Po każdej rundzie agregacji po stronie serwera generowany jest nowy punkt kontrolny modelu i nowy plik danych.

Dane są w pliku w formacie JSON zawierającym pary klucz-wartość. Plik jest generowany na podstawie listy Metrics zdefiniowanej w kroku 3. Przykład reprezentatywnego pliku JSON z danymi:

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

Aby uzyskać dane o modelu i monitorować skuteczność trenowania, możesz użyć skryptu podobnego do tego:

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

Zwróć uwagę, że na poprzednim przykładowym wykresie:

Oś X to liczba rund trenowania.
Oś Y to wartość AUC-ROC w każdej rundzie.

Trenowanie modelu klasyfikacji obrazów na potrzeby personalizacji na urządzeniu

W tym samouczku do demonstracji uruchomienia zadania sfederowanego uczenia się w ODP używamy zbioru danych EMNIST.

Krok 1. Utwórz klasę 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)

Szczegóły modelu Emnist Kera znajdziesz w atrybucie emnist_models.
TfLite nie obsługuje jeszcze dobrze funkcji tf.sparse.SparseTensor ani tf.RaggedTensor. Podczas tworzenia modelu staraj się korzystać z narzędzia tf.Tensor jak najczęściej.
Kreator zadań ODP nadpisuje wszystkie dane podczas tworzenia procesu nauki, więc nie trzeba ich podawać. Ten temat zostanie dokładniej omówiony w kroku 2. Utwórz konfigurację kreatora zadań.

Obsługiwane są 2 rodzaje danych wejściowych modelu:

Typ 1. Tuple(features_tensor, label_tensor).

Podczas tworzenia modelu element specyfikacyjny wejściowy wygląda tak:

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

Połącz to z implementacją interfejsu API publicznego ODP IsolatedWorker#onTrainingExamples, aby wygenerować dane treningowe na urządzeniu:

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. Tuple(Dict[feature_name, feature_tensor], label_tensor)

Podczas tworzenia modelu parametr input_spec ma postać:

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

Aby wygenerować dane do trenowania, połącz poprzednie rozwiązanie z tą implementacją publicznego interfejsu API ODP IsolatedWorker#onTrainingExamples:

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

Nie zapomnij zarejestrować wartości label_name w konfiguracji kreatora zadań.

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

ODP automatycznie obsługuje DP podczas tworzenia procesu nauki. Przy tworzeniu modelu funkcjonalnego nie trzeba dodawać żadnych szumów.
Dane wyjściowe tego zapisanego modelu funkcjonalnego powinny wyglądać jak przykład w naszym repozytorium GitHub.

Krok 2. Tworzenie konfiguracji kreatora zadań

Przykładowe konfiguracje kreatora zadań znajdziesz w naszym repozytorium GitHub.

Wskaźniki trenowania i oceny

Ze względu na to, że wskaźniki mogą wyciekać dane użytkowników, Kreator zadań będzie miał listę wskaźników, które proces uczenia się może wygenerować i opublikować. Pełną listę znajdziesz w naszym repozytorium GitHub.

Oto przykładowa lista wskaźników używanych podczas tworzenia nowej konfiguracji kreatora zadań:

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

Jeśli interesujących Cię danych nie ma na obecnej liście, skontaktuj się z nami.

Konfiguracje DP

Jest kilka konfiguracji związanych z DP, które należy określić:

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
}

Aby przejść weryfikację, musisz podać wartość dp_target_epsilon lub noise_mulitipiler: (noise_to_epsilon epislon_to_noise).
Te ustawienia domyślne znajdziesz w naszym repozytorium GitHub.

Krok 3. Prześlij zapisaną konfigurację modelu i kreatora zadań do Cloud Storage dowolnego dewelopera

Pamiętaj, aby podczas przesyłania konfiguracji kreatora zadań zaktualizować pola artifact_building.

Krok 4. (Opcjonalnie) Testowanie tworzenia artefaktu bez tworzenia nowego zadania

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}

Przykładowy model jest weryfikowany zarówno przez sprawdzenie operacji elastycznych, jak i sprawdzenie dp. Aby pominąć weryfikację, możesz dodać skip_flex_ops_check i skip_dp_check (tego modelu nie można wdrożyć w bieżącej wersji klienta ODP z powodu braku kilku operacji elastycznych).

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: wbudowana biblioteka operatorów TensorFlow Lite obsługuje ograniczoną liczbę operatorów TensorFlow (zgodność z operatorami TensorFlow Lite i TensorFlow) Wszystkie niezgodne operacje Tensorflow muszą być zainstalowane przy użyciu interfejsu Flex Delegat (Android.bp). Jeśli model zawiera nieobsługiwane operacje, skontaktuj się z nami, aby je zarejestrować:
```
Cannot build the ClientOnlyPlan: Please contact Google to register these ops: {...}
```

Najlepszym sposobem debugowania kreatora zadań jest uruchomienie go lokalnie:

# 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

Otrzymane w ten sposób artefakty znajdziesz w chmurze w chmurze określonej w konfiguracji. Powinien wyglądać podobnie do przykładu w naszym repozytorium GitHub.

Krok 5. Utwórz artefakty i nową parę zadań szkoleniowych i oceny na serwerze FCP.

Usuń flagę build_artifact_only, a skompilowane artefakty zostaną przesłane na serwer FCP. Sprawdź, czy udało się utworzyć parę zadań treningowych i ewaluacyjnych.

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}

Krok 6. Przygotowanie po stronie klienta do obsługi FCP

Zaimplementuj publiczny interfejs API ODP IsolatedWorker#onTrainingExamples, aby generować dane do trenowania.
Zadzwoń pod numer FederatedComputeScheduler#schedule.
W naszym repozytorium kodu źródłowego Androida znajdziesz kilka przykładów.

Krok 7. Monitorowanie

Wskaźniki serwera

Instrukcje konfiguracji znajdziesz w naszym repozytorium GitHub.

Dane modelu

Wykres przedstawiający porównanie danych z różnych testów

Dane z różnych uruchomień można porównać na jednym diagramie. Na przykład:

Fioletowa linia to noise_multiplier 0,1
Różowa linia to noise_multipiler 0,3

Tworzenie zadania sfederowanego uczenia się

Zanim zaczniesz

Tworzenie zadania sfederowanego uczenia się

Konfigurowanie serwera obliczeniowego federacji

Krok 1. Tworzenie federacyjnego serwera obliczeniowego

Krok 2. Przygotuj zapisany model funkcjonalny

Krok 3. Tworzenie konfiguracji sfederowanego serwera Compute Server

Krok 4. Prześlij skompresowaną konfigurację na serwer Federated Compute.

Tworzenie pakietu APK sfederowanego Compute na Androida

Krok 5. Określ punkt końcowy adresu URL sfederowanego serwera Compute

Krok 6. Wdrażanie interfejsu IsolatedWorker#onTrainingExample API

Krok 7. Zaplanuj cykliczne zadanie trenowania.

Weryfikacja

Krok 8. Sprawdź, czy zadanie federacyjnego uczenia się działa prawidłowo.

Trenowanie modelu klasyfikacji obrazów na potrzeby personalizacji na urządzeniu

Krok 1. Utwórz klasę tff.learning.models.FunctionalModel

Krok 2. Tworzenie konfiguracji kreatora zadań

Krok 3. Prześlij zapisaną konfigurację modelu i kreatora zadań do Cloud Storage dowolnego dewelopera

Krok 4. (Opcjonalnie) Testowanie tworzenia artefaktu bez tworzenia nowego zadania

Krok 5. Utwórz artefakty i nową parę zadań szkoleniowych i oceny na serwerze FCP.

Krok 6. Przygotowanie po stronie klienta do obsługi FCP

Krok 7. Monitorowanie

Krok 6. Wdrażanie interfejsu `IsolatedWorker#onTrainingExample` API