หน้านี้ได้รับการแปลโดย Cloud Translation API
Switch to English

แกนกลาง

เอกสารนี้แนะนำเลเยอร์หลักของ TFF ที่ทำหน้าที่เป็นรากฐานสำหรับ การ เรียนรู้แบบรวมศูนย์และอัลกอริทึมแบบสหพันธ์ที่ไม่ได้เรียนรู้ในอนาคตที่เป็นไปได้

สำหรับข้อมูลเบื้องต้นเกี่ยวกับ Federated Core โปรดอ่านบทช่วยสอนต่อไปนี้เนื่องจากแนะนำแนวคิดพื้นฐานบางส่วนตามตัวอย่างและสาธิตการสร้างอัลกอริทึมการหาค่าเฉลี่ยแบบรวมทีละขั้น

นอกจากนี้เราขอแนะนำให้คุณทำความคุ้นเคยกับ การเรียนรู้แบบรวมศูนย์ และแบบฝึกหัดที่เกี่ยวข้องเกี่ยวกับการ จำแนกรูปภาพ และการ สร้างข้อความ เนื่องจากการใช้ Federated Core API (FC API) สำหรับการเรียนรู้แบบรวมศูนย์ให้บริบทที่สำคัญสำหรับตัวเลือกบางอย่างที่เราได้ทำไว้ การออกแบบเลเยอร์นี้

ภาพรวม

เป้าหมายการใช้งานที่ตั้งใจไว้และขอบเขต

Federated Core (FC) เป็นที่เข้าใจได้ดีที่สุดว่าเป็นสภาพแวดล้อมการเขียนโปรแกรมสำหรับการใช้งานการคำนวณแบบกระจายกล่าวคือการคำนวณที่เกี่ยวข้องกับคอมพิวเตอร์หลายเครื่อง (โทรศัพท์มือถือแท็บเล็ตอุปกรณ์ฝังตัวคอมพิวเตอร์เดสก์ท็อปเซ็นเซอร์เซิร์ฟเวอร์ฐานข้อมูล ฯลฯ ) ซึ่งแต่ละเครื่องอาจไม่ทำงาน การประมวลผลเล็กน้อยในพื้นที่และสื่อสารผ่านเครือข่ายเพื่อประสานงานของพวกเขา

คำที่ กระจาย เป็นคำทั่วไปมากและ TFF ไม่ได้กำหนดเป้าหมายของอัลกอริทึมแบบกระจายที่เป็นไปได้ทุกประเภทดังนั้นเราจึงต้องการใช้คำทั่วไปที่ไม่ รวมการคำนวณแบบรวม เพื่ออธิบายประเภทของอัลกอริทึมที่สามารถแสดงในเฟรมเวิร์กนี้

แม้ว่าการกำหนดคำว่า การคำนวณแบบรวมศูนย์ ในลักษณะที่เป็นทางการโดยสมบูรณ์นั้นอยู่นอกขอบเขตของเอกสารนี้ให้นึกถึงประเภทของอัลกอริทึมที่คุณอาจเห็นในรหัสเทียมใน สิ่งพิมพ์งานวิจัย ที่อธิบายอัลกอริทึมการเรียนรู้แบบกระจายใหม่

เป้าหมายของ FC โดยสรุปคือการเปิดใช้งานการแสดงที่กะทัดรัดในระดับเดียวกันในระดับนามธรรมที่คล้ายกับรหัสเทียมที่คล้ายกันของลอจิกโปรแกรมที่ ไม่ใช่ รหัสเทียม แต่สามารถเรียกใช้งานได้ในสภาพแวดล้อมเป้าหมายที่หลากหลาย

ลักษณะการกำหนดที่สำคัญของประเภทของอัลกอริทึมที่ FC ได้รับการออกแบบมาเพื่อแสดงออกคือการกระทำของผู้เข้าร่วมระบบจะอธิบายในลักษณะรวม ดังนั้นเราจึงมักจะพูดถึง อุปกรณ์แต่ละเครื่อง ในการแปลงข้อมูลและอุปกรณ์ที่ประสานงานกันโดยผู้ประสานงานส่วนกลางที่ กระจายเสียง รวบรวม หรือ รวบรวม ผลลัพธ์

