PipelineDP की मदद से निजी आंकड़ों का हिसाब लगाएं

1. शुरू करने से पहले

आपको लग सकता है कि इकट्ठा किए गए आंकड़े किसी भी व्यक्ति की ऐसी जानकारी लीक नहीं करते जिससे वे जुड़े हों. हालांकि, हमलावर कई तरीकों से कुल आंकड़ों से किसी व्यक्ति की संवेदनशील जानकारी हासिल कर सकता है.

इस कोडलैब में, आपको लोगों की जानकारी को सुरक्षित रखने के लिए, PipelineDP से डिफ़रेंशियल प्राइवेट एग्रीगेशन की मदद से निजी आंकड़े तैयार करने का तरीका पता चलेगा निजता. PipelineDP एक Python फ़्रेमवर्क है, जिसकी मदद से बैच-प्रोसेसिंग सिस्टम वाले बड़े डेटासेट में डिफ़रेंशियल प्राइवसी लागू की जा सकती है. जैसे, Apache Spark और Apache बीम. Go में अलग-अलग निजी आंकड़ों की वैल्यू को कैलकुलेट करने के तरीके के बारे में ज़्यादा जानने के लिए, बीमा पर निजता कोडलैब देखें.

निजी का मतलब है कि आउटपुट इस तरह से तैयार किया गया है कि डेटा में मौजूद किसी व्यक्ति की निजी जानकारी बिना किसी रुकावट के सार्वजनिक हो. यह नतीजा पाने के लिए, डिफ़रेंशियल प्राइवसी का इस्तेमाल किया जा सकता है. यह पहचान छिपाने की एक मज़बूत निजता धारणा है. इस प्रोसेस में, उपयोगकर्ता की निजता की सुरक्षा के लिए कई उपयोगकर्ताओं का डेटा इकट्ठा किया जाता है. पहचान छिपाने के सभी तरीकों में एग्रीगेशन का इस्तेमाल किया जाता है. हालांकि, एग्रीगेशन के सभी तरीकों में पहचान छिपाने की सुविधा नहीं मिलती. वहीं दूसरी ओर, डिफ़रेंशियल प्राइवसी, जानकारी के लीक होने और निजता से जुड़ी गारंटी देता है.

ज़रूरी शर्तें

• Python के बारे में जानकारी
• बेसिक डेटा को इकट्ठा करने की सुविधा के बारे में जानकारी
• पांडा, स्पार्क, और बीम की सुविधा

आप इन चीज़ों के बारे में जानेंगे

• डिफ़रेंशियल प्राइवसी की बुनियादी बातें
• PipelineDP की मदद से, डिफ़रेंशियल प्राइवेट सम आंकड़ों को कैलकुलेट करने का तरीका
• निजता और उपयोगिता के अतिरिक्त पैरामीटर जोड़कर, अपने नतीजों को बेहतर बनाने का तरीका

आपको इनकी ज़रूरत होगी

• अगर आपको कोडलैब अपने एनवायरमेंट में चलाना है, तो आपके कंप्यूटर पर Python 3.7 या इसके बाद वाला वर्शन इंस्टॉल होना चाहिए.
• अगर आपको अपने एनवायरमेंट के बिना कोडलैब को फ़ॉलो करना है, तो आपको Colaboratory का ऐक्सेस चाहिए.

2. डिफ़रेंशियल प्राइवसी के बारे में जानकारी

डिफ़रेंशियल प्राइवसी को बेहतर तरीके से समझने के लिए, इस आसान उदाहरण को देखें.

मान लें कि आपका काम किसी ऑनलाइन फ़ैशन रीटेलर के मार्केटिंग डिपार्टमेंट में है और आपको यह जानना है कि आपके कौनसे प्रॉडक्ट सबसे ज़्यादा बिक सकते हैं.

इस चार्ट से पता चलता है कि ग्राहकों ने दुकान की वेबसाइट पर जाने के दौरान किन प्रॉडक्ट को सबसे पहले देखा था: टी-शर्ट, जंपर, मोज़े या जींस. टी-शर्ट सबसे लोकप्रिय आइटम हैं, जबकि मोज़े सबसे कम लोकप्रिय हैं.

यह काम का लग रहा है, लेकिन इसमें एक समस्या है. अगर आपको अतिरिक्त जानकारी पर ध्यान देना है, जैसे कि ग्राहकों ने खरीदारी की है या नहीं या उन्होंने किस प्रॉडक्ट को दूसरे समय में देखा है, तो आपके डेटा में अलग-अलग लोगों की जानकारी ज़ाहिर होने का जोखिम रहता है.

इस चार्ट से पता चलता है कि सिर्फ़ एक ग्राहक ने पहले जंपर को देखा और फिर असल में खरीदारी की:

निजता के नज़रिए से यह सही नहीं है. पहचान छिपाकर दिए गए आंकड़ों से अलग-अलग योगदानों की जानकारी नहीं मिलनी चाहिए. ऐसे में आपको क्या करना चाहिए? बार चार्ट में ग़ैर-ज़रूरी आवाज़ें कम कर दी जाती हैं, ताकि उनकी सटीक जानकारी न मिल पाए!

यह बार चार्ट पूरी तरह सटीक नहीं है. हालांकि, यह अब भी काम का है और इससे अलग-अलग योगदान की जानकारी नहीं मिलती:

डिफ़रेंशियल प्राइवसी, किसी योगदान को छिपाने के लिए गै़र-ज़रूरी डेटा की सही मात्रा जोड़ देता है.

यह उदाहरण बहुत आसान है. डिफ़रेंशियल प्राइवसी को सही तरीके से लागू करना ज़्यादा अहम है. साथ ही, इसे लागू करने से जुड़ी कई बारीकियां आती हैं. क्रिप्टोग्राफ़ी की तरह ही, डिफ़रेंशियल प्राइवसी को खुद ही लागू करना सही नहीं होगा. इसके बजाय, पाइपलाइनडीपी का इस्तेमाल किया जा सकता है.

3. PipelineDP डाउनलोड और इंस्टॉल करें

आपको इस कोडलैब के हिसाब से PipelineDP इंस्टॉल करने की ज़रूरत नहीं है, क्योंकि आपको इस दस्तावेज़ में सभी ज़रूरी कोड और ग्राफ़ मिल जाएंगे.

PipelineDP से चलाने के लिए, इसे खुद चलाएं या बाद में इस्तेमाल करें:

• PipelineDP डाउनलोड और इंस्टॉल करें:

pip install pipeline-dp

यदि आप Apache बीम का इस्तेमाल करके उदाहरण चलाना चाहते हैं, तो:

• Apache बीम डाउनलोड और इंस्टॉल करें:

pip install apache_beam

इस कोडलैब के लिए कोड और डेटासेट को PipelineDP/examples/codelab/ डायरेक्ट्री में देखा जा सकता है.

4. सबसे पहले देखे गए प्रॉडक्ट के हिसाब से, कन्वर्ज़न मेट्रिक का हिसाब लगाएं

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

वेबसाइट के लिए देखे गए हर पहले प्रॉडक्ट के लिए कन्वर्ज़न मेट्रिक की गिनती करने के लिए:

1. PipelineDP/examples/codelab/ डायरेक्ट्री में, अपनी वेबसाइट पर होने वाले विज़िट का मॉक डेटासेट देखें.

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

user_id	product_view_0	product_view_1	product_view_2	product_view_3	product_view_4	has_conversion	conversion_value
0	जींस	t_shirt	t_shirt	कोई नहीं	कोई नहीं	गलत	0.0
1	जींस	t_shirt	जींस	जंपर	कोई नहीं	गलत	0.0
2	t_shirt	जंपर	t_shirt	t_shirt	कोई नहीं	सही	105.19
3	t_shirt	t_shirt	जींस	कोई नहीं	कोई नहीं	गलत	0.0
4	t_shirt	मोज़े	जींस	जींस	कोई नहीं	गलत	0.0

आपकी दिलचस्पी इन मेट्रिक में है:

• view_counts: वह संख्या जितनी बार आपकी वेबसाइट पर आने वाले लोगों ने हर प्रॉडक्ट को पहले देखा.
• total_conversion_value: वह कुल रकम जिसे वेबसाइट पर आने वाले लोग, ग्राहक में बदलने के बाद खर्च करते हैं.
• conversion_rate: वेबसाइट पर आने वाले लोगों के ग्राहक में बदलने की दर.

2. किसी गैर-निजी तरीके से मेट्रिक जनरेट करें:

conversion_metrics = df.groupby(['product_view_0'
                               ])[['conversion_value', 'has_conversion']].agg({
                                   'conversion_value': [len, np.sum],
                                   'has_conversion': np.mean
                               })
conversion_metrics = conversion_metrics.rename(
   columns={
       'len': 'view_counts',
       'sum': 'total_conversion_value',
       'mean': 'conversion_rate'
   }).droplevel(
       0, axis=1)

जैसा कि आपको पहले पता था, ये आंकड़े आपके डेटासेट में मौजूद लोगों के बारे में जानकारी दे सकते हैं. उदाहरण के लिए, किसी व्यक्ति को पहले जंपर देखने के बाद सिर्फ़ एक व्यक्ति कन्वर्ट किया गया. 22 व्यू के लिए, आपका कन्वर्ज़न रेट करीब 0.05 है. अब आपको हर बार चार्ट को निजी चार्ट में बदलना होगा.

3. pipeline_dp.NaiveBudgetAccountant क्लास की मदद से, अपने निजता पैरामीटर तय करें. इसके बाद, वे epsilon और delta आर्ग्युमेंट तय करें जिनका इस्तेमाल आपको विश्लेषण के लिए करना है.

