สหพันธรัฐคอร์

เอกสารนี้แนะนำเลเยอร์หลักของ TFF ที่ทำหน้าที่เป็นรากฐานสำหรับ การเรียนรู้แบบรวมศูนย์ และอัลกอริธึมแบบรวมศูนย์ที่ไม่ใช่การเรียนรู้ในอนาคตที่เป็นไปได้

สำหรับการแนะนำ Federated Core แบบคร่าวๆ โปรดอ่านบทช่วยสอนต่อไปนี้ เนื่องจากบทช่วยสอนนี้จะแนะนำแนวคิดพื้นฐานบางส่วนด้วยตัวอย่าง และสาธิตการสร้างอัลกอริธึมการหาค่าเฉลี่ยแบบรวมศูนย์อย่างง่ายทีละขั้นตอน

• อัลกอริทึมแบบรวมศูนย์แบบกำหนดเอง ตอนที่ 1: ข้อมูลเบื้องต้นเกี่ยวกับ Federated Core

• อัลกอริทึม Federated แบบกำหนดเอง ตอนที่ 2: การใช้ Federated Averaging

นอกจากนี้เรายังขอแนะนำให้คุณทำความคุ้นเคยกับ Federated Learning และบทช่วยสอนที่เกี่ยวข้องเกี่ยวกับ การจำแนกรูปภาพ และ การสร้างข้อความ เนื่องจากการใช้ Federated Core API (FC API) สำหรับการเรียนรู้แบบรวมศูนย์จะให้บริบทที่สำคัญสำหรับตัวเลือกบางอย่างที่เราได้ทำใน การออกแบบเลเยอร์นี้

ภาพรวม

เป้าหมาย การใช้งานที่ตั้งใจไว้ และขอบเขต

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

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

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

โดยสรุปเป้าหมายของ FC คือการเปิดใช้งานการแสดงที่มีขนาดกะทัดรัดในทำนองเดียวกัน ในระดับนามธรรมของนามธรรมของโปรแกรมที่คล้ายกับรหัสเทียมที่คล้ายกัน ของตรรกะของโปรแกรมที่ ไม่ใช่ รหัสเทียม แต่สามารถเรียกใช้งานได้ในสภาพแวดล้อมเป้าหมายที่หลากหลาย

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

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

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

ด้วยเหตุนี้ แม้ว่าเฟรมเวิร์กแบบกระจายสำหรับวัตถุประสงค์ทั่วไปอาจมีการดำเนินการ เช่น การส่ง และ รับ แบบเอกสารสำเร็จรูป แต่ FC ก็จัดเตรียมเอกสารสำเร็จรูป เช่น tff.federated_sum , tff.federated_reduce หรือ tff.federated_broadcast ที่ห่อหุ้มโปรโตคอลแบบกระจายแบบง่าย

ภาษา

อินเตอร์เฟซหลาม

TFF ใช้ภาษาภายในเพื่อแสดงการคำนวณแบบรวมศูนย์ ซึ่งมีไวยากรณ์ที่กำหนดโดยการแสดงแบบอนุกรมใน computation.proto โดยทั่วไปแล้ว ผู้ใช้ FC API จะไม่จำเป็นต้องโต้ตอบกับภาษานี้โดยตรง แต่เราจัดเตรียม Python API (เนมสเปซ tff ) ที่ล้อมรอบไว้เพื่อเป็นแนวทางในการกำหนดการคำนวณ

โดยเฉพาะอย่างยิ่ง TFF จัดเตรียมตัวตกแต่งฟังก์ชัน Python เช่น tff.federated_computation ที่ติดตามเนื้อความของฟังก์ชันที่ตกแต่งแล้ว และสร้างการแสดงแบบอนุกรมของตรรกะการคำนวณแบบรวมในภาษาของ TFF ฟังก์ชันที่ตกแต่งด้วย tff.federated_computation ทำหน้าที่เป็นพาหะของการแสดงแบบซีเรียลไลซ์ดังกล่าว และสามารถฝังเป็น Building Block ในส่วนของการคำนวณอื่น หรือดำเนินการตามคำขอเมื่อเรียกใช้

