सीखने के लिए अनुशंसित समेकन ट्यूनिंग

TensorFlow.org पर देखें

Google Colab में चलाएं

GitHub पर स्रोत देखें

नोटबुक डाउनलोड करें

tff.learning मॉड्यूल सिफारिश डिफ़ॉल्ट कॉन्फ़िगरेशन के साथ कुल मॉडल अद्यतनों के लिए तरीके का एक संख्या में शामिल हैं:

• tff.learning.robust_aggregator
• tff.learning.dp_aggregator
• tff.learning.compression_aggregator
• tff.learning.secure_aggregator

इस ट्यूटोरियल में, हम अंतर्निहित प्रेरणा की व्याख्या करते हैं कि उन्हें कैसे लागू किया जाता है, और उनके कॉन्फ़िगरेशन को कैसे अनुकूलित किया जाए, इसके लिए सुझाव प्रदान करते हैं।

!pip install --quiet --upgrade tensorflow-federated-nightly
!pip install --quiet --upgrade nest-asyncio

import nest_asyncio
nest_asyncio.apply()

import math
import tensorflow_federated as tff
tff.federated_computation(lambda: 'Hello, World!')()

b'Hello, World!'

एकत्रीकरण तरीकों वस्तुओं के लिए पारित किया जा सकता है कि प्रतिनिधित्व कर रहे हैं tff.learning.build_federated_averaging_process अपने रूप model_update_aggregation_factory कीवर्ड तर्क। जैसे, एग्रीगेटर्स यहाँ पर चर्चा सीधे एक संशोधित करने के लिए इस्तेमाल किया जा सकता पिछले ट्यूटोरियल फ़ेडरेटेड सीखने पर।

से मतलब भारित आधारभूत FedAvg कलन विधि का उपयोग व्यक्त किया जा सकता tff.aggregators.MeanFactory इस प्रकार है:

mean = tff.aggregators.MeanFactory()
iterative_process = tff.learning.build_federated_averaging_process(
    ...,
    model_update_aggregation_factory=mean)

इस ट्यूटोरियल में शामिल भारित माध्य का विस्तार करने के लिए जिन तकनीकों का उपयोग किया जा सकता है वे हैं:

• ज़ीरोइंग
• कतरन
• विभेदक गोपनीयता
• दबाव
• सुरक्षित एकत्रीकरण

विस्तार रचना, जिसमें उपयोग किया जाता है MeanFactory एक आंतरिक कारखाने जो यह एकत्रीकरण का कुछ हिस्सा प्रतिनिधियों, या है करने के लिए स्वयं एक और एकत्रीकरण कारखाने से लिपटे गिर्द घूमती है। डिजाइन पर अधिक विस्तार के लिए, देखें कार्यान्वयन कस्टम एग्रीगेटर्स ट्यूटोरियल।

सबसे पहले, हम बताएंगे कि इन तकनीकों को व्यक्तिगत रूप से कैसे सक्षम और कॉन्फ़िगर किया जाए, और फिर दिखाएं कि उन्हें एक साथ कैसे जोड़ा जा सकता है।

तकनीक

अलग-अलग तकनीकों में जाने से पहले, हम पहले क्वांटाइल मिलान एल्गोरिदम पेश करते हैं, जो नीचे दी गई तकनीकों को कॉन्फ़िगर करने के लिए उपयोगी होगा।

मात्रा मिलान

नीचे दी गई कई एकत्रीकरण तकनीकों को एक मानदंड का उपयोग करने की आवश्यकता है जो एकत्रीकरण के कुछ पहलू को नियंत्रित करता है। इस तरह की सीमा एक स्थिर के रूप में प्रदान की जा सकती है, लेकिन आमतौर पर प्रशिक्षण के दौरान बाध्य को अनुकूलित करना बेहतर होता है। की सिफारिश की रास्ते से quantile मिलान एल्गोरिथ्म का उपयोग है एंड्रयू एट अल। (2019) , शुरू में अधिक मोटे तौर पर अंतर गोपनीयता लेकिन उपयोगी के साथ अपने संगतता के लिए प्रस्ताव रखा। किसी दिए गए quantile पर मूल्य का अनुमान करने के लिए, आप उपयोग कर सकते tff.aggregators.PrivateQuantileEstimationProcess । उदाहरण के लिए, किसी वितरण के माध्यिका के अनुकूल होने के लिए, आप इसका उपयोग कर सकते हैं:

median_estimate = tff.aggregators.PrivateQuantileEstimationProcess.no_noise(
    initial_estimate=1.0, target_quantile=0.5, learning_rate=0.2)

जैसा कि हम देखेंगे, विभिन्न तकनीकी तकनीकें जो मात्रात्मक अनुमान एल्गोरिथ्म का उपयोग करती हैं, उन्हें एल्गोरिथम मापदंडों के विभिन्न मूल्यों की आवश्यकता होगी। सामान्य तौर पर, बढ़ रही learning_rate पैरामीटर साधन तेजी से सही quantile के अनुकूलन है, लेकिन एक उच्च विचरण के साथ। no_noise classmethod निर्माणों एक quantile मिलान प्रक्रिया है कि अंतर की गोपनीयता के लिए शोर नहीं जोड़ता है।

ज़ीरोइंग

ज़ीरोइंग का तात्पर्य असामान्य रूप से बड़े मानों को शून्य से बदलना है। यहां, "असामान्य रूप से बड़ा" का अर्थ पूर्वनिर्धारित सीमा से बड़ा हो सकता है, या गणना के पिछले दौर के मूल्यों के सापेक्ष बड़ा हो सकता है। ज़ीरोइंग दोषपूर्ण ग्राहकों पर डेटा भ्रष्टाचार के लिए सिस्टम की मजबूती को बढ़ा सकता है।

एल अनंत मानदंडों से बड़ा के साथ मूल्यों का एक मतलब की गणना करने के ZEROING_CONSTANT ध्यान केंद्रित किया बाहर, हम एक लपेटो tff.aggregators.MeanFactory एक साथ tff.aggregators.zeroing_factory कि प्रदर्शन के शून्यीकरण:

zeroing_mean = tff.aggregators.zeroing_factory(
    zeroing_norm=MY_ZEROING_CONSTANT,
    inner_agg_factory=tff.aggregators.MeanFactory())

यहाँ हम एक लपेटो MeanFactory एक साथ zeroing_factory क्योंकि हम (पूर्व एकत्रीकरण) चाहते हैं के प्रभाव zeroing_factory ग्राहकों पर मूल्यों के लिए लागू करने के लिए इससे पहले कि वे आंतरिक को पास किया जाता MeanFactory औसत के माध्यम से एकत्रीकरण के लिए।

हालांकि, अधिकांश अनुप्रयोगों के लिए हम मात्रात्मक अनुमानक के साथ अनुकूली शून्यिंग की सलाह देते हैं। ऐसा करने के लिए, हम मात्रात्मक मिलान एल्गोरिथ्म का उपयोग निम्नानुसार करते हैं:

zeroing_norm = tff.aggregators.PrivateQuantileEstimationProcess.no_noise(
    initial_estimate=10.0,
    target_quantile=0.98,
    learning_rate=math.log(10),
    multiplier=2.0,
    increment=1.0)
zeroing_mean = tff.aggregators.zeroing_factory(
    zeroing_norm=zeroing_norm,
    inner_agg_factory=tff.aggregators.MeanFactory())

# Equivalent to:
# zeroing_mean = tff.learning.robust_aggregator(clipping=False)

मापदंडों चुना गया है, ताकि प्रक्रिया adapts बहुत जल्दी (अपेक्षाकृत बड़े learning_rate एक मूल्य के लिए) कुछ हद तक सबसे बड़ा मान अब तक देखा की तुलना में बड़ा। एक quantile अनुमान लगाने के लिए Q , सीमा के शून्यीकरण हो जाएगा के लिए इस्तेमाल किया Q * multiplier + increment ।

L2 मानदंड को बाध्य करने के लिए क्लिपिंग

क्लाइंट अपडेट को क्लिप करना (L2 बॉल पर प्रोजेक्ट करना) आउटलेर्स की मजबूती में सुधार कर सकता है। एक tff.aggregators.clipping_factory संरचित है वास्तव में की तरह tff.aggregators.zeroing_factory ऊपर चर्चा की, और या तो एक निरंतर या ले जा सकते हैं tff.templates.EstimationProcess अपने रूप clipping_norm तर्क। अनुशंसित सर्वोत्तम अभ्यास क्लिपिंग का उपयोग करना है जो मध्यम रूप से जल्दी से मध्यम रूप से उच्च मानदंड को अपनाता है, जैसा कि निम्नानुसार है:

clipping_norm = tff.aggregators.PrivateQuantileEstimationProcess.no_noise(
    initial_estimate=1.0,
    target_quantile=0.8,
    learning_rate=0.2)