ในขณะที่ TFF ได้รับการออกแบบมาเพื่อให้สามารถใช้งานได้เหนือกว่าสถาปัตยกรรม ไคลเอนต์เซิร์ฟเวอร์ที่ เรียบง่าย แต่แนวคิดของการประมวลผลแบบรวมเป็นพื้นฐาน นี่เป็นเพราะต้นกำเนิดของ TFF ในการเรียนรู้แบบรวมศูนย์ซึ่งเป็นเทคโนโลยีที่ออกแบบมาเพื่อรองรับการคำนวณข้อมูลที่อาจมีความอ่อนไหวซึ่งยังคงอยู่ภายใต้การควบคุมของอุปกรณ์ไคลเอนต์และอาจไม่เพียงดาวน์โหลดไปยังตำแหน่งส่วนกลางด้วยเหตุผลด้านความเป็นส่วนตัว ในขณะที่ลูกค้าแต่ละรายในระบบดังกล่าวมีส่วนช่วยในการประมวลผลข้อมูลและพลังในการประมวลผลโดยระบบ (ซึ่งโดยทั่วไปเราคาดว่าจะมีคุณค่าสำหรับผู้เข้าร่วมทั้งหมด) เรายังพยายามรักษาความเป็นส่วนตัวและการไม่เปิดเผยตัวตนของลูกค้าแต่ละราย

ดังนั้นในขณะที่เฟรมเวิร์กส่วนใหญ่สำหรับการประมวลผลแบบกระจายได้รับการออกแบบมาเพื่อแสดงการประมวลผลจากมุมมองของผู้เข้าร่วมแต่ละคนนั่นคือในระดับของการแลกเปลี่ยนข้อความแบบจุดต่อจุดแต่ละรายการและการพึ่งพาซึ่งกันและกันของการเปลี่ยนสถานะท้องถิ่นของผู้เข้าร่วมด้วยข้อความขาเข้าและขาออก , Federated Core ของ TFF ได้รับการออกแบบมาเพื่ออธิบายลักษณะการทำงานของระบบจากมุมมองของระบบ ทั่วโลก (เช่นเดียวกับเช่น MapReduce )

ดังนั้นในขณะที่เฟรมเวิร์กแบบกระจายเพื่อวัตถุประสงค์ทั่วไปอาจนำเสนอการดำเนินการเช่นการ ส่ง และ รับ เป็นแบบเอกสารสำเร็จรูป FC จัดเตรียมแบบเอกสารสำเร็จรูปเช่น tff.federated_sum , tff.federated_reduce หรือ tff.federated_broadcast ที่ห่อหุ้มโปรโตคอลแบบกระจายอย่างง่าย

ภาษา

อินเตอร์เฟซ Python

TFF ใช้ภาษาภายในเพื่อแสดงการคำนวณแบบรวมซึ่งเป็นไวยากรณ์ที่กำหนดโดยการแทนค่าแบบอนุกรมใน computation.proto ผู้ใช้ FC API โดยทั่วไปไม่จำเป็นต้องโต้ตอบกับภาษานี้โดยตรง แต่เรามี Python API (เนมสเปซ tff ) ที่ล้อมรอบเป็นวิธีกำหนดการคำนวณ

โดยเฉพาะอย่างยิ่ง TFF มีมัณฑนากรฟังก์ชัน Python เช่น tff.federated_computation ที่ติดตามเนื้อความของฟังก์ชันที่ได้รับการตกแต่งและสร้างการแสดงผลแบบอนุกรมของตรรกะการคำนวณแบบรวมศูนย์ในภาษาของ TFF ฟังก์ชันที่ตกแต่งด้วย tff.federated_computation จะทำหน้าที่เป็นพาหะของการแทนค่าแบบอนุกรมดังกล่าวและสามารถฝังไว้เป็น tff.federated_computation ในเนื้อความของการคำนวณอื่นหรือดำเนินการตามความต้องการเมื่อเรียกใช้

นี่เป็นเพียงตัวอย่างเดียว สามารถดูตัวอย่างเพิ่มเติมได้ในบทแนะนำ อัลกอริทึมที่กำหนดเอง

@tff.federated_computation(tff.type_at_clients(tf.float32))
def get_average_temperature(sensor_readings):
  return tff.federated_mean(sensor_readings)

