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