นี่เป็นเพียงตัวอย่างเดียว สามารถดูตัวอย่างเพิ่มเติมได้ในบทช่วยสอน อัลกอริทึมที่กำหนดเอง

@tff.federated_computation(tff.FederatedType(np.float32, tff.CLIENTS))
def get_average_temperature(sensor_readings):
  return tff.federated_mean(sensor_readings)

ผู้อ่านที่คุ้นเคยกับ TensorFlow ที่ไม่กระตือรือร้นจะพบว่าวิธีการนี้คล้ายคลึงกับการเขียนโค้ด Python ที่ใช้ฟังก์ชันต่างๆ เช่น tf.add หรือ tf.reduce_sum ในส่วนของโค้ด Python ที่กำหนดกราฟ TensorFlow แม้ว่าโค้ดจะแสดงออกมาในทางเทคนิคใน Python แต่จุดประสงค์ของมันคือเพื่อสร้างการแสดง tf.Graph ด้านล่างแบบอนุกรมได้ และเป็นกราฟ ไม่ใช่โค้ด Python ที่ถูกดำเนินการภายในโดยรันไทม์ TensorFlow ในทำนองเดียวกัน ใครๆ ก็นึกถึง tff.federated_mean เป็นการแทรก federated op ลงในการคำนวณแบบรวมศูนย์ซึ่งแสดงโดย get_average_temperature

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

สิ่งนี้เรียกร้องให้มีระบบภาษาและประเภทที่ยึดแนวคิดเรื่องการกระจายตัว

ประเภทระบบ

Federated Core มีประเภทต่างๆ ดังต่อไปนี้ ในการอธิบายประเภทเหล่านี้ เราจะชี้ไปที่ตัวสร้างประเภทรวมทั้งแนะนำสัญกรณ์แบบย่อ เนื่องจากเป็นวิธีที่สะดวกหรืออธิบายประเภทของการคำนวณและตัวดำเนินการ

ประการแรก ต่อไปนี้เป็นหมวดหมู่ของประเภทที่มีแนวคิดคล้ายคลึงกับที่พบในภาษากระแสหลักที่มีอยู่:

• ประเภทเทนเซอร์ ( tff.TensorType ) เช่นเดียวกับใน TensorFlow สิ่งเหล่านี้มี dtype และ shape ข้อแตกต่างเพียงอย่างเดียวคือออบเจ็กต์ประเภทนี้ไม่ได้จำกัดอยู่เพียงอินสแตนซ์ tf.Tensor ใน Python ที่แสดงเอาต์พุตของการดำเนินการ TensorFlow ในกราฟ TensorFlow แต่ยังอาจรวมหน่วยของข้อมูลที่สามารถสร้างได้ เช่น เป็นเอาต์พุตของการกระจาย โปรโตคอลการรวมตัว ดังนั้นประเภทเทนเซอร์ TFF จึงเป็นเพียงเวอร์ชันนามธรรมของการนำเสนอทางกายภาพที่เป็นรูปธรรมของประเภทดังกล่าวใน Python หรือ TensorFlow

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

  สัญกรณ์แบบกะทัดรัดสำหรับประเภทเทนเซอร์คือ dtype หรือ dtype[shape] ตัวอย่างเช่น int32 และ int32[10] คือประเภทของจำนวนเต็มและเวกเตอร์ int ตามลำดับ