clipping_mean = tff.aggregators.clipping_factory(
    clipping_norm=clipping_norm,
    inner_agg_factory=tff.aggregators.MeanFactory())

# Equivalent to:
# clipping_mean = tff.learning.robust_aggregator(zeroing=False)

कई समस्याओं में हमारे अनुभव में, के सटीक मूल्य target_quantile इतने लंबे समय के रूप में सीखने की दरों को उचित रूप से देखते हैं बहुत ज्यादा फर्क नहीं लगता है। हालांकि, इसे बहुत कम सेट करने के लिए क्लिपिंग का उपयोग न करने के सापेक्ष सर्वर सीखने की दर को बढ़ाने की आवश्यकता हो सकती है, यही कारण है कि हम डिफ़ॉल्ट रूप से 0.8 की अनुशंसा करते हैं।

विभेदक गोपनीयता

अनुकूली कतरन और गाऊसी शोर का उपयोग करते हुए, TFF अलग-अलग निजी एकत्रीकरण का भी समर्थन करता है। अलग-अलग निजी औसत प्रदर्शन करने के लिए एक एग्रीगेटर का निर्माण निम्नानुसार किया जा सकता है:

dp_mean = tff.aggregators.DifferentiallyPrivateFactory.gaussian_adaptive(
    noise_multiplier=0.1, clients_per_round=100)

# Equivalent to:
# dp_mean = tff.learning.dp_aggregator(
#   noise_multiplier=0.1, clients_per_round=100, zeroing=False)

कैसे स्थापित करने के लिए पर मार्गदर्शन noise_multiplier तर्क में पाया जा सकता TFF डीपी ट्यूटोरियल ।

हानिपूर्ण संपीड़न

दोषरहित संपीड़न जैसे कि gzip की तुलना में, हानिपूर्ण संपीड़न का परिणाम आम तौर पर बहुत अधिक संपीड़न अनुपात में होता है और बाद में इसे दोषरहित संपीड़न के साथ जोड़ा जा सकता है। चूंकि क्लाइंट-टू-सर्वर संचार पर कम समय खर्च करने की आवश्यकता होती है, प्रशिक्षण दौर तेजी से पूरा होता है। सीखने के एल्गोरिदम की स्वाभाविक रूप से यादृच्छिक प्रकृति के कारण, कुछ सीमा तक, हानिपूर्ण संपीड़न से अशुद्धि समग्र प्रदर्शन पर नकारात्मक प्रभाव नहीं डालती है।

डिफ़ॉल्ट सिफारिश सरल वर्दी परिमाणीकरण उपयोग करने के लिए (देखें है । सुरेश एट अल टेन्सर आकार संपीड़न: उदाहरण के लिए), दो मानों द्वारा parameterized threshold और की संख्या quantization_bits । हर टेन्सर के लिए t , अगर के तत्वों की संख्या t कम है या के बराबर threshold , यह संपीड़ित नहीं है। यदि यह बड़ा है, के तत्वों t करने के लिए बेतरतीब राउंडिंग का उपयोग कर रहे हैं quantized quantizaton_bits बिट्स। यानी हम ऑपरेशन लागू करते हैं

t = round((t - min(t)) / (max(t) - min(t)) * (2**quantizaton_bits - 1)),

की सीमा में पूर्णांक मूल्यों में जिसके परिणामस्वरूप [0, 2**quantizaton_bits-1] । परिमाणित मान सीधे संचरण के लिए एक पूर्णांक प्रकार में पैक किए जाते हैं, और फिर उलटा परिवर्तन लागू किया जाता है।

हम करने का सुझाव देते quantizaton_bits 8 और के बराबर threshold 20000 के बराबर:

compressed_mean = tff.aggregators.MeanFactory(
    tff.aggregators.EncodedSumFactory.quantize_above_threshold(
        quantization_bits=8, threshold=20000))

# Equivalent to:
# compressed_mean = tff.learning.compression_aggregator(zeroing=False, clipping=False)

ट्यूनिंग सुझाव

दोनों मानकों, quantization_bits और threshold समायोजित किया जा सकता है, और प्रत्येक प्रशिक्षण दौर में भाग लेने वाले ग्राहकों की संख्या भी संपीड़न के प्रभाव को प्रभावित कर सकता है।

