สหพันธ์การเรียนรู้

ภาพรวม

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

อินเทอร์เฟซที่เสนอโดยเลเยอร์นี้ประกอบด้วยส่วนสำคัญสามส่วนต่อไปนี้:

• โมเดล คลาสและฟังก์ชันตัวช่วยที่ให้คุณรวมโมเดลที่มีอยู่เพื่อใช้กับ TFF การรวมโมเดลสามารถทำได้ง่ายๆ เพียงแค่เรียกฟังก์ชันการรวมฟังก์ชันเดียว (เช่น tff.learning.models.from_keras_model ) หรือกำหนดคลาสย่อยของอินเทอร์เฟซ tff.learning.models.VariableModel เพื่อการปรับแต่งอย่างเต็มที่

• ผู้สร้างคอมพิวเตอร์ส่วนกลาง ฟังก์ชันตัวช่วยที่สร้างการคำนวณแบบรวมศูนย์สำหรับการฝึกอบรมหรือการประเมินผล โดยใช้โมเดลที่คุณมีอยู่

• ชุดข้อมูล คอลเลกชันข้อมูลกระป๋องที่คุณสามารถดาวน์โหลดและเข้าถึงใน Python เพื่อใช้ในการจำลองสถานการณ์การเรียนรู้แบบสมาพันธ์ แม้ว่าการเรียนรู้แบบรวมศูนย์ได้รับการออกแบบมาเพื่อใช้กับข้อมูลที่กระจายอำนาจซึ่งไม่สามารถดาวน์โหลดได้จากตำแหน่งที่ตั้งส่วนกลาง แต่ในขั้นตอนการวิจัยและพัฒนา มักสะดวกที่จะทำการทดลองเบื้องต้นโดยใช้ข้อมูลที่สามารถดาวน์โหลดและจัดการในเครื่องได้ โดยเฉพาะอย่างยิ่งสำหรับนักพัฒนาที่อาจ ใหม่สำหรับแนวทาง

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

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

โมเดล

สมมติฐานทางสถาปัตยกรรม

การทำให้เป็นอนุกรม

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

คุณสามารถ (และควร) ยังคงพัฒนารหัส TF ของคุณตามแนวทางปฏิบัติที่ดีที่สุดล่าสุด เช่น การใช้โหมดกระตือรือร้น อย่างไรก็ตาม รหัสสุดท้ายจะต้องทำให้เป็นอนุกรมได้ (เช่น สามารถรวมเป็น tf.function สำหรับรหัสโหมดกระตือรือร้น) สิ่งนี้ทำให้มั่นใจได้ว่าสถานะของ Python หรือโฟลว์การควบคุมที่จำเป็นในเวลาดำเนินการสามารถทำให้เป็นอนุกรมได้ (อาจด้วยความช่วยเหลือของ Autograph )

ปัจจุบัน TensorFlow ยังไม่รองรับการทำซีเรียลไลซ์และดีซีเรียลไลซ์โหมด TensorFlow อย่างเต็มที่ ดังนั้น การทำให้เป็นอันดับใน TFF ในปัจจุบันเป็นไปตามรูปแบบ TF 1.0 โดยที่โค้ดทั้งหมดต้องสร้างภายใน tf.Graph ที่ TFF ควบคุม ซึ่งหมายความว่า TFF ในปัจจุบันไม่สามารถใช้โมเดลที่สร้างไว้แล้วได้ แทน ตรรกะคำจำกัดความของโมเดลถูกบรรจุในฟังก์ชัน no-arg ที่ส่งคืน tff.learning.models.VariableModel ฟังก์ชันนี้จะถูกเรียกใช้โดย TFF เพื่อให้แน่ใจว่าส่วนประกอบทั้งหมดของโมเดลได้รับการต่ออนุกรม นอกจากนี้ เนื่องจากเป็นสภาพแวดล้อมที่มีการพิมพ์สูง TFF จึงต้องการ ข้อมูลเมตา เพิ่มเติมเล็กน้อย เช่น ข้อกำหนดของประเภทอินพุตของโมเดลของคุณ

การรวมตัว

เราขอแนะนำอย่างยิ่งให้ผู้ใช้ส่วนใหญ่สร้างโมเดลโดยใช้ Keras ดูส่วน Converters สำหรับ Keras ด้านล่าง Wrapper เหล่านี้จะจัดการการรวมการอัปเดตโมเดลรวมถึงเมตริกใดๆ ที่กำหนดไว้สำหรับโมเดลโดยอัตโนมัติ อย่างไรก็ตาม การทำความเข้าใจวิธีจัดการการรวมสำหรับ tff.learning.models.VariableModel ทั่วไปอาจยังมีประโยชน์