• ประเภทลำดับ ( tff.SequenceType ) สิ่งเหล่านี้เป็นนามธรรมของ TFF ที่เทียบเท่ากับแนวคิดที่เป็นรูปธรรมของ TensorFlow ในเรื่อง tf.data.Dataset s องค์ประกอบของลำดับสามารถใช้ได้ในลักษณะต่อเนื่องกัน และอาจรวมถึงประเภทที่ซับซ้อนด้วย

  การแสดงประเภทลำดับแบบกะทัดรัดคือ T* โดยที่ T คือประเภทขององค์ประกอบ ตัวอย่างเช่น int32* แสดงถึงลำดับจำนวนเต็ม

• ประเภทสิ่งอันดับที่มีชื่อ ( tff.StructType ) นี่เป็นวิธีของ TFF ในการสร้างสิ่งอันดับและโครงสร้างคล้ายพจนานุกรมที่มี องค์ประกอบ จำนวนที่กำหนดไว้ล่วงหน้าพร้อมประเภทเฉพาะ ทั้งแบบมีชื่อหรือไม่มีชื่อ ที่สำคัญ แนวคิด tuple ที่มีชื่อของ TFF ครอบคลุมค่านามธรรมที่เทียบเท่ากับ tuples อาร์กิวเมนต์ของ Python กล่าวคือ คอลเล็กชันขององค์ประกอบซึ่งมีบางส่วนได้รับการตั้งชื่อ แต่ไม่ใช่ทั้งหมด และบางส่วนเป็นตำแหน่ง

  รูปแบบย่อสำหรับสิ่งอันดับที่มีชื่อคือ <n_1=T_1, ..., n_k=T_k> โดยที่ n_k เป็นชื่อองค์ประกอบทางเลือก และ T_k เป็นประเภทองค์ประกอบ ตัวอย่างเช่น <int32,int32> เป็นสัญกรณ์แบบกะทัดรัดสำหรับคู่ของจำนวนเต็มที่ไม่มีชื่อ และ <X=float32,Y=float32> เป็นสัญกรณ์แบบกะทัดรัดสำหรับคู่ลอยที่ชื่อ X และ Y ซึ่งอาจเป็นตัวแทนของจุดบนระนาบ . สิ่งอันดับสามารถซ้อนกันและผสมกับประเภทอื่นได้ เช่น <X=float32,Y=float32>* จะเป็นสัญลักษณ์แบบกระชับสำหรับลำดับของจุด

• ประเภทฟังก์ชัน ( tff.FunctionType ) TFF เป็นเฟรมเวิร์กการเขียนโปรแกรมเชิงฟังก์ชัน โดยมีฟังก์ชันที่ถือว่าเป็น ค่าระดับเฟิร์สคลาส ฟังก์ชันมีอาร์กิวเมนต์ได้สูงสุด 1 รายการและมีผลลัพธ์เพียง 1 รายการเท่านั้น

  สัญกรณ์แบบกะทัดรัดสำหรับฟังก์ชันคือ (T -> U) โดยที่ T คือประเภทของอาร์กิวเมนต์ และ U คือประเภทของผลลัพธ์ หรือ ( -> U) หากไม่มีอาร์กิวเมนต์ (แม้ว่าฟังก์ชันที่ไม่มีอาร์กิวเมนต์จะเสื่อมลงก็ตาม แนวคิดที่มีอยู่ส่วนใหญ่ในระดับ Python เท่านั้น) ตัวอย่างเช่น (int32* -> int32) คือสัญลักษณ์สำหรับประเภทของฟังก์ชันที่ลดลำดับจำนวนเต็มให้เป็นค่าจำนวนเต็มเดียว

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

• ประเภทตำแหน่ง ประเภทนี้ยังไม่เปิดเผยใน API สาธารณะ นอกเหนือจากในรูปแบบ 2 ตัวอักษร tff.SERVER และ tff.CLIENTS ที่คุณถือเป็นค่าคงที่ประเภทนี้ อย่างไรก็ตาม จะมีการใช้งานเป็นการภายใน และจะเปิดตัวใน API สาธารณะในรุ่นต่อๆ ไป การแสดงประเภทนี้มีขนาดกะทัดรัดคือ placement

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

  วัตถุประสงค์หลักของการกำหนดแนวคิดเกี่ยวกับตำแหน่งนั้นเป็นพื้นฐานในการกำหนด ประเภทแบบรวมศูนย์

