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

ภาพรวม

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