มีการรวมอย่างน้อยสองชั้นเสมอในการเรียนรู้แบบรวมศูนย์: การรวมภายในบนอุปกรณ์และการรวมข้ามอุปกรณ์ (หรือแบบรวมศูนย์):

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

  การดำเนินการรวมที่ระดับนี้เป็นความรับผิดชอบของโค้ดโมเดลของคุณ และทำได้โดยใช้โครงสร้าง TensorFlow มาตรฐาน

  โครงสร้างทั่วไปของการประมวลผลมีดังนี้:

  • อันดับแรก แบบจำลองจะสร้าง tf.Variable s เพื่อเก็บผลรวม เช่น จำนวนแบทช์หรือจำนวนตัวอย่างที่ประมวลผล ผลรวมของการสูญเสียต่อแบทช์หรือต่อตัวอย่าง เป็นต้น

  • TFF เรียกใช้เมธอด forward_pass บน Model ของคุณหลายครั้ง ตามลำดับบนชุดข้อมูลไคลเอ็นต์ที่ตามมา ซึ่งช่วยให้คุณอัปเดตตัวแปรที่เก็บข้อมูลรวมต่างๆ เป็นผลข้างเคียงได้

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

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

  การดำเนินการรวมในระดับนี้เป็นความรับผิดชอบของ TFF อย่างไรก็ตาม ในฐานะผู้สร้างโมเดล คุณสามารถควบคุมกระบวนการนี้ได้ (ข้อมูลเพิ่มเติมด้านล่าง)

  โครงสร้างทั่วไปของการประมวลผลมีดังนี้:

  • แบบจำลองเริ่มต้นและพารามิเตอร์ใดๆ ที่จำเป็นสำหรับการฝึกอบรม จะถูกกระจายโดยเซิร์ฟเวอร์ไปยังลูกค้ากลุ่มย่อยที่จะเข้าร่วมในรอบของการฝึกอบรมหรือการประเมินผล

  • ในไคลเอนต์แต่ละราย โค้ดโมเดลของคุณจะถูกเรียกใช้ซ้ำๆ บนสตรีมของชุดข้อมูลในเครื่องเพื่อสร้างพารามิเตอร์โมเดลชุดใหม่ (เมื่อฝึก) และเมตริกโลคัลชุดใหม่ตามที่อธิบายไว้ข้างต้น (นี่คือโลคัล การรวมตัว).

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

อินเทอร์เฟซนามธรรม

อินเทอร์ เฟซตัวสร้างพื้นฐาน + ข้อมูลเมตา นี้แสดงโดยอินเทอร์เฟซ tff.learning.models.VariableModel ดังนี้:

• เมธอด Constructor, forward_pass และ report_local_unfinalized_metrics ควรสร้างตัวแปรโมเดล, Forward Pass และสถิติที่คุณต้องการรายงานตามลำดับ TensorFlow ที่สร้างโดยวิธีเหล่านั้นจะต้องทำให้เป็นอนุกรมได้ดังที่กล่าวไว้ข้างต้น

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

นอกจากนี้ อินเทอร์เฟซนามธรรม tff.learning.models.VariableModel ยังเปิดเผยคุณสมบัติ metric_finalizers ที่รับค่าที่ยังไม่สรุปของเมตริก (ส่งกลับโดย report_local_unfinalized_metrics() ) และส่งคืนค่าเมตริกที่สรุปผลแล้ว metric_finalizers และ report_local_unfinalized_metrics() จะใช้ร่วมกันเพื่อสร้างตัวรวบรวมเมตริกข้ามไคลเอ็นต์เมื่อกำหนดกระบวนการฝึกอบรมแบบรวมศูนย์หรือการคำนวณการประเมิน ตัวอย่างเช่น ตัวรวบรวม tff.learning.metrics.sum_then_finalize อย่างง่ายจะรวมค่าเมตริกที่ยังไม่สรุปจากไคลเอ็นต์ก่อน จากนั้นจึงเรียกใช้ฟังก์ชัน Finalizer ที่เซิร์ฟเวอร์

คุณสามารถดูตัวอย่างวิธีกำหนด tff.learning.models.VariableModel ของคุณเองได้ในส่วนที่สองของบทช่วย สอนการจัดประเภทรูปภาพ รวมถึงในตัวอย่างโมเดลที่เราใช้สำหรับการทดสอบใน model_examples.py

ตัวแปลงสำหรับ Keras