इन आर्ग्युमेंट को सेट करने का तरीका, आपकी समस्या पर निर्भर करता है. इनके बारे में ज़्यादा जानने के लिए, वैकल्पिक देखें: डिफ़रेंशियल-निजता पैरामीटर में बदलाव करें.

यह कोड स्निपेट, उदाहरण के तौर पर दी गई वैल्यू का इस्तेमाल करता है:

budget_accountant = pipeline_dp.NaiveBudgetAccountant(
     total_epsilon=1, total_delta=1e-5)

4. LocalBackend इंस्टेंस शुरू करें:

ops = pipeline_dp.LocalBackend()

LocalBackend इंस्टेंस का इस्तेमाल किया जा सकता है, क्योंकि आपने इस प्रोग्राम को बीम या स्पार्क जैसे अतिरिक्त फ़्रेमवर्क के बिना स्थानीय तौर पर चलाया है.

5. DPEngine इंस्टेंस शुरू करें:

dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

PipelineDP आपको pipeline_dp.AggregateParams क्लास के ज़रिए आगे के पैरामीटर तय करने देता है, जिससे आपके निजी आंकड़ों के जनरेशन पर असर पड़ता है.

params = pipeline_dp.AggregateParams(
     noise_kind=pipeline_dp.NoiseKind.LAPLACE,
     metrics=[pipeline_dp.Metrics.COUNT],
     max_partitions_contributed=1,
     max_contributions_per_partition=1)

6. बताएं कि आपको count मेट्रिक को कैलकुलेट करना है और LAPLACE के नॉइज़ डिस्ट्रिब्यूशन का इस्तेमाल करना है.
7. max_partitions_contributed आर्ग्युमेंट को 1 वैल्यू पर सेट करें.

यह तर्क यह सीमित करता है कि कोई उपयोगकर्ता कितनी अलग-अलग विज़िट का योगदान कर सकता है. आपसे उम्मीद है कि उपयोगकर्ता दिन में एक बार वेबसाइट पर आएंगे और आपको इस बात की परवाह नहीं है कि वे दिन में एक से ज़्यादा बार वेबसाइट पर आते हैं या नहीं.

8. max_contributions_per_partitions आर्ग्युमेंट को 1 वैल्यू पर सेट करें.

यह तर्क बताता है कि इस मामले में कोई एक विज़िटर किसी खास विभाजन या प्रॉडक्ट श्रेणी में कितने योगदान दे सकता है.

9. ऐसा data_extractor इंस्टेंस बनाएं जिससे पता चलता हो कि privacy_id, partition, और value फ़ील्ड कहां मिलेंगे.

आपका कोड इस कोड स्निपेट की तरह दिखना चाहिए:

def run_pipeline(data, ops):
 budget_accountant = pipeline_dp.NaiveBudgetAccountant(
     total_epsilon=1, total_delta=1e-5)

 dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

 params = pipeline_dp.AggregateParams(
     noise_kind=pipeline_dp.NoiseKind.LAPLACE,
     metrics=[pipeline_dp.Metrics.COUNT],
     max_partitions_contributed=1, # A single user can only contribute to one partition.
     max_contributions_per_partition=1, # For a single partition, only one contribution per user is used.
     )

 data_extractors = pipeline_dp.DataExtractors(
     privacy_id_extractor=lambda row: row.user_id,
     partition_extractor=lambda row: row.product_view_0
     value_extractor=lambda row: row.has_conversion)

 dp_result = dp_engine.aggregate(data, params, data_extractors)

 budget_accountant.compute_budgets()

 return dp_result

10. इस कोड को अपने Pandas DataFrame को उन पंक्तियों की सूची में बदलने के लिए जोड़ें जिनसे अलग-अलग निजी आंकड़ों का सीधे हिसाब लगाया जा सकता है:

rows = [index_row[1] for index_row in df.iterrows()]
dp_result_local = run_pipeline(rows, ops) # Returns generator
list(dp_result_local)

बधाई हो! आपने अपना पहला डिफ़रेंशियल प्राइवेट स्टैटिस्टिक्स कैलकुलेट किया है!

यह चार्ट, पहले कैलकुलेट की गई गैर-निजी संख्या के बगल में मौजूद डिफ़रेंशियल प्राइवेट काउंट का नतीजा दिखाता है:

कोड चलाने पर मिलने वाला बार चार्ट, इस चार्ट से अलग हो सकता है. डिफ़रेंशियल प्राइवसी की वजह से, कोड चलाने पर आपको हर बार एक अलग बार चार्ट मिलता है. हालांकि, यह देखा जा सकता है कि वे ओरिजनल बार चार्ट की तरह ही हैं.

कृपया ध्यान दें कि निजता की गारंटी के लिए, निजता से जुड़ी गारंटी के लिए यह बहुत ज़रूरी है कि वह सिस्टम को कई बार न चलाए जाए. ज़्यादा जानकारी के लिए, एक से ज़्यादा आंकड़ों की गिनती करें देखें.

