הדמיה בעלת ביצועים גבוהים עם Kubernetes

מדריך זה יתאר כיצד להגדיר סימולציה בעלת ביצועים גבוהים באמצעות זמן ריצה TFF הפועל על Kubernetes. המודל הוא זהה ב קודמת הדרכה, סימולציות ביצועים גבוהים עם TFF. ההבדל היחיד הוא שכאן אנו משתמשים במאגר עובדים במקום במבצע מקומי.

הדרכה זו מתייחסת של Google Cloud GKE ליצור באשכול Kubernetes, אבל כל השלבים לאחר באשכול נוצר ניתן להשתמש עם כל התקנה Kubernetes.

הצג באתר TensorFlow.org הפעל בגוגל קולאב צפה במקור ב-GitHub הורד מחברת

הפעל את TFF Workers ב-GKE

צור אשכול Kubernetes

השלב הבא צריך להיעשות רק פעם אחת. ניתן לעשות שימוש חוזר באשכול לעומסי עבודה עתידיים.

פעל על פי הוראות GKE כדי ליצור אשכול מיכל . שאר הדרכה זו מניחה כי באשכול נקרא tff-cluster , אבל השם האמיתי הוא לא חשוב. עצור ביצוע ההוראות כשתגיע "שלב 5: לפרוס את הבקשה".

פרוס את אפליקציית TFF Worker

הפקודות לאינטראקציה עם GCP ניתן להפעיל באופן מקומי או Google Cloud Shell . אנו ממליצים על Google Cloud Shell מכיוון שהיא אינה דורשת הגדרה נוספת.

  1. הפעל את הפקודה הבאה כדי להפעיל את יישום Kubernetes.
$ kubectl create deployment tff-workers --image=gcr.io/tensorflow-federated/remote-executor-service:latest
  1. הוסף מאזן עומסים עבור היישום.
$ kubectl expose deployment tff-workers --type=LoadBalancer --port 80 --target-port 8000

חפש את כתובת ה-IP של מאזן העומס ב-Google Cloud Console. תזדקק לו מאוחר יותר כדי לחבר את לולאת ההדרכה לאפליקציית העובד.

(לחילופין) הפעל את ה-Docker Container באופן מקומי

$ docker run --rm -p 8000:8000 gcr.io/tensorflow-federated/remote-executor-service:latest

הגדר סביבת TFF

!pip install --quiet --upgrade tensorflow-federated-nightly
!pip install --quiet --upgrade nest-asyncio

import nest_asyncio
nest_asyncio.apply()

הגדר את הדגם לאימון

import collections
import time

import tensorflow as tf
import tensorflow_federated as tff

source, _ = tff.simulation.datasets.emnist.load_data()


def map_fn(example):
  return collections.OrderedDict(
      x=tf.reshape(example['pixels'], [-1, 784]), y=example['label'])


def client_data(n):
  ds = source.create_tf_dataset_for_client(source.client_ids[n])
  return ds.repeat(10).batch(20).map(map_fn)


train_data = [client_data(n) for n in range(10)]
input_spec = train_data[0].element_spec


def model_fn():
  model = tf.keras.models.Sequential([
      tf.keras.layers.InputLayer(input_shape=(784,)),
      tf.keras.layers.Dense(units=10, kernel_initializer='zeros'),
      tf.keras.layers.Softmax(),
  ])
  return tff.learning.from_keras_model(
      model,
      input_spec=input_spec,
      loss=tf.keras.losses.SparseCategoricalCrossentropy(),
      metrics=[tf.keras.metrics.SparseCategoricalAccuracy()])


trainer = tff.learning.build_federated_averaging_process(
    model_fn, client_optimizer_fn=lambda: tf.keras.optimizers.SGD(0.02))


def evaluate(num_rounds=10):
  state = trainer.initialize()
  for round in range(num_rounds):
    t1 = time.time()
    state, metrics = trainer.next(state, train_data)
    t2 = time.time()
    print('Round {}: loss {}, round time {}'.format(round, metrics.loss, t2 - t1))

הגדר את המבצעים המרוחקים

כברירת מחדל, TFF מבצע את כל החישובים באופן מקומי. בשלב זה אנו אומרים ל-TFF להתחבר לשירותי Kubernetes שהגדרנו למעלה. הקפד להעתיק את כתובת ה-IP של השירות שלך לכאן.

import grpc

ip_address = '0.0.0.0' 
port = 80 

channels = [grpc.insecure_channel(f'{ip_address}:{port}') for _ in range(10)]

tff.backends.native.set_remote_execution_context(channels)

אימון ריצה

evaluate()

Round 0: loss 4.370407581329346, round time 4.201097726821899
Round 1: loss 4.1407670974731445, round time 3.3283166885375977
Round 2: loss 3.865147590637207, round time 3.098310947418213
Round 3: loss 3.534019708633423, round time 3.1565616130828857
Round 4: loss 3.272688388824463, round time 3.175067663192749
Round 5: loss 2.935391664505005, round time 3.008434534072876
Round 6: loss 2.7399251461029053, round time 3.31435227394104
Round 7: loss 2.5054931640625, round time 3.4411356449127197
Round 8: loss 2.290508985519409, round time 3.158798933029175
Round 9: loss 2.1194536685943604, round time 3.1348156929016113