ข้อมูลเกือบทั้งหมดที่ TFF ต้องการสามารถรับได้จากการเรียกอินเทอร์เฟ tf.keras ดังนั้นหากคุณมีโมเดล Keras คุณสามารถใช้ tff.learning.models.from_keras_model เพื่อสร้าง tff.learning.models.VariableModel

โปรดทราบว่า TFF ยังต้องการให้คุณระบุตัวสร้าง - ฟังก์ชันแบบจำลอง ที่ไม่มีข้อโต้แย้ง เช่น ต่อไปนี้:

def model_fn():
  keras_model = ...
  return tff.learning.models.from_keras_model(keras_model, sample_batch, loss=...)

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

การใช้ Keras wrappers แสดงไว้ในบทช่วยสอน การจัดประเภทรูปภาพ และ การสร้างข้อความ

ผู้สร้างคอมพิวเตอร์ส่วนกลาง

แพ็คเกจ tff.learning มีตัวสร้างหลายตัวสำหรับ tff.Computation ที่ทำงานเกี่ยวกับการเรียนรู้ เราคาดว่าชุดการคำนวณดังกล่าวจะขยายตัวในอนาคต

สมมติฐานทางสถาปัตยกรรม

การดำเนินการ

มีสองขั้นตอนที่แตกต่างกันในการรันการคำนวณแบบรวมศูนย์

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

• Execute TFF มีวิธีการ ดำเนิน การคำนวณเหล่านี้ สำหรับตอนนี้ การดำเนินการได้รับการสนับสนุนผ่านการจำลองในเครื่องเท่านั้น (เช่น ในโน้ตบุ๊กโดยใช้ข้อมูลจำลองแบบกระจายอำนาจ)

การคำนวณแบบรวมศูนย์ที่สร้างโดย Federated Learning API ของ TFF เช่น อัลกอริทึมการฝึกที่ใช้ การหาค่าเฉลี่ยแบบจำลองแบบรวมศูนย์ หรือการประเมินแบบรวมศูนย์ มีองค์ประกอบหลายอย่าง โดยเฉพาะอย่างยิ่ง:

• โค้ดโมเดลของคุณในรูปแบบซีเรียลไลซ์รวมถึงโค้ด TensorFlow เพิ่มเติมที่สร้างโดยเฟรมเวิร์ก Federated Learning เพื่อขับเคลื่อนลูปการฝึกอบรม/การประเมินโมเดลของคุณ (เช่น การสร้างเครื่องมือเพิ่มประสิทธิภาพ การใช้การอัปเดตโมเดล การวนซ้ำ tf.data.Dataset s และการคำนวณเมตริก และใช้การอัปเดตแบบรวมบนเซิร์ฟเวอร์ เป็นต้น)

• ข้อกำหนดที่เปิดเผยของการสื่อสารระหว่าง ไคลเอ็นต์ และ เซิร์ฟเวอร์ (โดยทั่วไปจะเป็นรูปแบบต่างๆ ของ การรวม ระหว่างอุปกรณ์ไคลเอ็นต์ และ การแพร่สัญญาณ จากเซิร์ฟเวอร์ไปยังไคลเอ็นต์ทั้งหมด) และวิธีการที่การสื่อสารแบบกระจายนี้สอดแทรกกับการดำเนินการไคลเอ็นต์-โลคัลหรือเซิร์ฟเวอร์-โลคัล ของรหัส TensorFlow

การคำนวณแบบรวมศูนย์ ที่แสดงในรูปแบบซีเรียลไลซ์นี้จะแสดงในภาษาภายในที่ไม่ขึ้นกับแพลตฟอร์มซึ่งแตกต่างจาก Python แต่หากต้องการใช้ Federated Learning API คุณไม่จำเป็นต้องกังวลเกี่ยวกับรายละเอียดของการแสดงข้อมูลนี้ การคำนวณจะแสดงในโค้ด Python ของคุณเป็นออบเจกต์ประเภท tff.Computation ซึ่งส่วนใหญ่คุณสามารถใช้เป็น Python ทึบแสง callable s

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

สถานะการสร้างแบบจำลอง

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

เนื่องจาก TFF ใช้งานได้ กระบวนการที่มีสถานะจะถูกสร้างแบบจำลองใน TFF เป็นการคำนวณที่ยอมรับสถานะปัจจุบันเป็นอินพุต จากนั้นให้สถานะที่อัปเดตเป็นเอาต์พุต เพื่อที่จะกำหนดกระบวนการที่มีสถานะอย่างสมบูรณ์ เราจำเป็นต้องระบุแหล่งที่มาของสถานะเริ่มต้นด้วย (ไม่เช่นนั้น เราจะไม่สามารถเริ่มต้นกระบวนการได้) สิ่งนี้ถูกบันทึกไว้ในนิยามของคลาสตัวช่วย tff.templates.IterativeProcess โดยมี 2 คุณสมบัติ initialize และ next ที่สอดคล้องกับการเริ่มต้นและการวนซ้ำตามลำดับ