5. सार्वजनिक विभाजनों का उपयोग करें

पिछले सेक्शन में, आपने देखा होगा कि आपने किसी बंटवारे के लिए वेबसाइट पर आने वाले लोगों का सारा डेटा हटा दिया है. सेगमेंट का मतलब वेबसाइट पर आने वाले उन लोगों को है जिन्होंने पहली बार आपकी वेबसाइट पर मोज़े देखे थे.

ऐसा, सेगमेंट को चुनने या थ्रेशोल्ड की वजह से होता है. यह डिफ़रेंशियल-प्राइवसी गारंटी देने का एक अहम चरण है. इससे यह पक्का किया जाता है कि आउटपुट वाले सेगमेंट की मौजूदगी, उपयोगकर्ता के डेटा पर निर्भर करती है. ऐसा होने पर, आउटपुट में सिर्फ़ किसी उपयोगकर्ता के डेटा के मौजूद होने से, डेटा में मौजूद किसी उपयोगकर्ता की मौजूदगी का पता लग सकता है. इससे निजता का उल्लंघन क्यों होता है, इस बारे में ज़्यादा जानने के लिए यह ब्लॉग पोस्ट देखें. निजता के इस उल्लंघन को रोकने के लिए, PipelineDP ऐसे सेगमेंट को ही सेव करता है जिनमें ज़रूरत के मुताबिक उपयोगकर्ता हों.

जब आउटपुट विभाजनों की सूची निजी उपयोगकर्ता डेटा पर निर्भर नहीं होती, तो आपको विभाजन-चुनने के इस चरण की आवश्यकता नहीं होती. आपके उदाहरण पर यही बात लागू होगी, क्योंकि आपको उन सभी संभावित प्रॉडक्ट कैटगरी के बारे में पता है जिन्हें ग्राहक पहले देख सकता है.

सेगमेंट का इस्तेमाल करने के लिए:

1. अपने संभावित विभाजनों की सूची बनाएं:

public_partitions_products = ['jeans', 'jumper', 'socks', 't-shirt']

2. सूची को run_pipeline() फ़ंक्शन में पास करें, जिससे इसे pipeline_dp.AggregateParams क्लास के लिए अतिरिक्त इनपुट के तौर पर सेट किया जा सकता है:

run_pipeline(
    rows, ops, total_delta=0, public_partitions=public_partitions_products)
  # Returns generator

params = pipeline_dp.AggregateParams(
     noise_kind=pipeline_dp.NoiseKind.LAPLACE,
     metrics=[pipeline_dp.Metrics.COUNT],
     max_partitions_contributed=1,
     max_contributions_per_partition=1,
     public_partitions=public_partitions_products)

अगर सार्वजनिक पार्टिशन और LAPLACE नॉइज़ का इस्तेमाल किया जाता है, तो total_delta आर्ग्युमेंट को 0 वैल्यू पर सेट किया जा सकता है.

अब आपको नतीजे में यह दिखता है कि सभी सेगमेंट या प्रॉडक्ट का डेटा रिपोर्ट किया गया है.

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

जब आप सार्वजनिक विभाजनों का उपयोग करते हैं तो दो महत्वपूर्ण बातें ध्यान में रखनी चाहिए:

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

बेहतर सुविधा: डेटा से सेगमेंट बनाएं

अगर एक ही पाइपलाइन में गैर-सार्वजनिक आउटपुट विभाजनों की एक ही सूची के साथ कई एग्रीगेशन चलाए जाते हैं, तो आप dp_engine.select_private_partitions() तरीके से एक बार विभाजन की सूची पा सकते हैं और public_partitions इनपुट के रूप में हर एग्रीगेशन के लिए पार्टिशन दें. यह न सिर्फ़ निजता के लिहाज़ से सुरक्षित है, बल्कि यह आपको कम नॉइज़ जोड़ने का विकल्प भी देता है, क्योंकि सेगमेंट चुनने के लिए निजता बजट का इस्तेमाल सिर्फ़ एक बार किया जाता है.

def get_private_product_views(data, ops):
 """Obtains the list of product_views in a private manner.

   This does not calculate any private metrics; it merely obtains the list of
   product_views but does so while making sure the result is differentially private.
   """

 # Set the total privacy budget.
 budget_accountant = pipeline_dp.NaiveBudgetAccountant(
     total_epsilon=1, total_delta=1e-5)

 # Create a DPEngine instance.
 dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

 # Specify how to extract privacy_id, partition_key, and value from a   
 # single element.
 data_extractors = pipeline_dp.DataExtractors(
     partition_extractor=lambda row: row.product_view_0,
     privacy_id_extractor=lambda row: row.user_id)

 # Run aggregation.
 dp_result = dp_engine.select_partitions(
     data, pipeline_dp.SelectPrivatePartitionsParams(
       max_partitions_contributed=1),
     data_extractors=data_extractors)

 budget_accountant.compute_budgets()
 return dp_result

