ภาพรวม
เอกสารนี้แนะนำอินเทอร์เฟซที่อำนวยความสะดวกในงานการเรียนรู้แบบรวมศูนย์ เช่น การฝึกอบรมแบบรวมศูนย์หรือการประเมินด้วยโมเดลการเรียนรู้ของเครื่องที่มีอยู่ซึ่งนำไปใช้ใน TensorFlow ในการออกแบบอินเทอร์เฟซเหล่านี้ เป้าหมายหลักของเราคือทำให้สามารถทดลองการเรียนรู้แบบสหพันธรัฐโดยไม่ต้องมีความรู้ว่ามันทำงานอย่างไรภายใต้ประทุน และเพื่อประเมินอัลกอริธึมการเรียนรู้แบบรวมศูนย์ที่ปรับใช้กับโมเดลและข้อมูลที่มีอยู่หลากหลายรูปแบบ เราสนับสนุนให้คุณกลับมามีส่วนร่วมกับแพลตฟอร์ม TFF ได้รับการออกแบบโดยคำนึงถึงความสามารถในการขยายและความสามารถในการบีบอัด และเรายินดีรับความช่วยเหลือ เรารู้สึกตื่นเต้นที่จะได้เห็นสิ่งที่คุณคิด!
อินเทอร์เฟซที่นำเสนอโดยเลเยอร์นี้ประกอบด้วยสามส่วนหลักดังต่อไปนี้:
โมเดล . คลาสและฟังก์ชันตัวช่วยที่ให้คุณรวมโมเดลที่มีอยู่เพื่อใช้กับ TFF การห่อโมเดลสามารถทำได้ง่ายพอๆ กับการเรียกใช้ฟังก์ชันการตัดคำเดียว (เช่น
tff.learning.from_keras_model
) หรือการกำหนดคลาสย่อยของอินเทอร์เฟซtff.learning.Model
เพื่อปรับแต่งได้อย่างเต็มที่ผู้สร้างการคำนวณแบบสหพันธรัฐ ฟังก์ชันตัวช่วยที่สร้างการคำนวณแบบรวมศูนย์สำหรับการฝึกอบรมหรือการประเมิน โดยใช้แบบจำลองที่มีอยู่ของคุณ
ชุดข้อมูล คอลเล็กชันข้อมูลสำเร็จรูปที่คุณสามารถดาวน์โหลดและเข้าถึงใน 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.Model
ฟังก์ชันนี้จะถูกเรียกใช้โดย TFF เพื่อให้แน่ใจว่าส่วนประกอบทั้งหมดของโมเดลได้รับการจัดลำดับ นอกจากนี้ เนื่องจากเป็นสภาพแวดล้อมที่มีการพิมพ์อย่างหนักหน่วง TFF จะต้องการ ข้อมูลเมตา เพิ่มเติมเล็กน้อย เช่น ข้อมูลจำเพาะของประเภทอินพุตของโมเดลของคุณ
การรวม
เราขอแนะนำอย่างยิ่งให้ผู้ใช้ส่วนใหญ่สร้างแบบจำลองโดยใช้ Keras ดูส่วนตัว แปลงสำหรับ Keras ด้านล่าง Wrapper เหล่านี้จัดการการรวมการอัพเดตโมเดล รวมถึงตัวชี้วัดใดๆ ที่กำหนดไว้สำหรับโมเดลโดยอัตโนมัติ อย่างไรก็ตาม การทำความเข้าใจวิธีจัดการการรวมสำหรับ tff.learning.Model
ทั่วไป อาจยังคงมีประโยชน์
มีการรวมอย่างน้อยสองชั้นเสมอในการเรียนรู้แบบรวมศูนย์: การรวมในอุปกรณ์ในเครื่อง และการรวมข้ามอุปกรณ์ (หรือแบบรวมศูนย์):
การรวมท้องถิ่น การรวมระดับนี้หมายถึงการรวมกลุ่มตัวอย่างหลายชุดที่เป็นของลูกค้าแต่ละราย มีผลกับทั้งพารามิเตอร์โมเดล (ตัวแปร) ซึ่งพัฒนาต่อเนื่องตามลำดับเมื่อโมเดลได้รับการฝึกอบรมในพื้นที่ ตลอดจนสถิติที่คุณคำนวณ (เช่น การสูญเสียโดยเฉลี่ย ความแม่นยำ และเมตริกอื่นๆ) ซึ่งโมเดลของคุณจะอัปเดตในเครื่องอีกครั้ง เมื่อมันวนซ้ำสตรีมข้อมูลในเครื่องของลูกค้าแต่ละราย
การรวมที่ระดับนี้เป็นความรับผิดชอบของรหัสโมเดลของคุณ และสามารถทำได้โดยใช้โครงสร้าง TensorFlow มาตรฐาน
โครงสร้างทั่วไปของการประมวลผลมีดังนี้:
โมเดลแรกสร้าง
tf.Variable
s เพื่อเก็บมวลรวม เช่น จำนวนแบทช์หรือจำนวนตัวอย่างที่ประมวลผล ผลรวมของการสูญเสียต่อแบทช์หรือต่อตัวอย่าง เป็นต้นTFF เรียกใช้เมธอด
forward_pass
บนModel
ของคุณหลายครั้ง ตามลำดับในชุดข้อมูลไคลเอ็นต์ที่ตามมา ซึ่งช่วยให้คุณอัปเดตตัวแปรที่มีการรวมต่างๆ เป็นผลข้างเคียงสุดท้าย TFF จะเรียกใช้เมธอด
report_local_unfinalized_metrics
บนโมเดลของคุณ เพื่อให้โมเดลของคุณสามารถรวบรวมสถิติสรุปทั้งหมดที่รวบรวมไว้เป็นชุดเมตริกขนาดย่อที่จะส่งออกโดยไคลเอ็นต์ นี่คือที่ที่รหัสแบบจำลองของคุณอาจ ตัวอย่างเช่น แบ่งผลรวมของการสูญเสียด้วยจำนวนตัวอย่างที่ประมวลผลเพื่อส่งออกการสูญเสียเฉลี่ย ฯลฯ
การรวมตัวแบบสหพันธรัฐ ระดับการรวมนี้หมายถึงการรวมในไคลเอนต์หลายเครื่อง (อุปกรณ์) ในระบบ อีกครั้ง จะใช้กับทั้งพารามิเตอร์โมเดล (ตัวแปร) ซึ่งใช้ค่าเฉลี่ยในไคลเอ็นต์ ตลอดจนเมตริกที่โมเดลของคุณส่งออกอันเป็นผลมาจากการรวมในเครื่อง
การดำเนินการรวมในระดับนี้เป็นความรับผิดชอบของ TFF อย่างไรก็ตาม ในฐานะผู้สร้างแบบจำลอง คุณสามารถควบคุมกระบวนการนี้ได้ (เพิ่มเติมเกี่ยวกับสิ่งนี้ด้านล่าง)
โครงสร้างทั่วไปของการประมวลผลมีดังนี้:
โมเดลเริ่มต้น และพารามิเตอร์ใดๆ ที่จำเป็นสำหรับการฝึกอบรม ถูกแจกจ่ายโดยเซิร์ฟเวอร์ไปยังกลุ่มย่อยของลูกค้าที่จะเข้าร่วมในการฝึกอบรมหรือการประเมินผล
ในไคลเอนต์แต่ละราย โค้ดโมเดลของคุณจะถูกเรียกใช้ซ้ำๆ กันในสตรีมของแบตช์ข้อมูลในเครื่อง เพื่อสร้างชุดพารามิเตอร์โมเดลใหม่ (เมื่อฝึก) และชุดเมทริกในเครื่องชุดใหม่ ตามที่อธิบายข้างต้น (นี่คือโลคัล การรวมตัว)
TFF รันโปรโตคอลการรวมแบบกระจายเพื่อรวบรวมและรวมพารามิเตอร์โมเดลและเมทริกที่เอ็กซ์พอร์ตในเครื่องทั่วทั้งระบบ ตรรกะนี้แสดงในลักษณะการประกาศโดยใช้ภาษา คำนวณรวม ของ TFF (ไม่ใช่ในภาษา TensorFlow) ดูบทแนะนำ อัลกอริทึมที่กำหนดเอง สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ API การรวม
อินเทอร์เฟซที่เป็นนามธรรม
คอน สตรั คเตอร์พื้นฐาน + อินเตอร์เฟส ข้อมูลเมตา นี้แสดงโดยอินเตอร์เฟส tff.learning.Model
ดังต่อไปนี้:
เมธอด Constructor,
forward_pass
และreport_local_unfinalized_metrics
ควรสร้างตัวแปรโมเดล การส่งต่อ และสถิติที่คุณต้องการรายงานตามลำดับ TensorFlow ที่สร้างขึ้นโดยวิธีการเหล่านั้นจะต้องทำให้เป็นอนุกรมได้ ตามที่กล่าวไว้ข้างต้นคุณสมบัติ
input_spec
รวมถึงคุณสมบัติ 3 ประการที่ส่งคืนชุดย่อยของตัวแปรที่ฝึกได้ ไม่สามารถฝึกได้ และตัวแปรท้องถิ่นแสดงถึงข้อมูลเมตา TFF ใช้ข้อมูลนี้เพื่อกำหนดวิธีเชื่อมต่อส่วนต่างๆ ของแบบจำลองของคุณกับอัลกอริธึมการปรับให้เหมาะสมแบบรวมศูนย์ และเพื่อกำหนดลายเซ็นประเภทภายในเพื่อช่วยในการตรวจสอบความถูกต้องของระบบที่สร้างขึ้น (เพื่อให้แบบจำลองของคุณไม่สามารถสร้างอินสแตนซ์บนข้อมูลที่ไม่ตรงกับสิ่งที่ รุ่นได้รับการออกแบบเพื่อการบริโภค)
นอกจากนี้ อินเทอร์เฟซนามธรรม tff.learning.Model
จะแสดงคุณสมบัติ metric_finalizers
ที่รับค่าที่ยังไม่สิ้นสุดของเมตริก (ส่งคืนโดย report_local_unfinalized_metrics()
) และส่งกลับค่าเมตริกที่สรุปผล metric_finalizers
และ report_local_unfinalized_metrics()
จะใช้ร่วมกันเพื่อสร้างตัวรวบรวมเมตริกข้ามไคลเอ็นต์เมื่อกำหนดกระบวนการฝึกอบรมแบบรวมศูนย์หรือการคำนวณการประเมินผล ตัวอย่างเช่น tff.learning.metrics.sum_then_finalize
aggregator แบบธรรมดาจะรวมค่าเมตริกที่ยังไม่เสร็จสิ้นจากไคลเอ็นต์ก่อน จากนั้นจึงเรียกใช้ฟังก์ชัน Finalizer ที่เซิร์ฟเวอร์
คุณสามารถค้นหาตัวอย่างวิธีกำหนด 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
ที่ทำงานเกี่ยวกับการเรียนรู้ เราคาดว่าชุดของการคำนวณดังกล่าวจะขยายตัวในอนาคต
สมมติฐานทางสถาปัตยกรรม
การดำเนินการ
มีสองขั้นตอนที่แตกต่างกันในการรันการคำนวณแบบรวมศูนย์
คอมไพล์ : TFF จะ คอมไพล์ อัลกอริธึมการเรียนรู้แบบสหพันธรัฐเป็นลำดับนามธรรมของการคำนวณแบบกระจายทั้งหมด นี่คือเวลาที่การจัดลำดับ TensorFlow เกิดขึ้น แต่การแปลงอื่นๆ สามารถเกิดขึ้นได้เพื่อสนับสนุนการดำเนินการที่มีประสิทธิภาพมากขึ้น เราอ้างถึงการแสดงลำดับที่ปล่อยออกมาโดยคอมไพเลอร์ว่าเป็นการ คำนวณแบบรวม ศูนย์
ดำเนินการ TFF มีวิธี ดำเนิน การคำนวณเหล่านี้ สำหรับตอนนี้ การดำเนินการได้รับการสนับสนุนผ่านการจำลองในเครื่องเท่านั้น (เช่น ในโน้ตบุ๊กที่ใช้ข้อมูลกระจายอำนาจจำลอง)
การคำนวณแบบรวมศูนย์ที่สร้างโดย Federated Learning API ของ TFF เช่น อัลกอริธึมการฝึกอบรมที่ใช้ แบบจำลองเฉลี่ยแบบรวม ศูนย์ หรือการประเมินแบบรวมศูนย์ รวมถึงองค์ประกอบจำนวนหนึ่ง โดยเฉพาะอย่างยิ่ง:
รูปแบบที่เป็นอนุกรมของรหัสโมเดลของคุณรวมถึงโค้ด TensorFlow เพิ่มเติมที่สร้างโดยเฟรมเวิร์กของ Federated Learning เพื่อขับเคลื่อนการวนรอบการฝึก/การประเมินของโมเดลของคุณ (เช่น การสร้างตัวเพิ่มประสิทธิภาพ การใช้การอัปเดตโมเดล การวนซ้ำ
tf.data.Dataset
และเมตริกการคำนวณ และใช้การอัปเดตแบบรวมบนเซิร์ฟเวอร์ เป็นต้น)ข้อกำหนดที่เปิดเผยของการสื่อสารระหว่าง ไคลเอนต์ และ เซิร์ฟเวอร์ (โดยทั่วไปแล้วจะเป็นการ รวม รูปแบบต่างๆ ระหว่างอุปกรณ์ไคลเอนต์ และ การออกอากาศ จากเซิร์ฟเวอร์ไปยังไคลเอนต์ทั้งหมด) และวิธีที่การสื่อสารแบบกระจายนี้ถูกสอดแทรกด้วยการดำเนินการไคลเอนต์ภายในหรือเซิร์ฟเวอร์ภายใน ของรหัส TensorFlow
การ คำนวณแบบรวม ศูนย์ที่แสดงในรูปแบบอนุกรมนี้จะแสดงเป็นภาษาภายในที่ไม่ขึ้นกับแพลตฟอร์มซึ่งแตกต่างจาก Python แต่หากต้องการใช้ Federated Learning API คุณจะไม่ต้องกังวลกับรายละเอียดของการนำเสนอนี้ การคำนวณจะแสดงในโค้ด Python ของคุณเป็นอ็อบเจ็กต์ประเภท tff.Computation
ซึ่งโดยส่วนใหญ่แล้ว คุณสามารถถือว่า Python callable
s ทึบแสงได้เป็นส่วนใหญ่
ในบทช่วยสอน คุณจะเรียกใช้การคำนวณแบบรวมศูนย์ราวกับว่ามันเป็นฟังก์ชัน Python ปกติ เพื่อดำเนินการในเครื่อง อย่างไรก็ตาม TFF ได้รับการออกแบบเพื่อแสดงการคำนวณแบบรวมศูนย์ในลักษณะที่ไม่เชื่อเรื่องพระเจ้าในแง่มุมส่วนใหญ่ของสภาพแวดล้อมการดำเนินการ เพื่อให้สามารถปรับใช้กับกลุ่มของอุปกรณ์ที่ใช้ Android
หรือคลัสเตอร์ในศูนย์ข้อมูลได้ อีกครั้ง ผลลัพธ์หลักของสิ่งนี้คือการตั้งสมมติฐานที่ชัดเจนเกี่ยวกับการทำให้เป็น อันดับ โดยเฉพาะอย่างยิ่ง เมื่อคุณเรียกใช้หนึ่งในเมธอด build_...
ที่อธิบายไว้ด้านล่าง การคำนวณจะถูกทำให้เป็นอนุกรมอย่างสมบูรณ์
สถานะการสร้างแบบจำลอง
TFF เป็นสภาพแวดล้อมการเขียนโปรแกรมเชิงฟังก์ชัน แต่กระบวนการที่น่าสนใจมากมายในการเรียนรู้แบบสหพันธรัฐนั้นมีการเก็บสถานะไว้ ตัวอย่างเช่น ลูปการฝึกที่เกี่ยวข้องกับการหาค่าเฉลี่ยของโมเดลรวมหลายรอบเป็นตัวอย่างของสิ่งที่เราจัดประเภทเป็น กระบวนการ เก็บสถานะ ในกระบวนการนี้ สถานะที่วิวัฒนาการจากรอบหนึ่งไปอีกรอบรวมถึงชุดของพารามิเตอร์แบบจำลองที่ได้รับการฝึก และอาจรวมถึงสถานะเพิ่มเติมที่เกี่ยวข้องกับเครื่องมือเพิ่มประสิทธิภาพ (เช่น เวกเตอร์โมเมนตัม)
เนื่องจาก TFF ใช้งานได้ กระบวนการเก็บสถานะจึงถูกจำลองใน TFF เป็นการคำนวณที่ยอมรับสถานะปัจจุบันเป็นอินพุต จากนั้นจึงจัดเตรียมสถานะที่อัปเดตเป็นเอาต์พุต เพื่อที่จะกำหนดกระบวนการ stateful ได้อย่างสมบูรณ์ เราจำเป็นต้องระบุที่มาของสถานะเริ่มต้นด้วย สิ่งนี้มีอยู่ในคำจำกัดความของคลาสตัวช่วย tff.templates.IterativeProcess
โดยมีคุณสมบัติ initialize
2 รายการและ next
จากการเริ่มต้นและการวนซ้ำตามลำดับ
ผู้สร้างที่มีอยู่
ในขณะนี้ TFF มีฟังก์ชันตัวสร้างต่างๆ ที่สร้างการคำนวณแบบรวมศูนย์สำหรับการฝึกอบรมและการประเมินแบบรวมศูนย์ สองตัวอย่างที่โดดเด่น ได้แก่ :
tff.learning.algorithms.build_weighted_fed_avg
ซึ่งใช้เป็นอินพุตของ ฟังก์ชันโมเดล และตัว เพิ่มประสิทธิภาพไคลเอ็นต์ และส่งคืนtff.learning.templates.LearningProcess
(ซึ่งคลาสย่อยtff.templates.IterativeProcess
)tff.learning.build_federated_evaluation
ใช้ ฟังก์ชัน model และส่งกลับการคำนวณแบบรวมศูนย์เดียวสำหรับการประเมินแบบจำลองแบบรวมศูนย์ เนื่องจากการประเมินไม่มีการเก็บสถานะ
ชุดข้อมูล
สมมติฐานทางสถาปัตยกรรม
การเลือกลูกค้า
ในสถานการณ์การเรียนรู้แบบรวมศูนย์ทั่วไป เรามีอุปกรณ์ไคลเอนต์ จำนวนมาก ที่อาจหลายร้อยล้านเครื่อง ซึ่งมีเพียงส่วนเล็ก ๆ เท่านั้นที่สามารถใช้งานได้และพร้อมสำหรับการฝึกอบรมในช่วงเวลาใดก็ตาม (เช่น อาจจำกัดเฉพาะลูกค้าที่ เสียบกับแหล่งพลังงาน ไม่ใช่เครือข่ายแบบมิเตอร์ และไม่ได้ใช้งาน) โดยทั่วไป กลุ่มลูกค้าที่พร้อมจะเข้าร่วมการฝึกอบรมหรือประเมินผลอยู่นอกเหนือการควบคุมของนักพัฒนา นอกจากนี้ เนื่องจากไม่สามารถประสานงานกับลูกค้าหลายล้านราย การฝึกอบรมหรือการประเมินโดยทั่วไปจะรวมลูกค้าที่มีอยู่เพียงเศษเสี้ยว ซึ่งอาจ สุ่มตัวอย่าง
ผลลัพธ์ที่สำคัญของสิ่งนี้คือการคำนวณแบบรวมศูนย์โดยการออกแบบนั้นแสดงออกในลักษณะที่ไม่สนใจกลุ่มผู้เข้าร่วมที่แน่นอน การประมวลผลทั้งหมดจะแสดงเป็นการดำเนินการโดยรวมในกลุ่มนามธรรมของ ไคลเอ็นต์ ที่ไม่ระบุชื่อ และกลุ่มนั้นอาจแตกต่างกันไปในแต่ละรอบของการฝึกอบรม การเชื่อมโยงที่แท้จริงของการคำนวณกับผู้เข้าร่วมที่เป็นรูปธรรม และด้วยเหตุนี้กับข้อมูลที่เป็นรูปธรรมที่พวกเขาป้อนเข้าสู่การคำนวณ จึงถูกจำลองภายนอกของการคำนวณเอง
เพื่อจำลองการใช้งานจริงของโค้ดการเรียนรู้แบบรวมศูนย์ โดยทั่วไปคุณจะต้องเขียนลูปการฝึกอบรมที่มีลักษณะดังนี้:
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
สำหรับใช้ในการจำลอง และเพาะด้วยชุดข้อมูลเพื่อสนับสนุนการสอนเกี่ยวกับการ จัดหมวดหมู่รูปภาพ และ การสร้างข้อความ เราขอสนับสนุนให้คุณร่วมให้ข้อมูลชุดข้อมูลของคุณเองกับแพลตฟอร์ม