सीमा। 20000 का डिफ़ॉल्ट मान चुना जाता है क्योंकि हमने देखा है कि कम संख्या में तत्वों के साथ चर, जैसे कि सामान्य परत प्रकारों में पूर्वाग्रह, शुरू किए गए शोर के प्रति अधिक संवेदनशील होते हैं। इसके अलावा, व्यवहार में कम संख्या में तत्वों के साथ चर को संपीड़ित करने से बहुत कम लाभ होता है, क्योंकि उनका असम्पीडित आकार शुरू में अपेक्षाकृत छोटा होता है।

कुछ अनुप्रयोगों में थ्रेसहोल्ड की पसंद को बदलने का अर्थ हो सकता है। उदाहरण के लिए, एक वर्गीकरण मॉडल की आउटपुट परत के पूर्वाग्रह शोर के प्रति अधिक संवेदनशील हो सकते हैं। आप 20004 की शब्दावली के साथ एक भाषा मॉडल प्रशिक्षित कर रहे हैं, तो आप सेट कर सकते हैं threshold 20004 किया जाना है।

परिमाणीकरण बिट्स। के लिए 8 का डिफ़ॉल्ट मान quantization_bits अधिकांश उपयोगकर्ताओं के लिए ठीक होना चाहिए। यदि 8 अच्छी तरह से काम कर रहा है और आप थोड़ा और प्रदर्शन निचोड़ना चाहते हैं, तो आप इसे 7 या 6 तक ले जाने का प्रयास कर सकते हैं। यदि संसाधन एक छोटी ग्रिड खोज करने की अनुमति देते हैं, तो हम अनुशंसा करेंगे कि आप उस मूल्य की पहचान करें जिसके लिए प्रशिक्षण अस्थिर हो जाता है या अंतिम मॉडल की गुणवत्ता घटने लगती है, और फिर उस मान को दो से बढ़ा देती है। उदाहरण के लिए, की स्थापना करता है, तो quantization_bits 5 कार्यों के लिए है, लेकिन 4 में खराबी आ रही करने के लिए यह मॉडल की स्थापना, हम अनुशंसा करते हैं डिफ़ॉल्ट 6 "सुरक्षित पक्ष पर" होने के लिए किया जाना है।

ग्राहक प्रति दौर। ध्यान दें कि काफी गोल प्रति ग्राहकों की संख्या में वृद्धि के लिए एक छोटा मान सक्षम कर सकते हैं quantization_bits , अच्छी तरह से काम करने के लिए, क्योंकि यादृच्छिक अशुद्धि परिमाणीकरण द्वारा शुरू की अधिक ग्राहक अपडेट से अधिक औसत से बाहर evened जा सकता है।

सुरक्षित एकत्रीकरण

सिक्योर एग्रीगेशन (SecAgg) द्वारा हम एक क्रिप्टोग्राफ़िक प्रोटोकॉल का उल्लेख करते हैं जिसमें क्लाइंट अपडेट को इस तरह से एन्क्रिप्ट किया जाता है कि सर्वर केवल उनकी राशि को डिक्रिप्ट कर सकता है। यदि वापस रिपोर्ट करने वाले ग्राहकों की संख्या अपर्याप्त है, तो सर्वर कुछ भी नहीं सीखेगा - और किसी भी स्थिति में सर्वर व्यक्तिगत अपडेट का निरीक्षण करने में सक्षम नहीं होगा। इस का उपयोग करते हुए महसूस किया है tff.federated_secure_sum_bitwidth ऑपरेटर।

मॉडल अपडेट फ़्लोटिंग पॉइंट मान हैं, लेकिन SecAgg पूर्णांकों पर काम करता है। इसलिए हमें किसी भी बड़े मान को एक पूर्णांक प्रकार के विवेकीकरण से पहले कुछ बाध्य करने की आवश्यकता है। क्लिपिंग बाउंड या तो स्थिर हो सकता है या अनुकूली रूप से निर्धारित किया जा सकता है (अनुशंसित डिफ़ॉल्ट)। फिर पूर्णांकों को सुरक्षित रूप से सम्‍मिलित किया जाता है, और योग को फ़्लोटिंग पॉइंट डोमेन पर वापस मैप किया जाता है।

साथ SecAgg का उपयोग कर अभिव्यक्त भारित मूल्यों के साथ एक मतलब की गणना करने के MY_SECAGG_BOUND कतरन बाध्य के रूप में, पारित SecureSumFactory को MeanFactory के रूप में:

secure_mean = tff.aggregators.MeanFactory(
    tff.aggregators.SecureSumFactory(MY_SECAGG_BOUND))

अनुकूल रूप से सीमा निर्धारित करते समय ऐसा करने के लिए:

secagg_bound = tff.aggregators.PrivateQuantileEstimationProcess.no_noise(
    initial_estimate=50.0,
    target_quantile=0.95,
    learning_rate=1.0,
    multiplier=2.0)
secure_mean = tff.aggregators.MeanFactory(
    tff.aggregators.SecureSumFactory(secagg_bound))

# Equivalent to:
# secure_mean = tff.learning.secure_aggregator(zeroing=Fasle, clipping=False)

ट्यूनिंग सुझाव

अनुकूली मापदंडों को चुना गया है ताकि सीमाएं तंग हों (हम विवेक में ज्यादा सटीकता नहीं खोएंगे) लेकिन क्लिपिंग शायद ही कभी होती है।

यदि मापदंडों को ट्यून किया जाता है, तो ध्यान रखें कि SecAgg प्रोटोकॉल भारित मॉडल अपडेट को माध्य में भारित करने के बाद जोड़ रहा है। वज़न आमतौर पर स्थानीय रूप से संसाधित किए गए डेटा बिंदुओं की संख्या होती है, इसलिए विभिन्न कार्यों के बीच, सही सीमा इस मात्रा पर निर्भर हो सकती है।

हम उपयोग करने की अनुशंसा नहीं है increment जब अनुकूली बनाने कीवर्ड तर्क secagg_bound , ऊपर छोटे किया जा रहा वास्तविक अनुमान समाप्त होता है के रूप में यह एक अपेक्षाकृत ज्यादा बड़ा परिशुद्धता नुकसान में परिणाम सकता है, मामले में।

उपरोक्त कोड स्निपेट SecAgg केवल भारित मानों का उपयोग करेगा। यदि वजन के योग के लिए SecAgg का भी उपयोग किया जाना चाहिए, तो हम अनुशंसा करते हैं कि सीमा को स्थिरांक के रूप में सेट किया जाए, जैसा कि एक सामान्य प्रशिक्षण सेटअप में, सबसे बड़ा संभव वजन पहले से ज्ञात होगा:

secure_mean = tff.aggregators.MeanFactory(
    value_sum_factory=tff.aggregators.SecureSumFactory(secagg_bound),
    weight_sum_factory=tff.aggregators.SecureSumFactory(
        upper_bound_threshold=MAX_WEIGHT, lower_bound_threshold=0.0))

रचना तकनीक

ऊपर बताए गए माध्य के विस्तार के लिए व्यक्तिगत तकनीकों को एक साथ जोड़ा जा सकता है।

हम अनुशंसा करते हैं कि ग्राहकों पर इन तकनीकों को किस क्रम में लागू किया जाए

1. ज़ीरोइंग
2. कतरन
3. अन्य तकनीक

में एग्रीगेटर्स tff.aggregators रैपिंग "आंतरिक एग्रीगेटर्स" (जिसका पूर्व एकत्रीकरण प्रभाव हो पिछले और बाद के एकत्रीकरण प्रभाव पहले हो) "बाहरी एग्रीगेटर्स" अंदर से बना रहे हैं मॉड्यूल। उदाहरण के लिए, शून्यिंग, क्लिपिंग और संपीड़न (उस क्रम में) करने के लिए, कोई लिखेगा:

# Compression is innermost because its pre-aggregation effects are last.
compressed_mean = tff.aggregators.MeanFactory(
    tff.aggregators.EncodedSumFactory.quantize_above_threshold(
        quantization_bits=8, threshold=20000))
# Compressed mean is inner aggregator to clipping...
clipped_compressed_mean = tff.aggregators.clipping_factory(
    clipping_norm=MY_CLIPPING_CONSTANT,
    inner_agg_factory=compressed_mean)
# ...which is inner aggregator to zeroing, since zeroing happens first.
final_aggregator = tff.aggregators.zeroing_factory(
    zeroing_norm=MY_ZEROING_CONSTANT,
    inner_agg_factory=clipped_compressed_mean)

ध्यान दें कि यह संरचना से मेल खाता है डिफ़ॉल्ट एग्रीगेटर्स एल्गोरिदम सीखने के लिए।

अन्य रचनाएँ भी संभव हैं। हम इस दस्तावेज़ का विस्तार तब करते हैं जब हमें विश्वास होता है कि हम डिफ़ॉल्ट कॉन्फ़िगरेशन प्रदान कर सकते हैं जो कई अलग-अलग अनुप्रयोगों में काम करता है। नए विचारों को लागू करने के लिए, देखें कार्यान्वयन कस्टम एग्रीगेटर्स ट्यूटोरियल।