6. एक से ज़्यादा आंकड़ों की गणना करें

अब आपको PipelineDP के काम करने का तरीका पता है, तो जानें कि इसे बेहतर तरीके से इस्तेमाल करने के लिए इसका इस्तेमाल कैसे किया जा सकता है. जैसा कि हमने शुरू में बताया है, आपकी दिलचस्पी तीन आंकड़ों में है. PipelineDP आपको एक ही समय पर कई आंकड़ों को कंप्यूट करने की सुविधा देता है, बशर्ते वे AggregateParams इंस्टेंस में एक जैसे पैरामीटर शेयर करते हों, जिसे आप बाद में देख सकते हैं. इससे एक बार में कई मेट्रिक को कैलकुलेट करना आसान और साफ़ होता है. साथ ही, निजता के मामले में भी बेहतर है.

अगर आपको याद हो कि आपने NaiveBudgetAccountant क्लास के लिए epsilon और delta पैरामीटर दिए हैं, तो वे निजता बजट कहते हैं. यह उपयोगकर्ता की निजता की सुरक्षा का वह पैमाना है जिसे आपने डेटा की मदद से लीक किया है.

निजता बजट के बारे में याद रखने वाली बात यह है कि यह अलग से जोड़ा जाता है. अगर किसी खास इपसिलॉन पेमेंट्स का हिस्सा ( अगर इसे दूसरी बार चलाया जाता है, तो इसका मतलब है कि आपका कुल बजट (2 बाकी, 2$) खर्च होगा. इसी तरह, अगर NaiveBudgetAccountant तरीके का इस्तेमाल करके कई आंकड़ों का हिसाब लगाया जाता है और निजता के लिए लगातार पेमेंट्स का बजट $,मु. का है, तो इसका मतलब है कि आपका कुल बजट (2 पेमेंट्स, 2D) खर्च हो जाएगा. इसका मतलब है कि निजता की सुरक्षा से जुड़ी गारंटी को कम किया जा रहा है.

इससे बचने के लिए, आपको कुल बजट के साथ एक ही NaiveBudgetAccountant इंस्टेंस का इस्तेमाल करना होगा, जिसे आपको तब इस्तेमाल करना है, जब आपको एक ही डेटा पर कई आंकड़े कंप्यूट करने हों. इसके बाद, आपको epsilon और delta की वे वैल्यू तय करनी होंगी जिनका इस्तेमाल आपको हर एग्रीगेशन के लिए करना है. आखिर में, आपको भी निजता की उसी गारंटी से फ़ायदा मिलेगा. हालांकि, किसी एग्रीगेशन में epsilon और delta की जितनी ज़्यादा वैल्यू होगी, उतना ही सटीक होगा.

इसे काम करते हुए देखने के लिए, count, mean, और sum आंकड़ों की गिनती की जा सकती है.

आप दो अलग-अलग मेट्रिक के आधार पर आंकड़ों की गणना करते हैं: conversion_value मेट्रिक, जिसका इस्तेमाल करके जनरेट होने वाले रेवेन्यू का अनुमान लगाया जाता है. यह अनुमान इस आधार पर लगाया जाता है कि किस प्रॉडक्ट को पहले देखा गया है. वहीं, has_conversion मेट्रिक का इस्तेमाल करके, वेबसाइट पर आने वाले लोगों की संख्या और औसत कन्वर्ज़न रेट का हिसाब लगाया जाता है.

हर मेट्रिक के लिए, आपको अलग से पैरामीटर तय करने होंगे. ये पैरामीटर निजी आंकड़ों को कैलकुलेट करने में मदद करेंगे. निजता से जुड़े बजट को दो मेट्रिक में बांटा जाता है. आप has_conversion मेट्रिक से दो आंकड़ों की गणना करते हैं, इसलिए आप उसे अपने शुरुआती बजट का दो-तिहाई हिस्सा और बाकी के एक-तिहाई हिस्से को conversion_value मेट्रिक को असाइन करना चाहते हैं.

अनेक आंकड़ों की गणना करने के लिए:

1. epsilon और delta की कुल वैल्यू का इस्तेमाल करके, प्राइवसी बजट अकाउंटेंट सेट अप करें. इन वैल्यू का इस्तेमाल, आपको इन तीनों आंकड़ों में करना है:

budget_accountant = pipeline_dp.NaiveBudgetAccountant(
     total_epsilon=1, total_delta=0)

2. अपनी मेट्रिक कैलकुलेट करने के लिए, DPEngine को शुरू करें:

 dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

3. इस मेट्रिक के लिए पैरामीटर तय करें.

params_conversion_value_metrics = pipeline_dp.AggregateParams(
     noise_kind=pipeline_dp.NoiseKind.LAPLACE,
     metrics=[pipeline_dp.Metrics.SUM],
     max_partitions_contributed=1,
     max_contributions_per_partition=1,
     min_value=0,
     max_value=100,
     public_partitions=public_partitions,
     budget_weight=1/3)

आखिरी आर्ग्युमेंट, विकल्प के तौर पर आपके निजता बजट का वज़न बताता है. आप सभी को एक जैसा महत्व दे सकते हैं, लेकिन आपको इस तर्क को एक-तिहाई पर सेट करना है, जैसा कि पहले बताया गया है.

किसी विभाजन में निजता की इकाई के दिए गए मान पर लागू निचली और ऊपरी सीमा तय करने के लिए min_value और max_value आर्ग्युमेंट भी सेट किया जा सकता है. ये पैरामीटर तब ज़रूरी होते हैं, जब आपको किसी निजी योग या माध्य की गणना करनी हो. आपको नेगेटिव वैल्यू की उम्मीद नहीं है, इसलिए 0 और 100 को सही वैल्यू माना जा सकता है.

4. काम का डेटा एक्सट्रैक्ट करें और उसे एग्रीगेशन फ़ंक्शन में पास करें:

data_extractors_conversion_value_metrics = pipeline_dp.DataExtractors(
     privacy_id_extractor=lambda row: row.user_id,
     partition_extractor=lambda row: row.product_view_0,
     value_extractor=lambda row: row.conversion_value)

 dp_result_conversion_value_metrics = (
     dp_engine.aggregate(data, params_conversion_value_metrics,
         data_extractors_conversion_value_metrics))

5. अपने has_conversion वैरिएबल के आधार पर दो मेट्रिक की गिनती करने के लिए, यही तरीका अपनाएं:

params_conversion_rate_metrics = pipeline_dp.AggregateParams(
     noise_kind=pipeline_dp.NoiseKind.LAPLACE,
     metrics=[pipeline_dp.Metrics.COUNT, pipeline_dp.Metrics.MEAN],
     max_partitions_contributed=1,
     max_contributions_per_partition=1,
     min_value=0,
     max_value=1,
     public_partitions=public_partitions,
     budget_weight=2/3)

 data_extractors_conversion_rate_metrics = pipeline_dp.DataExtractors(
     privacy_id_extractor=lambda row: row.user_id,
     partition_extractor=lambda row: row.product_view_0,
     value_extractor=lambda row: row.has_conversion)

 dp_result_conversion_rate_metrics = (
     dp_engine.aggregate(data, params_conversion_rate_metrics,
         data_extractors_conversion_rate_metrics))

सिर्फ़ pipeline_dp.AggregateParams इंस्टेंस में बदलाव हुआ है. अब आपने mean और count को एग्रीगेशन के तौर पर शामिल किया है. साथ ही, इस हिसाब के लिए अपने निजता बजट का दो-तिहाई हिस्सा असाइन किया है. आपको दोनों आंकड़ों के लिए योगदान की एक जैसी सीमाएं सेट करनी हैं और एक ही has_conversion वैरिएबल के आधार पर उनका हिसाब लगाना है. इसलिए, उन्हें एक ही pipeline_dp.AggregateParams इंस्टेंस में मिलाया जा सकता है और एक ही समय पर कैलकुलेट किया जा सकता है.

6. budget_accountant.compute_budgets() तरीके को कॉल करें:

budget_accountant.compute_budgets()

आप तीनों निजी आंकड़ों को उनके मूल आंकड़ों से तुलना कर सकते हैं. जोड़े गए शोर के आधार पर, आपको दिखता है कि नतीजे सही स्केल से बाहर हो सकते हैं. इस मामले में, आपको जंपर के लिए नेगेटिव कन्वर्ज़न रेट और कुल कन्वर्ज़न वैल्यू दिखती है, क्योंकि जोड़ा गया नॉइज़ शून्य के आस-पास सिमेट्रिक होती है. ज़्यादा विश्लेषण और प्रोसेसिंग के लिए, बेहतर होगा कि निजी आंकड़ों को मैन्युअल तौर पर पोस्ट-प्रोसेस न करें. हालांकि, अगर आपको उन प्लॉट को किसी रिपोर्ट में जोड़ना है, तो निजता गारंटी का उल्लंघन किए बिना, सबसे कम से कम वैल्यू को शून्य पर सेट करें.

7. बीम की मदद से पाइपलाइन चलाएं

आज-कल डेटा प्रोसेसिंग के लिए आपको बहुत ज़्यादा डेटा का इस्तेमाल करना पड़ता है, ताकि आप उसे स्थानीय तौर पर प्रोसेस न कर सकें. इसके बजाय, कई लोग बीम या स्पार्क जैसे बड़े पैमाने पर डेटा प्रोसेसिंग के लिए फ़्रेमवर्क का इस्तेमाल करते हैं और अपनी पाइपलाइन को क्लाउड में चलाते हैं.

पाइपलाइनडीपी आपके कोड में सिर्फ़ छोटे-मोटे बदलाव करके, बीम और स्पार्क के साथ काम करता है.

private_beam एपीआई की मदद से, बीम करने की सुविधा के साथ पाइपलाइन चलाने के लिए:

1. runner वैरिएबल को शुरू करें. इसके बाद, ऐसी पाइपलाइन बनाएं जिसमें आप अपनी निजता से जुड़ी कार्रवाइयों को अपने rows के बीम रिप्रज़ेंटेशन पर लागू करें:

runner = fn_api_runner.FnApiRunner()  # local runner

with beam.Pipeline(runner=runner) as pipeline:
   beam_data = pipeline | beam.Create(rows)

2. अपने ज़रूरी निजता पैरामीटर के साथ budget_accountant वैरिएबल बनाएं:

budget_accountant = pipeline_dp.NaiveBudgetAccountant(
               total_epsilon=1, total_delta=0)

3. pcol या निजी कलेक्शन, वैरिएबल बनाएं. इससे यह गारंटी मिलती है कि कोई एग्रीगेशन आपकी निजता से जुड़ी ज़रूरी शर्तों के मुताबिक है:

pcol = beam_data | pbeam.MakePrivate(
                                 budget_accountant=budget_accountant,
                                 privacy_id_extractor=lambda 
                                                    row: row.user_id)

4. सही क्लास में अपने निजी एग्रीगेशन के पैरामीटर तय करें.

यहां pipeline_dp.aggregate_params.SumParams() क्लास का इस्तेमाल किया जाता है, क्योंकि प्रॉडक्ट पर मिले कुल व्यू का हिसाब लगाया जाता है.

5. अपने आंकड़े की गणना करने के लिए अपने एग्रीगेशन पैरामीटर को pbeam.Sum विधि पर पास करें:

dp_result = pcol | pbeam.Sum(params)

6. आखिर में, आपका कोड इस कोड स्निपेट की तरह दिखना चाहिए:

import pipeline_dp.private_beam as pbeam
runner = fn_api_runner.FnApiRunner()  # local runner

with beam.Pipeline(runner=runner) as pipeline:
   beam_data = pipeline | beam.Create(rows)
   budget_accountant = pipeline_dp.NaiveBudgetAccountant(
               total_epsilon=1, total_delta=0)

   # Create private collection.
   pcol = beam_data | pbeam.MakePrivate(
                              budget_accountant=budget_accountant,
                              privacy_id_extractor=lambda row:  
                                                         row.user_id)
   # Specify parameters.
   params = pipeline_dp.aggregate_params.SumParams(
     noise_kind=pipeline_dp.NoiseKind.LAPLACE,
     max_partitions_contributed=1,
     max_contributions_per_partition=1,
     min_value=0,
     max_value=100,
     public_partitions=public_partitions_product_views,
     partition_extractor=lambda row: row.product_view_0,
     value_extractor=lambda row:row.conversion_value)
   dp_result = pcol | pbeam.Sum(params)

   budget_accountant.compute_budgets()
   dp_result | beam.Map(print)

8. ज़रूरी नहीं: निजता और उपयोगिता पैरामीटर में बदलाव करना

आपने इस कोडलैब में, epsilon, delta, और max_partitions_contributed पैरामीटर जैसे कुछ पैरामीटर देखे हैं. उन्हें दो कैटगरी में बांटा जा सकता है: निजता पैरामीटर और उपयोगिता पैरामीटर.

निजता के पैरामीटर

epsilon और delta पैरामीटर, डिफ़रेंशियल प्राइवसी के साथ दी जाने वाली निजता का आकलन करते हैं. ज़्यादा सटीक तरीके से, इन रणनीतियों से यह जानकारी मिलती है कि कोई संभावित हमलावर, पहचान छिपाकर दिए गए आउटपुट से डेटा के बारे में कितनी जानकारी हासिल कर सकता है. पैरामीटर की वैल्यू जितनी ज़्यादा होगी, हमलावर को डेटा के बारे में उतनी ही ज़्यादा जानकारी मिलेगी. इससे निजता को खतरा है. वहीं दूसरी ओर, epsilon और delta पैरामीटर की वैल्यू जितनी कम होगी, आउटपुट में पहचान छिपाने के लिए उतनी ही ज़्यादा ग़ैर-ज़रूरी चीज़ें जोड़नी होंगी. साथ ही, हर पार्टीशन में यूनीक उपयोगकर्ताओं की संख्या उतनी ही ज़्यादा होगी, ताकि उन्हें पहचान छिपाने वाले आउटपुट में रखा जा सके. इस मामले में, उपयोगिता और निजता के बीच एक संतुलन है.

PipelineDP में NaiveBudgetAccountant इंस्टेंस में कुल निजता बजट सेट करने पर, आपको पहचान छिपाने वाले आउटपुट के लिए निजता की गारंटी देनी होगी. ध्यान रखें कि अगर आपको निजता से जुड़ी गारंटी का इस्तेमाल करना है, तो हर एग्रीगेशन के लिए ध्यान से एक अलग NaiveBudgetAccountant इंस्टेंस का इस्तेमाल करें या कई बार पाइपलाइन चलाएं, ताकि आपके बजट का ज़्यादा इस्तेमाल न हो.

डिफ़रेंशियल प्राइवसी और प्राइवसी पैरामीटर के बारे में ज़्यादा जानने के लिए, डिफ़रेंशियल प्राइवसी के बारे में जानकारी वाली रीडिंग लिस्ट देखें.

यूटिलिटी पैरामीटर

बिजली, पानी जैसी सुविधाओं के पैरामीटर, निजता से जुड़ी गारंटी पर कोई असर नहीं डालते. हालांकि, इनसे आउटपुट के सटीक होने और उसकी उपयोगिता पर असर पड़ता है. ये डाइमेंशन, AggregateParams इंस्टेंस में दिए जाते हैं. साथ ही, इनका इस्तेमाल जोड़े गए नॉइज़ को बढ़ाने के लिए किया जाता है.

max_partitions_contributed पैरामीटर, AggregateParams इंस्टेंस में दिया जाता है और सभी एग्रीगेशन पर लागू होता है. सेगमेंट, डेटा की उस कुंजी से मेल खाता है जो PipelineDP एग्रीगेशन ऑपरेशन से मिलती है. इसलिए, max_partitions_contributed पैरामीटर उन अलग-अलग मुख्य वैल्यू की संख्या को सीमित करता है जिन्हें कोई उपयोगकर्ता, आउटपुट में योगदान दे सकता है. अगर कोई उपयोगकर्ता max_partitions_contributed पैरामीटर की वैल्यू से ज़्यादा कुंजियों के लिए योगदान देता है, तो कुछ योगदान हटा दिए जाते हैं, ताकि वे max_partitions_contributed पैरामीटर की वैल्यू के बराबर योगदान दे सकें.

इसी तरह, ज़्यादातर एग्रीगेशन में max_contributions_per_partition पैरामीटर होता है. इन्हें AggregateParams इंस्टेंस में भी दिया जाता है और हर एग्रीगेशन के लिए अलग-अलग वैल्यू हो सकती हैं. वे हर कुंजी के लिए, उपयोगकर्ता के योगदान को सीमित करते हैं.

आउटपुट में जोड़ी गई नॉइज़ को max_partitions_contributed और max_contributions_per_partition पैरामीटर के हिसाब से स्केल किया जाता है. इसलिए, इसमें एक समस्या है: हर पैरामीटर को बड़ी वैल्यू असाइन करने का मतलब है कि आपके पास ज़्यादा डेटा है, लेकिन आपको नॉइज़र नतीजा मिलता है.

कुछ एग्रीगेशन के लिए min_value और max_value पैरामीटर की ज़रूरत होती है. इन पैरामीटर से हर उपयोगकर्ता के योगदान की सीमाएं तय होती हैं. अगर कोई उपयोगकर्ता, min_value पैरामीटर को असाइन की गई वैल्यू से कम वैल्यू देता है, तो वैल्यू बढ़ाकर पैरामीटर की वैल्यू कर दी जाती है. इसी तरह, अगर कोई उपयोगकर्ता, max_value पैरामीटर की वैल्यू से ज़्यादा वैल्यू देता है, तो वह वैल्यू पैरामीटर की वैल्यू में घट जाती है. मूल वैल्यू की संख्या ज़्यादा रखने के लिए, आपको बड़ी सीमाएं तय करनी होंगी. शोर को, बाउंड के साइज़ के हिसाब से स्केल किया जाता है, इसलिए बड़ी बाउंड से आपको ज़्यादा डेटा रखने की सुविधा मिलती है, लेकिन आपको ज़्यादा डेटा मिलता है.

आखिर में, noise_kind पैरामीटर, PipelineDP में शोर की दो अलग-अलग प्रक्रियाओं के साथ काम करता है: GAUSSIAN और LAPLACE नॉइज़. LAPLACE डिस्ट्रिब्यूशन, योगदान की कम सीमा के साथ बेहतर सुविधाएं देता है. इसलिए, PipelineDP डिफ़ॉल्ट रूप से इसका इस्तेमाल करता है. हालांकि, अगर आपको GAUSSIAN डिस्ट्रिब्यूशन नॉइज़ का इस्तेमाल करना है, तो AggregateParams इंस्टेंस में इसकी जानकारी दें.

9. बधाई हो

बहुत बढ़िया! आपने PipelineDP कोडलैब (कोड बनाना सीखना) पूरा कर लिया है और डिफ़रेंशियल प्राइवसी और PipelineDP के बारे में बहुत कुछ सीखा है.

ज़्यादा जानें

• GitHub का डेटा स्टोर करने की जगह
• PipelineDP
• बीम कोडलैब की निजता