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

จัดทุกอย่างให้เป็นระเบียบอยู่เสมอด้วยคอลเล็กชัน บันทึกและจัดหมวดหมู่เนื้อหาตามค่ากำหนดของคุณ

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

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

นอกจากนี้ เราขอแนะนำให้คุณทำความคุ้นเคยกับ 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 หรือ TensorFlow

    TensorTypes ของ 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