• ประเภทแบบรวมศูนย์ ( tff.FederatedType ) ค่าของประเภท federated คือค่าที่โฮสต์โดยกลุ่มผู้เข้าร่วมระบบที่กำหนดโดยตำแหน่งเฉพาะ (เช่น tff.SERVER หรือ tff.CLIENTS ) ประเภทแบบรวมศูนย์ถูกกำหนดโดยค่า ตำแหน่ง (ดังนั้นจึงเป็น ประเภทที่ขึ้นต่อกัน ) ประเภทของ องค์ประกอบของสมาชิก (ประเภทของเนื้อหาที่ผู้เข้าร่วมแต่ละคนโฮสต์แบบโลคัล) และบิตเพิ่มเติม all_equal ที่ระบุว่าผู้เข้าร่วมทั้งหมดเป็นแบบโลคัลหรือไม่ เป็นเจ้าภาพรายการเดียวกัน

  รูปแบบย่อสำหรับประเภทค่าแบบรวมศูนย์ที่รวมรายการ (องค์ประกอบสมาชิก) ประเภท T แต่ละโฮสต์โดยกลุ่ม (ตำแหน่ง) G คือ T@G หรือ {T}@G โดยมีชุดบิต all_equal หรือไม่ได้ตั้งค่า ตามลำดับ

  ตัวอย่างเช่น:

  • {int32}@CLIENTS แสดงถึง ค่ารวม ที่ประกอบด้วยชุดของจำนวนเต็มที่อาจแตกต่างออกไป หนึ่งค่าต่ออุปกรณ์ไคลเอ็นต์ โปรดทราบว่าเรากำลังพูดถึง ค่ารวมศูนย์ เดียวซึ่งครอบคลุมข้อมูลหลายรายการที่ปรากฏในหลายตำแหน่งทั่วทั้งเครือข่าย วิธีคิดวิธีหนึ่งคือเป็นเมตริกซ์ชนิดหนึ่งที่มีมิติ "เครือข่าย" แม้ว่าการเปรียบเทียบนี้จะไม่สมบูรณ์แบบเนื่องจาก TFF ไม่อนุญาตให้ มีการเข้าถึงแบบสุ่ม ไปยังองค์ประกอบของสมาชิกของค่าแบบรวมศูนย์

  • {<X=float32,Y=float32>*}@CLIENTS แสดงถึง ชุดข้อมูลแบบรวมศูนย์ ซึ่งเป็นค่าที่ประกอบด้วยลำดับพิกัด XY หลายลำดับ หนึ่งลำดับต่ออุปกรณ์ไคลเอ็นต์

  • <weights=float32[10,5],bias=float32[5]>@SERVER แสดงถึงทูเพิลที่มีชื่อของน้ำหนักและเทนเซอร์อคติที่เซิร์ฟเวอร์ เนื่องจากเราได้ทิ้งเครื่องหมายปีกกา สิ่งนี้บ่งชี้ว่ามีการตั้งค่าบิต all_equal กล่าวคือ มีเพียง tuple เดียวเท่านั้น (ไม่ว่าเซิร์ฟเวอร์เรพลิกาจำนวนเท่าใดที่อาจมีในคลัสเตอร์ที่โฮสต์ค่านี้)

หน่วยการสร้าง

ภาษาของ Federated Core เป็นรูปแบบหนึ่งของ แลมบ์ดา-แคลคูลัส โดยมีองค์ประกอบเพิ่มเติมบางประการ