ผู้อ่านที่คุ้นเคยกับ TensorFlow ที่ไม่กระตือรือร้นจะพบว่าแนวทางนี้คล้ายคลึงกับการเขียนโค้ด Python ที่ใช้ฟังก์ชันเช่น tf.add หรือ tf.reduce_sum ในส่วนของโค้ด Python ที่กำหนดกราฟ TensorFlow แม้ว่าโค้ดจะถูกแสดงในทางเทคนิคใน Python แต่จุดประสงค์ของมันคือเพื่อสร้างการแทนค่า tf.Graph เป็น tf.Graph อยู่ด้านล่างและเป็นกราฟไม่ใช่โค้ด Python ที่รันภายในโดยรันไทม์ TensorFlow ในทำนองเดียวกันเราสามารถคิดว่า tff.federated_mean เป็นการแทรกหน่วยปฏิบัติการ รวม ลงในการคำนวณแบบรวมศูนย์ที่แสดงโดย get_average_temperature

เหตุผลส่วนหนึ่งสำหรับ FC ในการกำหนดภาษานั้นเกี่ยวข้องกับข้อเท็จจริงที่ว่าตามที่ระบุไว้ข้างต้นการคำนวณแบบรวมศูนย์ระบุพฤติกรรมร่วมแบบกระจายดังนั้นตรรกะของพวกเขาจึงไม่ใช่แบบโลคัล ตัวอย่างเช่น TFF มีตัวดำเนินการอินพุตและเอาต์พุตซึ่งอาจมีอยู่ในตำแหน่งต่างๆในเครือข่าย

สิ่งนี้เรียกร้องภาษาและระบบประเภทที่จับความคิดของการกระจาย

พิมพ์ระบบ

Federated Core มีประเภทต่างๆดังต่อไปนี้ ในการอธิบายประเภทเหล่านี้เราจะชี้ไปที่ตัวสร้างประเภทพร้อมทั้งแนะนำสัญกรณ์ขนาดกะทัดรัดเนื่องจากเป็นวิธีที่สะดวกหรืออธิบายประเภทของการคำนวณและตัวดำเนินการ

