เอกสารนี้แนะนำเลเยอร์หลักของ TFF ซึ่งทำหน้าที่เป็นรากฐานสำหรับการเรียนรู้แบบ สหพันธรัฐ และอัลกอริทึมแบบรวมศูนย์ที่ไม่ใช่การเรียนรู้ในอนาคตที่เป็นไปได้
สำหรับคำแนะนำเบื้องต้นเกี่ยวกับ Federated Core โปรดอ่านบทช่วยสอนต่อไปนี้ เนื่องจากจะแนะนำแนวคิดพื้นฐานบางส่วนตามตัวอย่าง และสาธิตการสร้างอัลกอริทึมแบบรวมทั่วไปอย่างง่ายทีละขั้นตอน
Custom Federated Algorithm ส่วนที่ 1: ข้อมูลเบื้องต้นเกี่ยวกับ Federated Core
อัลกอริธึมแบบรวมศูนย์แบบกำหนดเอง ส่วนที่ 2: การนำ Federated Averaging ไปใช้
นอกจากนี้ เราขอแนะนำให้คุณทำความคุ้นเคยกับ Federated Learning และบทช่วยสอนที่เกี่ยวข้องเกี่ยวกับ การจัดประเภทรูปภาพ และ การสร้างข้อความ เนื่องจากการใช้ Federated Core API (FC API) สำหรับการเรียนรู้แบบรวมศูนย์จะให้บริบทที่สำคัญสำหรับตัวเลือกบางอย่างที่เราได้ดำเนินการ การออกแบบเลเยอร์นี้
ภาพรวม
เป้าหมาย วัตถุประสงค์การใช้งาน และขอบเขต
Federated Core (FC) เป็นที่เข้าใจได้ดีที่สุดว่าเป็นสภาพแวดล้อมการเขียนโปรแกรมสำหรับการนำการคำนวณแบบกระจายไปใช้ เช่น การคำนวณที่เกี่ยวข้องกับคอมพิวเตอร์หลายเครื่อง (โทรศัพท์มือถือ แท็บเล็ต อุปกรณ์ฝังตัว คอมพิวเตอร์เดสก์ท็อป เซ็นเซอร์ เซิร์ฟเวอร์ฐานข้อมูล ฯลฯ) ที่อาจทำงานไม่ การประมวลผลเล็กน้อยในพื้นที่ และสื่อสารผ่านเครือข่ายเพื่อประสานงานการทำงานของพวกเขา
คำว่า distribution เป็นคำที่สามัญมาก และ TFF ไม่ได้กำหนดเป้าหมายไปยังอัลกอริธึมแบบกระจายทุกประเภทที่เป็นไปได้ ดังนั้นเราจึงต้องการใช้คำทั่วไปน้อยกว่า federated computation เพื่ออธิบายประเภทของอัลกอริธึมที่สามารถแสดงออกมาในเฟรมเวิร์กนี้ได้
แม้ว่าการกำหนดคำว่า การคำนวณแบบรวม ศูนย์ในลักษณะที่เป็นทางการอย่างสมบูรณ์นั้นอยู่นอกเหนือขอบเขตของเอกสารนี้ ให้นึกถึงประเภทของอัลกอริธึมที่คุณอาจเห็นแสดงในโค้ดเทียมใน เอกสารงานวิจัย ที่อธิบายอัลกอริธึมการเรียนรู้แบบกระจายใหม่
โดยสรุป เป้าหมายของ FC คือการเปิดใช้งานการแสดงข้อมูลแบบย่อที่คล้ายคลึงกันในระดับนามธรรมที่คล้ายกันของรหัสเทียม ของตรรกะของโปรแกรมที่ ไม่ใช่ รหัสเทียม แต่สามารถเรียกใช้งานได้ในสภาพแวดล้อมเป้าหมายที่หลากหลาย
ลักษณะการกำหนดที่สำคัญของประเภทของอัลกอริธึมที่ FC ออกแบบมาเพื่อแสดงคือการอธิบายการกระทำของผู้เข้าร่วมระบบในลักษณะรวม ดังนั้น เรามักจะพูดถึง อุปกรณ์แต่ละเครื่อง ที่แปลงข้อมูลในเครื่อง และอุปกรณ์ที่ประสานงานทำงานโดยผู้ประสานงานแบบรวมศูนย์ กระจายเสียง รวบรวม หรือ รวบรวม ผลลัพธ์
แม้ว่า TFF ได้รับการออกแบบมาเพื่อให้สามารถไปได้ไกลกว่าสถาปัตยกรรม ไคลเอนต์-เซิร์ฟเวอร์ ทั่วไป แต่แนวคิดของการประมวลผลแบบรวมเป็นพื้นฐาน ทั้งนี้เนื่องมาจากต้นกำเนิดของ TFF ในการเรียนรู้แบบสหพันธรัฐ ซึ่งเป็นเทคโนโลยีที่ออกแบบมาเพื่อรองรับการคำนวณข้อมูลที่อาจมีความละเอียดอ่อนซึ่งยังคงอยู่ภายใต้การควบคุมของอุปกรณ์ไคลเอ็นต์ และอาจไม่ได้ดาวน์โหลดไปยังตำแหน่งส่วนกลางเพียงเพื่อเหตุผลด้านความเป็นส่วนตัว แม้ว่าลูกค้าแต่ละรายในระบบดังกล่าวจะให้ข้อมูลและพลังในการประมวลผลต่อการคำนวณผลลัพธ์ของระบบ (ผลลัพธ์ที่เราคาดว่าจะมีค่าสำหรับผู้เข้าร่วมทั้งหมด) เรายังพยายามรักษาความเป็นส่วนตัวและการไม่เปิดเผยตัวตนของลูกค้าแต่ละราย
ดังนั้น ในขณะที่เฟรมเวิร์กส่วนใหญ่สำหรับการคำนวณแบบกระจายได้รับการออกแบบเพื่อแสดงการประมวลผลจากมุมมองของผู้เข้าร่วมแต่ละคน นั่นคือที่ระดับของการแลกเปลี่ยนข้อความแบบจุดต่อจุดแต่ละรายการ และการพึ่งพาอาศัยกันของการเปลี่ยนสถานะท้องถิ่นของผู้เข้าร่วมด้วยข้อความขาเข้าและขาออก Federated Core ของ TFF ได้รับการออกแบบมาเพื่ออธิบายพฤติกรรมของระบบจากมุมมองของ ทั่ว ทั้งระบบ (คล้ายกับ MapReduce )
ดังนั้น ในขณะที่เฟรมเวิร์กแบบกระจายสำหรับวัตถุประสงค์ทั่วไปอาจเสนอการดำเนินการต่างๆ เช่น ส่ง และ รับ เป็นหน่วยการสร้าง แต่ FC จัดเตรียมบล็อคส่วนประกอบ เช่น tff.federated_sum
, tff.federated_reduce
หรือ tff.federated_broadcast
ที่ห่อหุ้มโปรโตคอลแบบกระจายอย่างง่าย
ภาษา
อินเทอร์เฟซ Python
TFF ใช้ภาษาภายในเพื่อแทนการคำนวณแบบรวมศูนย์ ไวยากรณ์ที่กำหนดโดยการแทนค่าอนุกรมใน computation.proto ผู้ใช้ FC API โดยทั่วไปจะไม่จำเป็นต้องโต้ตอบกับภาษานี้โดยตรง แต่เราจัดเตรียม Python API (เนมสเปซ tff
) ที่ล้อมรอบไว้เพื่อกำหนดการคำนวณ
โดยเฉพาะอย่างยิ่ง TFF มีตัวตกแต่งฟังก์ชัน Python เช่น tff.federated_computation
ที่ติดตามเนื้อหาของฟังก์ชันที่ตกแต่ง และสร้างการแสดงแทนค่าตรรกะการคำนวณแบบรวมศูนย์ในภาษาของ TFF ฟังก์ชันที่ตกแต่งด้วย tff.federated_computation
ทำหน้าที่เป็นพาหะของการแทนค่าแบบอนุกรมดังกล่าว และสามารถฝังไว้เป็นหน่วยการสร้างในเนื้อความของการคำนวณอื่น หรือดำเนินการตามต้องการเมื่อเรียกใช้
นี่เป็นเพียงตัวอย่างเดียว ตัวอย่างเพิ่มเติมสามารถพบได้ในบทช่วยสอน อัลกอริธึมที่กำหนดเอง
@tff.federated_computation(tff.type_at_clients(tf.float32))
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 ops ในกราฟ TensorFlow แต่อาจรวมถึงหน่วยของข้อมูลที่สามารถผลิตได้ เช่น เป็นเอาต์พุตของการกระจาย โปรโตคอลการรวม ดังนั้น ประเภท TFF เทนเซอร์จึงเป็นเวอร์ชันนามธรรมของการแสดงทางกายภาพที่เป็นรูปธรรมของประเภทดังกล่าวใน Python หรือ TensorFlowTensorTypes
ของ TFF สามารถรักษารูปร่าง (คงที่) ได้เข้มงวดกว่า TensorFlow ตัวอย่างเช่น ระบบพิมพ์ของ TFF ถือว่าเทนเซอร์ที่มีอันดับที่ไม่รู้จักว่ากำหนดได้ จาก เทนเซอร์อื่นๆ ของdtype
เดียวกัน แต่ไม่สามารถกำหนด ให้ กับเทนเซอร์ที่มีอันดับคงที่ได้ การรักษานี้ป้องกันความล้มเหลวรันไทม์บางอย่าง (เช่น พยายามปรับเทนเซอร์ของอันดับที่ไม่รู้จักให้เป็นรูปร่างที่มีจำนวนองค์ประกอบที่ไม่ถูกต้อง) โดยต้องเสียค่าความเข้มงวดมากขึ้นในสิ่งที่การคำนวณ TFF ยอมรับว่าถูกต้องสัญกรณ์ขนาดกะทัดรัดสำหรับประเภทเทนเซอร์คือ
dtype
หรือdtype[shape]
ตัวอย่างเช่นint32
และint32[10]
เป็นประเภทของจำนวนเต็มและเวกเตอร์ int ตามลำดับประเภทลำดับ (
tff.SequenceType
) สิ่งเหล่านี้เทียบเท่านามธรรมของ TFF กับแนวคิดที่เป็นรูปธรรมของ TensorFlow ของtf.data.Dataset
องค์ประกอบของลำดับสามารถนำมาใช้ในลักษณะที่ต่อเนื่องกัน และสามารถรวมประเภทที่ซับซ้อนได้การแสดงประเภทลำดับอย่างย่อคือ
T*
โดยที่T
คือประเภทขององค์ประกอบ ตัวอย่างเช่นint32*
แสดงถึงลำดับจำนวนเต็มประเภททูเปิลที่มีชื่อ (
tff.StructType
) นี่เป็นวิธีการของ TFF ในการสร้างทูเพิลและโครงสร้างที่เหมือนพจนานุกรมซึ่งมี องค์ประกอบ ที่กำหนดไว้ล่วงหน้าซึ่งมีประเภทเฉพาะ มีชื่อหรือไม่มีชื่อ ที่สำคัญ แนวคิด tuple ที่มีชื่อของ TFF ครอบคลุมสิ่งที่เทียบเท่านามธรรมของสิ่งอันดับอาร์กิวเมนต์ของ Python กล่าวคือ คอลเล็กชันขององค์ประกอบซึ่งมีการตั้งชื่อบางส่วน แต่ไม่ใช่ทั้งหมด และบางส่วนมีตำแหน่งเครื่องหมายย่อสำหรับ tuples ที่มีชื่อคือ
<n_1=T_1, ..., n_k=T_k>
โดยที่n_k
เป็นชื่อองค์ประกอบทางเลือก และT_k
คือประเภทองค์ประกอบ ตัวอย่างเช่น<int32,int32>
เป็นสัญลักษณ์ย่อสำหรับจำนวนเต็มที่ไม่ทราบชื่อคู่หนึ่ง และ<X=float32,Y=float32>
เป็นสัญลักษณ์ย่อสำหรับคู่ของทุ่นชื่อX
และY
ที่อาจแสดงจุดบนระนาบ . Tuples สามารถซ้อนกันได้เช่นเดียวกับการผสมกับประเภทอื่นๆ เช่น<X=float32,Y=float32>*
จะเป็นสัญลักษณ์ย่อสำหรับลำดับของจุดประเภทฟังก์ชัน (
tff.FunctionType
) TFF เป็นเฟรมเวิร์กการเขียนโปรแกรมเชิงฟังก์ชัน โดยมีฟังก์ชันที่ถือว่าเป็น ค่าระดับเฟิร์สคลาส ฟังก์ชันมีอาร์กิวเมนต์ได้ไม่เกินหนึ่งอาร์กิวเมนต์ และมีเพียงหนึ่งผลลัพธ์เท่านั้นสัญกรณ์ย่อสำหรับฟังก์ชันคือ
(T -> U)
โดยที่T
คือประเภทของอาร์กิวเมนต์ และU
คือประเภทของผลลัพธ์ หรือ( -> U)
หากไม่มีอาร์กิวเมนต์ (แม้ว่าฟังก์ชันไม่มีอาร์กิวเมนต์จะเสื่อมลง แนวคิดที่มีอยู่ส่วนใหญ่ในระดับ Python เท่านั้น) ตัวอย่างเช่น(int32* -> int32)
เป็นสัญลักษณ์สำหรับประเภทของฟังก์ชันที่ลดลำดับจำนวนเต็มเป็นค่าจำนวนเต็มเดียว
ประเภทต่อไปนี้กล่าวถึงลักษณะของระบบแบบกระจายของการคำนวณ TFF เนื่องจากแนวคิดเหล่านี้ค่อนข้างเฉพาะตัวสำหรับ TFF เราขอแนะนำให้คุณอ้างอิงบทช่วยสอน อัลกอริทึมที่กำหนดเอง สำหรับความคิดเห็นและตัวอย่างเพิ่มเติม
ประเภทตำแหน่ง ประเภทนี้ยังไม่เปิดเผยใน API สาธารณะอื่นนอกเหนือจากในรูปแบบของ 2 ตัวอักษร
tff.SERVER
และtff.CLIENTS
ที่คุณคิดได้ว่าเป็นค่าคงที่ของประเภทนี้ อย่างไรก็ตาม มีการใช้งานภายใน และจะเปิดตัวใน API สาธารณะในรุ่นต่อๆ ไป การแสดงแบบกระชับของประเภทนี้คือplacement
ตำแหน่ง แสดงถึงกลุ่มผู้เข้าร่วมระบบที่มีบทบาทเฉพาะ การเปิดตัวครั้งแรกมีเป้าหมายที่การคำนวณแบบไคลเอนต์-เซิร์ฟเวอร์ ซึ่งมีผู้เข้าร่วม 2 กลุ่ม: ไคลเอนต์ และ เซิร์ฟเวอร์ (คุณสามารถคิดว่ากลุ่มหลังเป็นกลุ่มซิงเกิลตัน) อย่างไรก็ตาม ในสถาปัตยกรรมที่ซับซ้อนมากขึ้น อาจมีบทบาทอื่นๆ เช่น ตัวรวบรวมระดับกลางในระบบหลายระดับ ที่อาจดำเนินการรวมประเภทต่าง ๆ หรือใช้การบีบอัด/คลายข้อมูลประเภทต่างๆ มากกว่าที่ใช้โดยเซิร์ฟเวอร์หรือ ลูกค้า
วัตถุประสงค์หลักของการกำหนดแนวคิดของตำแหน่งเป็นพื้นฐานสำหรับการกำหนด ประเภทรวม
ประเภท รวม (
tff.FederatedType
) ค่าของประเภทรวมเป็นค่าที่โฮสต์โดยกลุ่มของผู้เข้าร่วมระบบที่กำหนดโดยตำแหน่งเฉพาะ (เช่น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
แสดงถึง tuple ที่มีชื่อของน้ำหนักและเทนเซอร์อคติที่เซิร์ฟเวอร์ เนื่องจากเราลดเครื่องหมายปีกกา แสดงว่าบิตall_equal
ถูกตั้งค่า กล่าวคือ มีเพียงทูเพิลตัวเดียว (ไม่ว่าจะมีการจำลองเซิร์ฟเวอร์กี่ตัวในคลัสเตอร์ที่โฮสต์ค่านี้)
การก่อสร้างตึก
ภาษาของ Federated Core คือรูปแบบของ lambda-calculus โดยมีองค์ประกอบเพิ่มเติมเล็กน้อย
ให้นามธรรมโปรแกรมต่อไปนี้เปิดเผยใน API สาธารณะ:
การคำนวณ TensorFlow (
tff.tf_computation
) นี่คือส่วนต่างๆ ของโค้ด TensorFlow ที่ห่อหุ้มเป็นส่วนประกอบที่ใช้ซ้ำได้ใน TFF โดยใช้ตัวตกแต่งtff.tf_computation
พวกมันมีประเภทการทำงานเสมอ และไม่เหมือนกับฟังก์ชันใน TensorFlow พวกมันสามารถรับพารามิเตอร์ที่มีโครงสร้างหรือส่งคืนผลลัพธ์ที่มีโครงสร้างของประเภทลำดับได้นี่คือตัวอย่างหนึ่ง การคำนวณ TF ของประเภท
(int32* -> int)
ที่ใช้ตัวดำเนินการtf.data.Dataset.reduce
เพื่อคำนวณผลรวมของจำนวนเต็ม:@tff.tf_computation(tff.SequenceType(tf.int32)) def add_up_integers(x): return x.reduce(np.int32(0), lambda x, y: x + y)
ตัวดำเนินการภายในหรือ ส่วนกลาง ( tff.federated
tff.federated_...
) นี่คือไลบรารีของฟังก์ชันต่างๆ เช่นtff.federated_sum
หรือtff.federated_broadcast
ที่ประกอบด้วย FC API จำนวนมาก ซึ่งส่วนใหญ่เป็นตัวแทนของตัวดำเนินการสื่อสารแบบกระจายสำหรับใช้กับ TFFเราเรียกสิ่งเหล่านี้ว่า intrinsics เพราะค่อนข้างเหมือนกับ intrinsic functions พวกมันคือชุดโอเปอเรเตอร์ปลายเปิดที่ขยายได้ซึ่ง TFF เข้าใจและคอมไพล์ลงในโค้ดระดับล่าง
ตัวดำเนินการเหล่านี้ส่วนใหญ่มีพารามิเตอร์และผลลัพธ์ของประเภทรวม และส่วนใหญ่เป็นเทมเพลตที่สามารถนำไปใช้กับข้อมูลประเภทต่างๆ
ตัวอย่างเช่น
tff.federated_broadcast
ถือได้ว่าเป็นตัวดำเนินการเทมเพลตของประเภทการทำงานT@SERVER -> T@CLIENTS
นิพจน์แลมบ์ดา (
tff.federated_computation
) นิพจน์แลมบ์ดาใน TFF เทียบเท่ากับlambda
หรือdef
ใน Python ประกอบด้วยชื่อพารามิเตอร์ และเนื้อหา (นิพจน์) ที่มีการอ้างอิงถึงพารามิเตอร์นี้ในโค้ด Python สิ่งเหล่านี้สามารถสร้างขึ้นได้โดยการตกแต่งฟังก์ชัน Python ด้วย
tff.federated_computation
และกำหนดอาร์กิวเมนต์นี่คือตัวอย่างนิพจน์แลมบ์ดาที่เราได้กล่าวไปแล้วก่อนหน้านี้:
@tff.federated_computation(tff.type_at_clients(tf.float32)) 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
(สมมติว่าบริบทจากตัวอย่างด้านบน)
การสร้างสิ่ง อันดับ และ การเลือก องค์ประกอบ นิพจน์หลามของรูปแบบ
[x, y]
,x[y]
หรือxy
ที่ปรากฏในเนื้อความของฟังก์ชันที่ตกแต่งด้วยtff.federated_computation