โดยจัดเตรียมบทคัดย่อการเขียนโปรแกรมต่อไปนี้ซึ่งปัจจุบันเปิดเผยใน API สาธารณะ:

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

  นี่คือตัวอย่างหนึ่ง การคำนวณ TF ประเภท (int32* -> int) ที่ใช้ตัวดำเนินการ tf.data.Dataset.reduce เพื่อคำนวณผลรวมของจำนวนเต็ม:

  @tff.tensorflow.computation(tff.SequenceType(np.int32))
  def add_up_integers(x):
    return x.reduce(np.int32(0), lambda x, y: x + y)
  

• ตัวดำเนินการภายใน หรือ ตัวดำเนินการแบบรวมศูนย์ ( tff.federated_... ) นี่คือไลบรารีของฟังก์ชัน เช่น tff.federated_sum หรือ tff.federated_broadcast ที่ประกอบด้วย FC API จำนวนมาก ซึ่งส่วนใหญ่เป็นตัวแทนของตัวดำเนินการสื่อสารแบบกระจายสำหรับใช้กับ TFF

  เราเรียกสิ่งเหล่านี้ว่า intrinsics เพราะว่า เหมือนกับ intrinsic function ตรงที่พวกมันคือชุดตัวดำเนินการแบบปลายเปิดและขยายได้ ซึ่ง TFF เข้าใจ และคอมไพล์ลงในโค้ดระดับล่าง

  ตัวดำเนินการเหล่านี้ส่วนใหญ่มีพารามิเตอร์และผลลัพธ์เป็นประเภทแบบรวมศูนย์ และส่วนใหญ่เป็นเทมเพลตที่สามารถนำไปใช้กับข้อมูลประเภทต่างๆ ได้

  ตัวอย่างเช่น tff.federated_broadcast สามารถถือเป็นตัวดำเนินการเทมเพลตของประเภทฟังก์ชัน T@SERVER -> T@CLIENTS

• นิพจน์แลมบ์ดา ( tff.federated_computation ) นิพจน์แลมบ์ดาใน TFF เทียบเท่ากับ lambda หรือ def ใน Python ประกอบด้วยชื่อพารามิเตอร์ และเนื้อหา (นิพจน์) ที่มีการอ้างอิงถึงพารามิเตอร์นี้

  ในโค้ด Python สิ่งเหล่านี้สามารถสร้างขึ้นได้โดยการตกแต่งฟังก์ชัน Python ด้วย tff.federated_computation และกำหนดอาร์กิวเมนต์

  นี่คือตัวอย่างของนิพจน์แลมบ์ดาที่เราได้กล่าวถึงไปแล้วก่อนหน้านี้:

  @tff.federated_computation(tff.FederatedType(np.float32, tff.CLIENTS))
  def get_average_temperature(sensor_readings):
    return tff.federated_mean(sensor_readings)
  

• ตัวอักษรตำแหน่ง สำหรับตอนนี้ เฉพาะ tff.SERVER และ tff.CLIENTS เท่านั้นที่อนุญาตให้กำหนดการคำนวณไคลเอ็นต์-เซิร์ฟเวอร์อย่างง่าย

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

  ตัวอย่างเช่น:

  • add_up_integers(x) แสดงถึงการเรียกใช้การคำนวณ TensorFlow ที่กำหนดไว้ก่อนหน้าในอาร์กิวเมนต์ x ประเภทของนิพจน์นี้คือ int32

  • tff.federated_mean(sensor_readings) แสดงถึงการเรียกใช้ตัวดำเนินการเฉลี่ยแบบรวมศูนย์บน sensor_readings ประเภทของนิพจน์นี้คือ float32@SERVER (สมมติว่ามีบริบทจากตัวอย่างด้านบน)

• การสร้าง สิ่งอันดับ และ เลือก องค์ประกอบ นิพจน์ Python ในรูปแบบ [x, y] , x[y] หรือ xy ที่ปรากฏในเนื้อหาของฟังก์ชันที่ตกแต่งด้วย tff.federated_computation