อันดับแรกนี่คือประเภทของประเภทที่มีแนวคิดคล้ายกับที่พบในภาษากระแสหลักที่มีอยู่:

  • ประเภทของเทนเซอร์ ( tff.TensorType ) เช่นเดียวกับใน TensorFlow สิ่งเหล่านี้มี dtype และ shape ข้อแตกต่างเพียงอย่างเดียวคือออบเจ็กต์ประเภทนี้ไม่ จำกัด เฉพาะอินสแตนซ์ tf.Tensor อินสแตนซ์ใน Python ที่แสดงผลลัพธ์ของ TensorFlow ops ในกราฟ TensorFlow แต่อาจรวมถึงหน่วยของข้อมูลที่สามารถสร้างได้เช่นเป็นเอาต์พุตของการกระจาย โปรโตคอลการรวม ดังนั้นประเภท TFF เทนเซอร์จึงเป็นเพียงรูปแบบนามธรรมของการแสดงทางกายภาพที่เป็นรูปธรรมของประเภทดังกล่าวใน Python หรือ TensorFlow

    สัญกรณ์ขนาดกะทัดรัดสำหรับชนิดเทนเซอร์คือ dtype หรือ dtype[shape] ตัวอย่างเช่น int32 และ int32[10] เป็นประเภทของจำนวนเต็มและเวกเตอร์ int ตามลำดับ

  • ประเภทลำดับ ( tff.SequenceType ) สิ่งเหล่านี้เทียบเท่านามธรรมของ TFF กับแนวคิดที่เป็นรูปธรรมของ tf.data.Dataset เกี่ยวกับ tf.data.Dataset s องค์ประกอบของลำดับสามารถใช้ในลักษณะตามลำดับและสามารถรวมประเภทที่ซับซ้อนได้

    การแสดงประเภทลำดับอย่างกะทัดรัดคือ T* โดยที่ T คือประเภทขององค์ประกอบ ตัวอย่างเช่น int32* แสดงถึงลำดับจำนวนเต็ม

  • ชื่อประเภททูเปิล ( tff.StructType ) นี่คือวิธีของ TFF ในการสร้างสิ่งทอและโครงสร้างแบบพจนานุกรมที่มีจำนวน องค์ประกอบที่ กำหนดไว้ล่วงหน้าซึ่งมีประเภทเฉพาะตั้งชื่อหรือไม่มีชื่อ ที่สำคัญแนวคิด tuple ของ TFF นั้นครอบคลุมสิ่งที่เทียบเท่ากับสิ่งที่เป็นนามธรรมของสิ่งที่เป็นนามธรรมของ Python นั่นคือชุดขององค์ประกอบที่มีการตั้งชื่อบางส่วน แต่ไม่ใช่ทั้งหมดและบางส่วนเป็นตำแหน่ง

    สัญกรณ์ขนาดกะทัดรัดสำหรับสิ่งที่ตั้งชื่อคือ <n_1=T_1, ..., n_k=T_k> โดยที่ n_k เป็นชื่อองค์ประกอบที่เป็นทางเลือกและ T_k เป็นประเภทองค์ประกอบ ตัวอย่างเช่น <int32,int32> เป็นสัญกรณ์ขนาดกะทัดรัดสำหรับคู่ของจำนวนเต็มที่ไม่มีชื่อและ <X=float32,Y=float32> เป็นสัญกรณ์ขนาดกะทัดรัดสำหรับคู่ลอยชื่อ X และ Y ที่อาจแสดงถึงจุดบนระนาบ . Tuples สามารถซ้อนกันและผสมกับประเภทอื่น ๆ ได้เช่น <X=float32,Y=float32>* จะเป็นสัญกรณ์ที่กะทัดรัดสำหรับลำดับของจุด

  • ประเภทฟังก์ชัน ( tff.FunctionType ) TFF เป็นเฟรมเวิร์กการเขียนโปรแกรมเชิงฟังก์ชันโดยฟังก์ชันที่ถือว่าเป็น ค่าชั้น หนึ่ง ฟังก์ชันมีอาร์กิวเมนต์ไม่เกินหนึ่งรายการและผลลัพธ์เดียวเท่านั้น

    สัญกรณ์ที่กระชับสำหรับฟังก์ชันคือ (T -> U) โดยที่ T คือประเภทของอาร์กิวเมนต์และ U คือประเภทของผลลัพธ์หรือ ( -> U) หากไม่มีอาร์กิวเมนต์ (แม้ว่าฟังก์ชันที่ไม่มีอาร์กิวเมนต์จะเป็นค่าเสื่อม แนวคิดที่มีอยู่ส่วนใหญ่ในระดับ Python) ตัวอย่างเช่น (int32* -> int32) เป็นสัญกรณ์สำหรับประเภทของฟังก์ชันที่ลดลำดับจำนวนเต็มเป็นค่าจำนวนเต็มเดียว

