בדף הזה מוסבר איך להשתמש בממשקי Federated Learning API שמוצעים על ידי On-Device Personalization כדי לאמן מודל באמצעות תהליך למידה של ממוצעים מאוחדים ורעש גאוסי קבוע.
לפני שמתחילים
לפני שמתחילים, צריך לבצע את השלבים הבאים במכשיר הבדיקה:
מוודאים שהמודול OnDevicePersonalization מותקן. המודול הפך לזמין כעדכון אוטומטי באפריל 2024.
# List the modules installed on the device adb shell pm list packages --apex-only --show-versioncodeמוודאים שהמודול הבא מופיע עם קוד גרסה 341717000 ומעלה:
package:com.google.android.ondevicepersonalization versionCode:341717000אם המודול לא מופיע ברשימה, עוברים אל הגדרות > אבטחה ופרטיות > עדכונים > עדכון מערכת של Google Play כדי לוודא שהמכשיר מעודכן. בוחרים באפשרות עדכון לפי הצורך.
הפעלת כל התכונות החדשות שקשורות ללמידה מאוחדת.
# 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
יצירת משימה של למידה משותפת
המספרים בתרשים מוסברים בפירוט בשמונת השלבים הבאים.
הגדרת שרת של חישוב מאוחד
למידה משותפת היא מיפוי-צמצום שפועל בשרת Federated Compute (הצמצם) ובקבוצת לקוחות (המיפוי). בשרת של למידה משותפת נשמרים המטא-נתונים והמידע על המודל של כל משימה של למידה משותפת. ברמת העל:
- מפתח של למידה משותפת יוצר משימה חדשה ומעלה לשרת מטא-נתונים של הפעלת המשימה ומידע על המודל.
- כשלקוח של Federated Compute יוזם בקשה חדשה להקצאת משימה לשרת, השרת בודק את הזכאות של המשימה ומחזיר מידע על משימות שעומדות בדרישות.
- אחרי שחשבון לקוח של Federated Compute מסיים את החישובים המקומיים, הוא שולח את תוצאות החישובים האלה לשרת. לאחר מכן השרת מבצע צבירה והוספת רעש לתוצאות החישוב האלה, ומחיל את התוצאה על המודל הסופי.
מידע נוסף על המושגים האלה זמין במאמרים הבאים:
- למידה משותפת (Federated): למידת מכונה שיתופית ללא נתוני אימון מרכזיים
- Towards Federated Learning at Scale: System Design (SysML 2019)
ב-ODP נעשה שימוש בגרסה משופרת של למידה משותפת (Federated), שבה רעש מכויל (מרוכז) מוחל על הצבירות לפני שהוא מוחל על המודל. היקף הרעש מבטיח שהצבירות ישמרו על פרטיות דיפרנציאלית.
שלב 1. יצירת שרת של חישוב מאוחד
כדי להגדיר שרת Federated Compute משלכם, פועלים לפי ההוראות בפרויקט Federated Compute.
שלב 2. הכנת Saved FunctionalModel
מכינים קובץ FunctionalModel שמור. אפשר להשתמש ב-'functional_model_from_keras' כדי להמיר 'Model' ל-'FunctionalModel', וב-'save_functional_model' כדי לבצע סריאליזציה של 'FunctionalModel' בתור 'SavedModel'.
functional_model = tff.learning.models.functional_model_from_keras(keras_model=model)
tff.learning.models.save_functional_model(functional_model, saved_model_path)
שלב 3. יצירת הגדרה של שרת Federated Compute
מכינים fcp_server_config.json שכולל מדיניות, הגדרת למידה משותפת (Federated) והגדרת פרטיות דיפרנציאלית. דוגמה:
# 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
}
שלב 4. שולחים את תצורת ה-ZIP לשרת Federated Compute.
שולחים את קובץ ה-ZIP ואת fcp_server_config.json לשרת Federated Compute.
task_builder_client --task_builder_server='http://{federated_compute_server_endpoint}' --saved_model='saved_model' --task_config='fcp_server_config.json'
נקודת הקצה של שרת החישוב המאוחד היא השרת שהגדרתם בשלב 1.
ספריית האופרטורים המובנית של LiteRT תומכת רק במספר מוגבל של אופרטורים של TensorFlow (בחירת אופרטורים של TensorFlow). יכול להיות שקבוצת האופרטורים הנתמכת תשתנה בין גרסאות שונות של מודול OnDevicePersonalization. כדי לוודא תאימות, מתבצע תהליך אימות של האופרטור בבונה המשימות במהלך יצירת המשימה.
גרסת המודול המינימלית הנתמכת של OnDevicePersonalization תיכלל במטא-נתונים של המשימה. המידע הזה מופיע בהודעת המידע של כלי בניית המשימות.
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" }שרת Federated Compute יקצה את המשימה הזו לכל המכשירים שמצוידים במודול OnDevicePersonalization בגרסה גבוהה מ-341812000.
אם המודל כולל פעולות שלא נתמכות על ידי אף אחד מהמודולים של OnDevicePersonalization, תיווצר הודעת שגיאה במהלך יצירת המשימה.
common.TaskBuilderException: Cannot build the ClientOnlyPlan: Please contact Google to register these ops: {'L2Loss': 'L2LossOp<CPUDevice, float>'} . Stop building remaining artifacts.רשימה מפורטת של פעולות גמישות נתמכות זמינה ב-GitHub.
יצירת קובץ APK של חישוב מאוחד ל-Android
כדי ליצור קובץ APK של Federated Compute ל-Android, צריך לציין ב-AndroidManifest.xml את נקודת הקצה של כתובת ה-URL של שרת Federated Compute, שאליה מתחבר Federated Compute Client.
שלב 5. מציינים את נקודת הקצה של כתובת ה-URL של שרת החישוב המאוחד
מציינים ב-AndroidManifest.xml את נקודת הקצה של כתובת ה-URL של שרת Federated Compute (שהגדרתם בשלב 1), שאליה מתחבר לקוח Federated Compute.
<!-- 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>
בקובץ משאבי ה-XML שצוין בתג <property> צריך גם להצהיר על מחלקת השירות בתג <service>, ולציין את נקודת הקצה של כתובת ה-URL של שרת ה-Compute המאוחד שאליה יתחבר לקוח ה-Compute המאוחד:
<!-- 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>
שלב 6. הטמעה של IsolatedWorker#onTrainingExample API
מטמיעים את ה-API הציבורי של התאמה אישית במכשיר IsolatedWorker#onTrainingExample כדי ליצור נתוני אימון.
לקוד שפועל ב-IsolatedProcess אין גישה ישירה לרשת, לדיסקים מקומיים או לשירותים אחרים שפועלים במכשיר. עם זאת, ממשקי ה-API הבאים זמינים:
- 'getRemoteData' – נתונים של זוגות מפתח/ערך שלא ניתן לשנות, שהורדו משרתי קצה מרוחקים שמופעלים על ידי מפתחים, אם רלוונטי.
- getLocalData – נתונים משתנים של זוגות מפתח/ערך שנשמרים באופן מקומי על ידי מפתחים, אם רלוונטי.
- UserData – נתוני משתמשים שהפלטפורמה מספקת.
- 'getLogReader' – מחזירה DAO לטבלאות REQUESTS ו-EVENTS.
דוגמה:
@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());
}
}
שלב 7. קביעת משימת הדרכה חוזרת.
התאמה אישית במכשיר מספקת FederatedComputeScheduler למפתחים לתזמן או לבטל משימות מחשוב מאוחדות. יש כמה אפשרויות להפעיל אותו דרך IsolatedWorker, לפי לוח זמנים או כשהורדה אסינכרונית מסתיימת. בהמשך מופיעות דוגמאות לשני המקרים.
אפשרות מבוססת-תזמון. התקשרות אל
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); } }האפשרות 'ההורדה הסתיימה'. מתקשרים אל
FederatedComputeScheduler#scheduleבIsolatedWorker#onDownloadCompletedאם תזמון משימת הדרכה תלוי בנתונים או בתהליכים אסינכרוניים.
אימות
בשלבים הבאים מוסבר איך לוודא שמשימת הלמידה המאוחדת פועלת בצורה תקינה.
שלב 8. מוודאים שמשימת הלמידה המשותפת פועלת בצורה תקינה.
בכל סבב של צבירה בצד השרת נוצרת נקודת ביקורת חדשה של המודל וקובץ מדדים חדש.
המדדים נמצאים בקובץ בפורמט JSON של צמדי מפתח-ערך. הקובץ נוצר על ידי רשימת Metrics שהגדרתם בשלב 3. דוגמה לקובץ JSON של מדדים מייצגים:
{"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}
אפשר להשתמש בסקריפט שדומה לסקריפט הבא כדי לקבל מדדים של המודל ולעקוב אחרי ביצועי האימון:
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()
שימו לב שבתרשים לדוגמה שלמעלה:
- ציר ה-x הוא מספר סבבי האימון.
- ציר ה-y הוא הערך של auc-roc בכל סיבוב.
אימון מודל לסיווג תמונות בהתאמה אישית במכשיר
במדריך הזה נעשה שימוש במערך הנתונים EMNIST כדי להדגים איך להריץ משימת למידה מאוחדת ב-ODP.
שלב 1. יצירת 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)
- פרטים על מודל emnist keras זמינים ב-emnist_models.
- ב-TfLite עדיין אין תמיכה טובה ב-tf.sparse.SparseTensor או ב-tf.RaggedTensor. כדאי להשתמש ב-tf.Tensor כמה שיותר כשיוצרים את המודל.
- כלי בניית המשימות של ODP יחליף את כל המדדים כשבונה את תהליך הלמידה, כך שאין צורך לציין מדדים. הנושא הזה יוסבר בהרחבה בשלב 2. יוצרים את ההגדרה של כלי ליצירת משימות.
יש תמיכה בשני סוגים של נתוני קלט למודל:
סוג 1. Tuple(תכונות_טנסור, תווית_טנסור).
- כשיוצרים את המודל, input_spec נראה כך:
def get_input_spec(): return ( tf.TensorSpec([None, 28, 28, 1], tf.float32), tf.TensorSpec([None, 1], tf.int64), )- כדי ליצור נתוני אימון במכשיר, משלבים את הקוד שלמעלה עם ההטמעה הבאה של ODP Public API IsolatedWorker#onTrainingExamples:
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()סוג 2.
Tuple(Dict[feature_name, feature_tensor], label_tensor)- כשיוצרים את המודל, input_spec נראה כך:
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), )- כדי ליצור נתוני אימון, משלבים את הקוד שלמעלה עם ההטמעה הבאה של ממשק ה-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()- אל תשכחו לרשום את label_name בהגדרות של הכלי ליצירת משימות.
mode: TRAINING_AND_EVAL # Task execution mode population_name: "my_example_model" label_name: "my_label"
ה-ODP מטפל ב-DP באופן אוטומטי בתהליך הלמידה. לכן, אין צורך להוסיף רעשי רקע כשיוצרים את המודל הפונקציונלי.
הפלט של המודל הפונקציונלי השמור הזה צריך להיראות כמו הדוגמה במאגר שלנו ב-GitHub.
שלב 2. יצירת ההגדרה של כלי ליצירת משימות
דוגמאות להגדרת כלי בניית המשימות זמינות במאגר GitHub שלנו.
מדדים של אימון והערכה
יכול להיות שהמדדים יכללו נתוני משתמשים, ולכן בבונה המשימות תופיע רשימה של מדדים שתהליך הלמידה יכול ליצור ולפרסם. הרשימה המלאה מופיעה במאגר שלנו ב-GitHub.
הנה רשימת מדדים לדוגמה כשיוצרים הגדרה חדשה של כלי ליצירת משימות:
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" } } }
אם המדדים שמעניינים אתכם לא מופיעים ברשימה הנוכחית, אתם יכולים לפנות אלינו.
הגדרות DP
יש כמה הגדרות שקשורות ל-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או אתnoise_mulitipiler: (noise_to_epsilonepislon_to_noise). - הגדרות ברירת המחדל האלה מפורטות במאגר שלנו ב-GitHub.
- כדי שהאימות יצליח, צריך לציין את
שלב 3. מעלים את המודל השמור ואת ההגדרה של כלי יצירת המשימות לאחסון בענן של כל מפתח
כשמעלים את ההגדרה של כלי ליצירת משימות, חשוב לזכור לעדכן את השדות artifact_building.
שלב 4. (אופציונלי) בדיקת בניית ארטיפקט בלי ליצור משימה חדשה
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}
המודל לדוגמה מאומת באמצעות בדיקת פעולות גמישות ובדיקת dp. אפשר להוסיף skip_flex_ops_check ו-skip_dp_check כדי לעקוף את האימות (אי אפשר לפרוס את המודל הזה בגרסה הנוכחית של לקוח ODP בגלל כמה פעולות גמישות חסרות).
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: ספריית האופרטורים המובנית של TensorFlow Lite תומכת רק במספר מוגבל של אופרטורים של TensorFlow (תאימות של אופרטורים של TensorFlow ו-TensorFlow Lite). צריך להתקין את כל פעולות TensorFlow הלא תואמות באמצעות נציג ה-Flex (Android.bp). אם מודל מכיל פעולות שאין להן תמיכה, אפשר לפנות אלינו כדי לרשום אותן:
Cannot build the ClientOnlyPlan: Please contact Google to register these ops: {...}הדרך הכי טובה לנפות באגים בכלי ליצירת משימות היא להפעיל אותו באופן מקומי:
# 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
אפשר למצוא את הארטיפקטים שנוצרו באחסון הענן שצוין בהגדרה. הוא אמור להיראות כמו הדוגמה במאגר שלנו ב-GitHub.
שלב 5. יצירת ארטיפקטים ויצירה של צמד חדש של משימות אימון והערכה בשרת FCP.
מסירים את הדגל build_artifact_only והארטיפקטים שנבנו יועלו לשרת FCP. צריך לוודא שנוצרו בהצלחה זוג משימות של אימון והערכה
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}
שלב 6. הכנה של הצד של הלקוח ל-FCP
- מטמיעים את ODP public API
IsolatedWorker#onTrainingExamplesכדי ליצור נתוני אימון. - קוראים לפונקציה
FederatedComputeScheduler#schedule. - כאן אפשר למצוא כמה דוגמאות במאגר המקור של Android.
שלב 7. מעקב
מדדי השרת
הוראות ההגדרה זמינות במאגר שלנו ב-GitHub.
- מדדי המודל
אפשר להשוות בין מדדים מהרצות שונות בדיאגרמה אחת. לדוגמה:
- הקו הסגול הוא עם
noise_multiplier0.1 - הקו הוורוד הוא עם
noise_multipiler0.3