การจำลองประสิทธิภาพสูงด้วย Kubernetes

บทช่วยสอนนี้จะอธิบายวิธีตั้งค่าการจำลองประสิทธิภาพสูงโดยใช้รันไทม์ TFF ที่ทำงานบน Kubernetes รูปแบบที่เป็นเช่นเดียวกับในการกวดวิชาก่อนหน้านี้แบบจำลองที่มีประสิทธิภาพสูงกับฉิบหาย ข้อแตกต่างเพียงอย่างเดียวคือที่นี่เราใช้พูลผู้ปฏิบัติงานแทนตัวดำเนินการในเครื่อง

กวดวิชานี้จะหมายถึง Google Cloud ของ GKE การสร้างคลัสเตอร์ Kubernetes แต่ทุกขั้นตอนหลังจากที่กลุ่มจะถูกสร้างขึ้นสามารถนำมาใช้กับการติดตั้ง Kubernetes

ดูบน TensorFlow.org

ทำงานใน Google Colab

ดูแหล่งที่มาบน GitHub

ดาวน์โหลดโน๊ตบุ๊ค

เปิดตัว TFF Workers บน GKE

สร้างคลัสเตอร์ Kubernetes

ขั้นตอนต่อไปนี้ต้องทำเพียงครั้งเดียว คลัสเตอร์สามารถนำกลับมาใช้ใหม่สำหรับปริมาณงานในอนาคต

ทำตามคำแนะนำ GKE เพื่อ สร้างคลัสเตอร์ภาชนะ ส่วนที่เหลือของการกวดวิชานี้อนุมานว่าคลัสเตอร์เป็นชื่อ tff-cluster แต่ชื่อจริงนั้นไม่สำคัญ หยุดทำตามคำแนะนำเมื่อคุณได้รับ "ขั้นตอนที่ 5: การปรับใช้แอพลิเคชันของคุณ"

ปรับใช้แอปพลิเคชัน TFF Worker

คำสั่งในการโต้ตอบกับ GCP สามารถทำงาน ในประเทศ หรือใน ระบบคลาวด์ของ Google เชลล์ เราขอแนะนำ 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 Environment

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

ตั้งค่า Remote Executors

โดยค่าเริ่มต้น 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