ประเภทต่อไปนี้กล่าวถึงแง่มุมของระบบแบบกระจายของการคำนวณ TFF เนื่องจากแนวคิดเหล่านี้ค่อนข้างเฉพาะสำหรับ TFF เราขอแนะนำให้คุณดูบทแนะนำ อัลกอริทึมที่กำหนดเอง สำหรับคำอธิบายและตัวอย่างเพิ่มเติม

  • ประเภทตำแหน่ง ประเภทนี้ยังไม่ถูกเปิดเผยใน API สาธารณะนอกเหนือจากรูปแบบ 2 ตัวอักษร tff.SERVER และ tff.CLIENTS ที่คุณคิดว่าเป็นค่าคงที่ของประเภทนี้ อย่างไรก็ตามมีการใช้งานภายในและจะเปิดตัวใน API สาธารณะในอนาคต การแสดงประเภทนี้อย่างกะทัดรัดคือการ placement

    ตำแหน่ง แสดงถึงกลุ่มผู้เข้าร่วมระบบที่มีบทบาทเฉพาะ รุ่นแรกกำหนดเป้าหมายการคำนวณไคลเอนต์เซิร์ฟเวอร์ซึ่งมีผู้เข้าร่วม 2 กลุ่มคือ ไคลเอนต์ และ เซิร์ฟเวอร์ (คุณสามารถคิดว่ากลุ่มหลังเป็นกลุ่มซิงเกิลตัน) อย่างไรก็ตามในสถาปัตยกรรมที่ซับซ้อนมากขึ้นอาจมีบทบาทอื่น ๆ เช่นตัวรวบรวมระดับกลางในระบบแบบหลายชั้นซึ่งอาจดำเนินการการรวมประเภทต่างๆหรือใช้การบีบอัด / คลายการบีบอัดข้อมูลประเภทต่างๆมากกว่าที่เซิร์ฟเวอร์ใช้หรือ ลูกค้า

    จุดประสงค์หลักของการกำหนดแนวคิดของตำแหน่งเป็นพื้นฐานสำหรับการกำหนด ประเภทแบบรวม

  • ประเภทรวมศูนย์ ( tff.FederatedType ) ค่าของชนิด federated คือค่าที่โฮสต์โดยกลุ่มผู้เข้าร่วมระบบที่กำหนดโดยตำแหน่งเฉพาะ (เช่น tff.SERVER หรือ tff.CLIENTS ) ประเภทรวมถูกกำหนดโดยค่า ตำแหน่ง (ดังนั้นจึงเป็น ประเภทที่ขึ้นต่อกัน ) ประเภทของ องค์ประกอบ ของ สมาชิก (ประเภทของเนื้อหาที่ผู้เข้าร่วมแต่ละคนโฮสต์ไว้ในเครื่อง) และบิตเพิ่มเติม all_equal ที่ระบุว่าผู้เข้าร่วมทั้งหมดอยู่ในพื้นที่หรือไม่ โฮสต์รายการเดียวกัน

    สัญกรณ์ขนาดกะทัดรัดสำหรับประเภท federated ของค่าที่รวมรายการ (คนละสมาชิก) ประเภท T แต่ละเจ้าภาพโดยกลุ่ม (ตำแหน่ง) G คือ T@G หรือ {T}@G กับ all_equal ชุดบิตหรือไม่ได้ตั้งค่าตามลำดับ

    ตัวอย่างเช่น:

    • {int32}@CLIENTS หมายถึง ค่าแบบรวม ที่ประกอบด้วยชุดของจำนวนเต็มที่อาจแตกต่างกันหนึ่งชุดต่ออุปกรณ์ไคลเอ็นต์ โปรดทราบว่าเรากำลังพูดถึง ค่าที่รวมกัน เพียง ค่า เดียวโดยรวมข้อมูลหลายรายการที่ปรากฏในหลายตำแหน่งทั่วทั้งเครือข่าย วิธีหนึ่งในการคิดเกี่ยวกับเรื่องนี้ก็คือเป็นเทนเซอร์ชนิดหนึ่งที่มีมิติข้อมูล "เครือข่าย" แม้ว่าการเปรียบเทียบนี้จะไม่สมบูรณ์แบบเนื่องจาก TFF ไม่อนุญาตให้มี การเข้าถึงโดยสุ่ม ไปยังองค์ประกอบของสมาชิกที่มีมูลค่ารวม

    • {<X=float32,Y=float32>*}@CLIENTS แสดงถึง ชุดข้อมูลแบบรวม ค่าที่ประกอบด้วยพิกัด XY หลายลำดับโดยหนึ่งลำดับต่ออุปกรณ์ไคลเอ็นต์

    • <weights=float32[10,5],bias=float32[5]>@SERVER แสดงชื่อทูเพิลของน้ำหนักและเทนเซอร์ไบแอสที่เซิร์ฟเวอร์ เนื่องจากเราได้ทิ้งวงเล็บปีกกาสิ่งนี้บ่งชี้ว่ามีการตั้งค่าบิต all_equal กล่าวคือมีเพียงทูเปิลเดียว (ไม่ว่าจะมีเซิร์ฟเวอร์จำลองจำนวนเท่าใดในคลัสเตอร์ที่โฮสต์ค่านี้)

การก่อสร้างตึก

ภาษาของ Federated Core เป็นรูปแบบของ แลมบ์ดา - แคลคูลัส ซึ่งมีองค์ประกอบเพิ่มเติมบางส่วน

