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

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

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

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

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

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

Python की जानकारी
डेटा एग्रीगेशन की बुनियादी जानकारी होना
pandas, Spark, और Beam का अनुभव

आपको क्या सीखने को मिलेगा

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

आपको किन चीज़ों की ज़रूरत होगी

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pip install pipeline-dp

अगर आपको Apache Beam का इस्तेमाल करके उदाहरण चलाना है, तो:

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

pip install apache_beam

इस कोडलैब का कोड और डेटासेट, PipelineDP/examples/codelab/ डायरेक्ट्री में मौजूद है.

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

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

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

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: इससे वेबसाइट पर आने वाले लोगों के ग्राहक में बदलने की दर का पता चलता है.

मेट्रिक को बिना किसी निजी तरीके से जनरेट करें:

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 है. अब आपको हर बार चार्ट को निजी चार्ट में बदलना होगा.

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

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

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

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

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

ops = pipeline_dp.LocalBackend()

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

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)

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

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

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

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

एक 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

अपने 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 सिर्फ़ उन पार्टीशन को सेव करता है जिनमें उपयोगकर्ताओं की संख्या काफ़ी होती है.

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

पार्टिशन का इस्तेमाल करने के लिए:

अपने संभावित पार्टीशन की सूची बनाएं:

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

सूची को 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ε, 2δ) होगा. इसका मतलब है कि आपने निजता से जुड़े भरोसे को कम कर दिया है.

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

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

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

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

एक से ज़्यादा आंकड़ों का हिसाब लगाने के लिए:

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

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

अपनी मेट्रिक का हिसाब लगाने के लिए, DPEngine को शुरू करें:

 dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

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

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 को सही सीमाएं माना जा सकता है.

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

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))

अपने 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 इंस्टेंस में जोड़ा जा सकता है और एक ही समय में कैलकुलेट किया जा सकता है.

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

budget_accountant.compute_budgets()

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

7. Beam की मदद से पाइपलाइन चलाना

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

PipelineDP, Beam और Spark के साथ काम करता है. इसके लिए, आपको अपने कोड में सिर्फ़ मामूली बदलाव करने होंगे.

private_beam API के साथ Beam का इस्तेमाल करके पाइपलाइन चलाने के लिए:

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

runner = fn_api_runner.FnApiRunner()  # local runner

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

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

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

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

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

सही क्लास में, निजता बनाए रखते हुए एग्रीगेशन के पैरामीटर तय करें.

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

अपनी स्टैटिस्टिक का हिसाब लगाने के लिए, एग्रीगेशन पैरामीटर को pbeam.Sum तरीके से पास करें:

dp_result = pcol | pbeam.Sum(params)

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

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 इंस्टेंस में दिया जाता है. इनका इस्तेमाल, जोड़े गए नॉइज़ को स्केल करने के लिए किया जाता है.

AggregateParams इंस्टेंस में दिया गया एक यूटिलिटी पैरामीटर, max_partitions_contributed पैरामीटर है. यह सभी एग्रीगेशन पर लागू होता है. पार्टिशन, 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 डिस्ट्रिब्यूशन नॉइज़ का इस्तेमाल करना है, तो इसे GAUSSIAN इंस्टेंस में तय किया जा सकता है.AggregateParams

9. बधाई हो

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