ผู้สร้างที่มีอยู่

ในขณะนี้ TFF มีฟังก์ชันตัวสร้างต่างๆ ที่สร้างการคำนวณแบบรวมศูนย์สำหรับการฝึกอบรมและการประเมินแบบรวมศูนย์ ตัวอย่างที่โดดเด่น 2 ตัวอย่างได้แก่:

• tff.learning.algorithms.build_weighted_fed_avg ซึ่งใช้เป็นอินพุตของ ฟังก์ชันโมเดล tff.templates.IterativeProcess ไคลเอ็นต์เพิ่มประสิทธิภาพ และส่งคืน stateful tff.learning.templates.LearningProcess (ซึ่งคลาสย่อย

• tff.learning.build_federated_evaluation ใช้ ฟังก์ชันแบบจำลอง และส่งคืนการคำนวณแบบรวมศูนย์เดียวสำหรับการประเมินแบบจำลองแบบรวมศูนย์ เนื่องจากการประเมินไม่มีสถานะ

ชุดข้อมูล

สมมติฐานทางสถาปัตยกรรม

การเลือกลูกค้า

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

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

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

trainer = tff.learning.algorithms.build_weighted_fed_avg(...)
state = trainer.initialize()
federated_training_data = ...

def sample(federate_data):
  return ...

while True:
  data_for_this_round = sample(federated_training_data)
  result = trainer.next(state, data_for_this_round)
  state = result.state

เพื่ออำนวยความสะดวกนี้ เมื่อใช้ TFF ในการจำลอง ข้อมูลรวมจะได้รับการยอมรับเป็น Python list s โดยมีหนึ่งองค์ประกอบต่ออุปกรณ์ไคลเอ็นต์ที่เข้าร่วมเพื่อแสดงถึง tf.data.Dataset ภายในเครื่องของอุปกรณ์นั้น

อินเทอร์เฟซนามธรรม

เพื่อสร้างมาตรฐานการจัดการกับชุดข้อมูลส่วนกลางจำลอง TFF จัดเตรียมอินเทอร์เฟซแบบนามธรรม tff.simulation.datasets.ClientData ซึ่งอนุญาตให้ระบุชุดของไคลเอนต์ และสร้าง tf.data.Dataset ที่มีข้อมูลเฉพาะ ลูกค้า. tf.data.Dataset เหล่านั้นสามารถป้อนโดยตรงเป็นอินพุตไปยังการคำนวณแบบรวมศูนย์ที่สร้างขึ้นในโหมดกระตือรือร้น

ควรสังเกตว่าความสามารถในการเข้าถึงข้อมูลระบุตัวตนของไคลเอ็นต์เป็นคุณลักษณะที่จัดทำโดยชุดข้อมูลเพื่อใช้ในการจำลองเท่านั้น โดยอาจจำเป็นต้องใช้ความสามารถในการฝึกฝนข้อมูลจากชุดย่อยเฉพาะของไคลเอ็นต์ (เช่น เพื่อจำลองความพร้อมในแต่ละวันของข้อมูลต่างๆ ประเภทของลูกค้า) การคำนวณที่คอมไพล์แล้วและรันไทม์พื้นฐาน ไม่ เกี่ยวข้องกับแนวคิดเกี่ยวกับข้อมูลประจำตัวของลูกค้า เมื่อเลือกข้อมูลจากชุดย่อยเฉพาะของไคลเอ็นต์เป็นอินพุตแล้ว เช่น ในการเรียกไปยัง tff.templates.IterativeProcess.next ข้อมูลประจำตัวของไคลเอ็นต์จะไม่ปรากฏในนั้นอีกต่อไป

ชุดข้อมูลที่ใช้ได้

เราได้จัดเตรียมชุดข้อมูลเนมสเปซ tff.simulation.datasets สำหรับชุดข้อมูลที่ใช้อินเทอร์เฟ tff.simulation.datasets.ClientData เพื่อใช้ในการจำลองสถานการณ์ และเสริมด้วยชุดข้อมูลเพื่อรองรับ การจำแนกรูปภาพ และบทช่วยสอน การสร้างข้อความ เราอยากสนับสนุนให้คุณสนับสนุนชุดข้อมูลของคุณเองในแพลตฟอร์ม