มันมี abstractions การเขียนโปรแกรมต่อไปนี้ที่เปิดเผยใน API สาธารณะในปัจจุบัน:

  • การคำนวณ TensorFlow ( tff.tf_computation ) นี่คือส่วนของโค้ด TensorFlow ที่ห่อหุ้มเป็นส่วนประกอบที่ใช้ซ้ำได้ใน TFF โดยใช้มัณฑนากร tff.tf_computation พวกเขามีประเภทการทำงานเสมอและต่างจากฟังก์ชันใน TensorFlow คือสามารถรับพารามิเตอร์ที่มีโครงสร้างหรือส่งคืนผลลัพธ์ที่มีโครงสร้างของประเภทลำดับได้

    นี่คือตัวอย่างหนึ่งการคำนวณ TF ประเภท (int32* -> int) ที่ใช้ตัวดำเนินการ tf.data.Dataset.reduce เพื่อคำนวณผลรวมของจำนวนเต็ม:

    @tff.tf_computation(tff.SequenceType(tf.int32))
    def add_up_integers(x):
      return x.reduce(np.int32(0), lambda x, y: x + y)
    
  • Intrinsics หรือ ตัวดำเนินการแบบรวม ( tff.federated_... ) นี่คือไลบรารีของฟังก์ชันเช่น tff.federated_sum หรือ tff.federated_broadcast ที่ประกอบด้วย FC API จำนวนมากซึ่งส่วนใหญ่เป็นตัวแทนของตัวดำเนินการสื่อสารแบบกระจายสำหรับใช้กับ TFF

    เราเรียกสิ่งเหล่านี้ว่าเป็นอินท รินซิค เพราะค่อนข้างเหมือน ฟังก์ชันภายใน คือเป็นชุดโอเปอเรเตอร์ปลายเปิดที่ขยายได้ซึ่ง TFF เข้าใจและรวบรวมลงในโค้ดระดับล่าง

    ตัวดำเนินการเหล่านี้ส่วนใหญ่มีพารามิเตอร์และผลลัพธ์เป็นชนิดรวมและส่วนใหญ่เป็นเทมเพลตที่สามารถนำไปใช้กับข้อมูลประเภทต่างๆ

    ตัวอย่างเช่น tff.federated_broadcast สามารถคิดได้ว่าเป็นตัวดำเนินการแม่แบบของฟังก์ชัน T@SERVER -> T@CLIENTS

  • นิพจน์แลมบ์ดา ( tff.federated_computation ) นิพจน์แลมด้าใน TFF เทียบเท่ากับ lambda หรือ def ใน Python ประกอบด้วยชื่อพารามิเตอร์และเนื้อหา (นิพจน์) ที่มีการอ้างอิงถึงพารามิเตอร์นี้

    ในโค้ด Python สิ่งเหล่านี้สามารถสร้างได้โดยการตกแต่งฟังก์ชัน Python ด้วย tff.federated_computation และกำหนดอาร์กิวเมนต์

    นี่คือตัวอย่างของนิพจน์แลมบ์ดาที่เราได้กล่าวไปแล้วก่อนหน้านี้:

    @tff.federated_computation(tff.type_at_clients(tf.float32))
    def get_average_temperature(sensor_readings):
      return tff.federated_mean(sensor_readings)
    
  • ตำแหน่งตามตัวอักษร สำหรับตอนนี้มีเพียง tff.SERVER และ tff.CLIENTS ที่อนุญาตให้กำหนดการคำนวณไคลเอนต์เซิร์ฟเวอร์แบบง่าย

  • การเรียกใช้ฟังก์ชัน ( __call__ ) สิ่งใดก็ตามที่มีประเภทการทำงานสามารถเรียกใช้โดยใช้ไวยากรณ์ Python __call__ มาตรฐาน การเรียกใช้คือนิพจน์ซึ่งเป็นประเภทเดียวกับชนิดของผลลัพธ์ของฟังก์ชันที่เรียกใช้

    ตัวอย่างเช่น:

    • add_up_integers(x) แสดงถึงการเรียกใช้การคำนวณ TensorFlow ที่กำหนดไว้ก่อนหน้านี้บนอาร์กิวเมนต์ x ประเภทของนิพจน์นี้คือ int32

    • tff.federated_mean(sensor_readings) แสดงถึงการเรียกใช้ตัวดำเนินการแบบรวมค่าเฉลี่ยบน sensor_readings ประเภทของนิพจน์นี้คือ float32@SERVER (สมมติบริบทจากตัวอย่างด้านบน)

  • การขึ้นรูป tuples และเลือกองค์ประกอบของพวกเขา นิพจน์ Python ของรูปแบบ [x, y] , x[y] หรือ xy ที่ปรากฏในเนื้อความของฟังก์ชันที่ตกแต่งด้วย tff.federated_computation