पाठ्यक्रम 156 में से पाठ 54 · निजता मापें, ईमानदारी से
निजता मापें, ईमानदारी से

k-anonymity

यह क्यों मायने रखता है संगठन अक्सर "नाम हटाकर" डेटा साझा करते हैं, और उसे गुमनाम कहते हैं। आप synthetic डेटा पर देखेंगे कि तीन साधारण तथ्य कितनी जल्दी नाम वापस ले आते हैं। असली पुनः-पहचान ऐसे ही हुई है, और इसीलिए पाठ 56 का बचाव मौजूद है।

गपशप वाली जाँच

कोई कहता है: "हमारी गली की एक महिला, जो 3 मार्च 1981 को पैदा हुई, को अभी एक बीमारी का पता चला।" कोई नाम नहीं दिया गया। पर एक गली पर कितनी महिलाएँ ठीक वही जन्मदिन साझा करती हैं? शायद एक। विवरण ही नाम थे।

Quasi-identifier: एक तथ्य जो नाम नहीं है पर कुछ और के साथ मिलकर एक व्यक्ति की ओर इशारा करता है। Postcode (zip code), पूरी जन्म तारीख़ और लिंग क्लासिक तीन हैं।

पुनः-पहचान (Re-identification): बिना नामों के जारी किए डेटा पर नाम वापस लगाना, आमतौर पर उसे नामों वाली एक दूसरी सूची से जोड़कर।

2000 में Latanya Sweeney के एक प्रसिद्ध अध्ययन ने अनुमान लगाया कि संयुक्त राज्य अमेरिका के लगभग 87% लोगों को सिर्फ़ zip code, जन्म तारीख़ और लिंग से अलग पहचाना जा सकता था। नए जनगणना डेटा के साथ एक बाद के अध्ययन (Golle, 2006) ने इसे 63% के क़रीब रखा: कम, पर फिर भी ज़्यादातर लोग, जो मुद्दा है। हम बनावटी डेटा पर वही असर देखेंगे।

अभ्यास डेटा

synthetic_people(2000) एक गढ़ी हुई स्वास्थ्य table बनाता है: id, name, zip, birth_date, gender, diagnosis। इसमें कोई भी असली नहीं है। हम इसे भोले तरीके से "गुमनाम" करते हैं, नाम हटाकर। synthetic_public_roll(people) एक गढ़ी हुई सार्वजनिक सूची बनाता है, एक club register की तरह, नाम, zip, जन्म तारीख़ और लिंग के साथ, पर बिना diagnosis के।

जोखिम मापना: k

k-anonymity: एक table k-anonymous है जब quasi-identifier मानों का हर मेल कम से कम k rows साझा करती हों। k = 1 का मतलब कम से कम एक व्यक्ति अकेला है, और ढूँढा जा सकता है।

k ढूँढने के लिए: rows को उनके quasi-identifier tuple से समूहित करें, हर समूह गिनें, और सबसे छोटी गिनती लें। अकेले ["gender"] के साथ k बड़ा है। zip, जन्म तारीख़ और लिंग साथ होने पर k 1 तक गिर जाता है।

जोड़

सार्वजनिक सूची के हर व्यक्ति के लिए उनकी key (zip, birth_date, gender) बनाएँ और उसे जारी table में खोजें। सख़्त रहें: मेल सिर्फ़ तब गिनें जब key जारी table में ठीक एक बार और सूची में ठीक एक बार आए। तब आप पक्के हैं। अगर दो records key साझा करें, तो आप नहीं बता सकते कि कौन-सा कौन-सा है; अगर सूची के दो लोग उसे साझा करें, तो आप नहीं बता सकते कि कौन कौन है।

reidentify(released, roll)
# {17: 'Mei Patel', 203: 'Omar Novak', ...}   record id -> name

एक बार record 17 का नाम हो जाए, उसके diagnosis का भी हो जाता है। यही पूरा हमला है: दो हानिरहित दिखती सूचियाँ, एक जोड़।

एक आम ग़लतफ़हमी

"नाम, emails और फ़ोन नंबर हटाना डेटा को गुमनाम बनाता है।" यह स्पष्ट पहचानकर्ता हटाता है, पर बाक़ी columns फिर भी लोगों को अलग पहचान सकते हैं। डेटा गुमनाम है या नहीं यह इस पर निर्भर है कि उससे जोड़ने के लिए बाहर और क्या है, इसीलिए पाठ 56 डेटा को ही बदलता है।

आज़माएँ पास होने पर, सूची का fraction 0.6 से 0.2 करें और फिर चलाएँ। मेलों की संख्या गिरती है, पर सूची के जिन लोगों को आप फिर से पहचानते हैं उनका हिस्सा मुश्किल से बदलता है। हर व्यक्ति अपने विवरणों से उजागर होता है, सूची कितनी बड़ी है इससे नहीं।

दूसरी भाषाओं में

JavaScript:

function reidentify(released, roll, cols) {
  const key = r => JSON.stringify(cols.map(c => r[c]));
  const count = list => list.reduce((m, r) => m.set(key(r), (m.get(key(r)) || 0) + 1), new Map());
  const a = count(released), b = count(roll);
  const byKey = new Map(released.map(r => [key(r), r]));
  const found = {};
  for (const p of roll) {
    if (a.get(key(p)) === 1 && b.get(key(p)) === 1) found[byKey.get(key(p)).id] = p.name;
  }
  return found;
}

C# (LINQ) में SQL-शैली की सोच:

var matches =
    from r in released
    join p in roll on new { r.Zip, r.BirthDate, r.Gender }
                   equals new { p.Zip, p.BirthDate, p.Gender }
    select new { r.Id, p.Name };
// then keep only keys that occur once on each side

सार

  • Quasi-identifiers (zip, जन्म तारीख़, लिंग) बिना नाम के लोगों को अलग पहचान सकते हैं।
  • k एक जैसे quasi-identifiers साझा करते सबसे छोटे समूह का आकार है; k = 1 का मतलब कोई उजागर है।
  • एक बिना नाम वाली table को नामों वाली सार्वजनिक सूची से जोड़ना लोगों को फिर से पहचानता है।
  • नाम हटाना गुमनामीकरण नहीं है। यहाँ सिर्फ़ synthetic डेटा; बचाव अगला है।
आपकी बारी

quasi_key(row, columns) (मानों का tuple), smallest_group(rows, columns) (एक key साझा करती rows के सबसे छोटे समूह का आकार: वही k है) और reidentify(released, roll, columns=QUASI) लिखें, जो सूची के हर उस व्यक्ति के लिए जारी record id से सूची के name तक एक dict लौटाए जिसकी key released में ठीक एक बार और roll में ठीक एक बार आती है।

इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें

यह अभ्यास जल्द खुलेगा

इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।