Wysokowydajna symulacja z Kubernetes

W tym samouczku opiszemy, jak skonfigurować wysokowydajną symulację przy użyciu środowiska wykonawczego TFF działającego na Kubernetes. Model ten jest taki sam jak w poprzednim ćwiczeniu, symulacje wysokiej wydajności z TFF. Jedyną różnicą jest to, że tutaj używamy puli pracowników zamiast lokalnego executora.

Ten poradnik odnosi się do Google Cloud za GKE stworzyć klaster Kubernetes, ale wszystkie kroki po klaster jest tworzony może być używany z dowolnym instalacji Kubernetes.

Zobacz na TensorFlow.org Uruchom w Google Colab Wyświetl źródło na GitHub Pobierz notatnik

Uruchom pracowników TFF w GKE

Utwórz klaster Kubernetes

Następny krok należy wykonać tylko raz. Klaster można ponownie wykorzystać do przyszłych obciążeń.

Postępuj zgodnie z instrukcjami GKE aby utworzyć klaster kontenera . Reszta tego samouczka zakłada, że klaster jest nazwany tff-cluster , ale rzeczywista nazwa nie jest ważna. Zatrzymaj postępując zgodnie z instrukcjami, kiedy dojdziesz do „Krok 5: Wdrażanie aplikacji”.

Wdróż aplikację TFF Worker

Polecenia do interakcji z GCP można uruchomić lokalnie lub w chmurze Shell Google . Zalecamy Google Cloud Shell, ponieważ nie wymaga dodatkowej konfiguracji.

  1. Uruchom następujące polecenie, aby uruchomić aplikację Kubernetes.
$ kubectl create deployment tff-workers --image=gcr.io/tensorflow-federated/remote-executor-service:latest
  1. Dodaj system równoważenia obciążenia dla aplikacji.
$ kubectl expose deployment tff-workers --type=LoadBalancer --port 80 --target-port 8000

Wyszukaj adres IP modułu równoważenia obciążenia w Google Cloud Console. Będzie on potrzebny później, aby połączyć pętlę treningową z aplikacją pracownika.

(Alternatywnie) Uruchom kontener Docker lokalnie

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

Skonfiguruj środowisko TFF

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

import nest_asyncio
nest_asyncio.apply()

Zdefiniuj model do trenowania

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

Konfiguracja zdalnych wykonawców

Domyślnie TFF wykonuje wszystkie obliczenia lokalnie. W tym kroku mówimy TFF, aby łączył się z usługami Kubernetes, które skonfigurowaliśmy powyżej. Pamiętaj, aby skopiować tutaj adres IP swojej usługi.

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)

Trening biegowy

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