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

ภาพรวม

เอกสารนี้จะแนะนำอินเทอร์เฟซที่อำนวยความสะดวกให้กับงานการเรียนรู้แบบรวมศูนย์ เช่น การฝึกอบรมแบบรวมศูนย์หรือการประเมินผลด้วยโมเดลการเรียนรู้ของเครื่องที่มีอยู่ใน 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 ดู ส่วนตัวแปลงสำหรับ Keras ด้านล่าง Wrapper เหล่านี้จัดการการรวมการอัปเดตโมเดลตลอดจนตัววัดใดๆ ที่กำหนดไว้สำหรับโมเดลโดยอัตโนมัติ อย่างไรก็ตาม การทำความเข้าใจวิธีจัดการการรวมกลุ่มสำหรับ tff.learning.models.VariableModel ทั่วไปอาจยังมีประโยชน์อยู่

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

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

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

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

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

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

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

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

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

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

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

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

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

อินเทอร์เฟซที่เป็นนามธรรม

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

• เมธอด Constructor, forward_pass และ report_local_unfinalized_metrics ควรสร้างตัวแปรโมเดล การส่งต่อ และสถิติที่คุณต้องการรายงานตามลำดับ 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 aggregator แบบธรรมดาจะรวมค่าเมตริกที่ยังไม่สรุปจากไคลเอ็นต์ก่อน จากนั้นจึงเรียกใช้ฟังก์ชัน 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 เพิ่มเติมที่สร้างโดยเฟรมเวิร์กการเรียนรู้แบบรวมศูนย์เพื่อขับเคลื่อนลูปการฝึกอบรม/การประเมินผลของโมเดลของคุณ (เช่น การสร้างเครื่องมือเพิ่มประสิทธิภาพ การใช้การอัปเดตโมเดล การวนซ้ำบน tf.data.Dataset s และตัววัดการประมวลผล และใช้การอัปเดตแบบรวมบนเซิร์ฟเวอร์ เป็นต้น)

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

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

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

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

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

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

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

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

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

• 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 ในการจำลอง ข้อมูลแบบรวมศูนย์จะได้รับการยอมรับเป็น list Python โดยมีหนึ่งองค์ประกอบต่ออุปกรณ์ไคลเอ็นต์ที่เข้าร่วมเพื่อแสดง 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 สำหรับใช้ในการจำลอง และเพาะด้วยชุดข้อมูลเพื่อรองรับ การจัดหมวดหมู่รูปภาพ และบทช่วยสอน การสร้างข้อความ เราต้องการสนับสนุนให้คุณสนับสนุนชุดข้อมูลของคุณเองบนแพลตฟอร์ม