การเรียนรู้แบบรวมศูนย์

ภาพรวม

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

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

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

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

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

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

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

โมเดล

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

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

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

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

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

การรวม

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

นอกจากนี้อินเทอร์เฟซนามธรรม tff.learning.Model แสดงคุณสมบัติ federated_output_computation ที่ร่วมกับคุณสมบัติ report_local_outputs กล่าวถึงก่อนหน้านี้ช่วยให้คุณสามารถควบคุมกระบวนการรวมสถิติสรุป

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

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

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

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

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

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

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

ผู้สร้างการคำนวณแบบรวมศูนย์

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ผู้สร้างที่มีจำหน่าย

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

• tff.learning.build_federated_averaging_process รับ ฟังก์ชันโมเดล และตัว เพิ่มประสิทธิภาพไคลเอ็นต์ และส่งคืน tff.templates.IterativeProcess มีสถานะ

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

ชุดข้อมูล

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

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

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

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

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

trainer = tff.learning.build_federated_averaging_process(...)
state = trainer.initialize()
federated_training_data = ...

def sample(federate_data):
  return ...

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

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