แรงจูงใจ

ฉันทำงานกับชุดข้อมูลที่มีข้อมูลส่วนบุคคล (PII) และบางครั้งจำเป็นต้องแบ่งปันส่วนหนึ่งของชุดข้อมูลกับบุคคลที่สามในลักษณะที่ไม่เปิดเผยข้อมูล PII และบังคับให้นายจ้างรับผิดชอบ วิธีการตามปกติของเราที่นี่คือการระงับข้อมูลทั้งหมดหรือในบางกรณีเพื่อลดความละเอียด เช่นการแทนที่ที่อยู่ถนนที่แน่นอนด้วยเคาน์ตีหรือระบบการสำรวจสำมะโนประชากรที่เกี่ยวข้อง

ซึ่งหมายความว่าต้องทำการวิเคราะห์และประมวลผลบางประเภทภายใน บริษัท แม้ว่าบุคคลที่สามจะมีทรัพยากรและความเชี่ยวชาญที่เหมาะสมกับงานมากกว่า เนื่องจากไม่มีการเปิดเผยข้อมูลต้นฉบับวิธีที่เราดำเนินการเกี่ยวกับการวิเคราะห์และการประมวลผลนี้จึงไม่มีความโปร่งใส ดังนั้นความสามารถของบุคคลที่สามในการดำเนินการ QA / QC ปรับพารามิเตอร์หรือทำการปรับแต่งอาจมีข้อ จำกัด มาก

การเปิดเผยข้อมูลที่เป็นความลับ

งานหนึ่งเกี่ยวข้องกับการระบุบุคคลตามชื่อของพวกเขาในข้อมูลที่ผู้ใช้ส่งในขณะที่คำนึงถึงข้อผิดพลาดของบัญชีและความไม่สอดคล้องกัน บุคคลที่เป็นส่วนตัวอาจถูกบันทึกไว้ในที่เดียวว่า "เดฟ" และที่อื่น ๆ ในฐานะ "เดวิด" หน่วยงานการค้าสามารถมีตัวย่อต่าง ๆ ได้มากมาย ฉันได้พัฒนาสคริปต์ตามเกณฑ์จำนวนหนึ่งที่กำหนดว่าเมื่อใดที่ระเบียนสองรายการที่มีชื่อไม่เหมือนกันแสดงถึงบุคคลเดียวกันและกำหนดรหัสทั่วไปให้กับพวกเขา

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

อะไรไม่ทำงาน

ตัวอย่างเช่นมันจะดีมากที่จะสามารถเข้ารหัสสตริงในขณะที่รักษาระยะแก้ไข ด้วยวิธีนี้บุคคลที่สามสามารถทำ QA / QC ของตนเองหรือเลือกที่จะดำเนินการเพิ่มเติมด้วยตนเองโดยไม่ต้องเข้าถึง (หรือสามารถย้อนกลับวิศวกรที่มีความสามารถ PII) บางทีเราอาจจับคู่สตริงภายในกับระยะการแก้ไข <= 2 และผู้รับต้องการดูความหมายของการทำให้ความอดทนนั้นแน่นขึ้นเพื่อแก้ไขระยะทาง <= 1

แต่วิธีเดียวที่ฉันคุ้นเคยกับการทำเช่นนี้ก็คือROT13 (โดยทั่วไปแล้วรหัสการเปลี่ยนแปลงใด ๆ) ซึ่งแทบจะไม่นับเป็นการเข้ารหัส มันเหมือนกับการเขียนชื่อคว่ำและพูดว่า "สัญญาว่าคุณจะไม่พลิกกระดาษเหรอ?"

ทางออกที่ไม่ดีอีกอย่างก็คือการย่อทุกอย่าง "Ellen Roberts" กลายเป็น "ER" เป็นต้น นี่เป็นวิธีการแก้ปัญหาที่ไม่ดีเพราะในบางกรณีคำย่อที่เชื่อมโยงกับข้อมูลสาธารณะจะเปิดเผยตัวตนของบุคคลและในกรณีอื่น ๆ มันก็คลุมเครือเกินไป "Benjamin Othello Ames" และ "Bank of America" ​​จะมีชื่อย่อเหมือนกัน แต่ชื่อของพวกเขานั้นแตกต่างกัน ดังนั้นมันจะไม่ทำสิ่งใดสิ่งหนึ่งที่เราต้องการ

ทางเลือกที่ไม่เหมาะสมคือการแนะนำฟิลด์เพิ่มเติมเพื่อติดตามคุณสมบัติบางอย่างของชื่อเช่น:

+-----+----+-------------------+-----------+--------+
| Row | ID | Name              | WordChars | Origin |
+-----+----+-------------------+-----------+--------+
| 1   | 17 | "AMELIA BEDELIA"  | (6, 7)    | Eng    |
+-----+----+-------------------+-----------+--------+
| 2   | 18 | "CHRISTOPH BAUER" | (9, 5)    | Ger    |
+-----+----+-------------------+-----------+--------+
| 3   | 18 | "C J BAUER"       | (1, 1, 5) | Ger    |
+-----+----+-------------------+-----------+--------+
| 4   | 19 | "FRANZ HELLER"    | (5, 6)    | Ger    |
+-----+----+-------------------+-----------+--------+

ฉันเรียกสิ่งนี้ว่า "ไม่เหมาะสม" เพราะมันต้องมีการคาดการณ์ว่าคุณสมบัติใดบ้างที่น่าสนใจและค่อนข้างหยาบ หากมีการลบชื่อออกไปคุณจะไม่สามารถสรุปได้อย่างสมเหตุสมผลเกี่ยวกับความแข็งแกร่งของการจับคู่ระหว่างแถว 2 และ 3 หรือระยะห่างระหว่างแถว 2 และ 4 (เช่นระยะห่างระหว่างการจับคู่)

ข้อสรุป

เป้าหมายคือการแปลงสตริงในลักษณะที่คุณสมบัติที่มีประโยชน์มากมายของสตริงต้นฉบับจะถูกเก็บรักษาไว้ให้มากที่สุดเท่าที่จะเป็นไปได้ในขณะที่บดบังสตริงเดิม การถอดรหัสควรเป็นไปไม่ได้หรือทำไม่ได้ดังนั้นจะเป็นไปไม่ได้อย่างมีประสิทธิภาพไม่ว่าขนาดของชุดข้อมูลจะเป็นเท่าใดก็ตาม โดยเฉพาะอย่างยิ่งวิธีการที่รักษาระยะห่างการแก้ไขระหว่างสตริงโดยพลการจะมีประโยชน์มาก

ฉันพบเอกสารสองฉบับที่อาจมีความเกี่ยวข้อง แต่หัวของฉันก็เล็กน้อย:

• ความเป็นส่วนตัวที่เก็บรักษาการเปรียบเทียบสตริงขึ้นอยู่กับระยะทาง Levenshtein
• การเปรียบเทียบเชิงประจักษ์ของแนวทางการจับคู่สตริงโดยประมาณในการเชื่อมโยงเรคคอร์ดส่วนตัว

หนึ่งในข้อมูลอ้างอิงที่ฉันพูดถึงใน OP ทำให้ฉันมีวิธีแก้ปัญหาที่อาจมีประสิทธิภาพซึ่งอธิบายไว้ใน "การเชื่อมโยงบันทึกข้อมูลความเป็นส่วนตัวโดยใช้ตัวกรอง Bloom" ( ดอย: 10.1186 / 1472-6947-9-41 ):

โปรโตคอลใหม่สำหรับการเชื่อมโยงบันทึกข้อมูลส่วนบุคคลด้วยตัวระบุที่เข้ารหัสซึ่งช่วยให้เกิดข้อผิดพลาดในตัวระบุได้รับการพัฒนา โปรโตคอลนี้ใช้ตัวกรอง Bloom ตามตัวระบุ q-g

บทความนี้มีรายละเอียดเกี่ยวกับวิธีการซึ่งฉันจะสรุปที่นี่เพื่อความสามารถที่ดีที่สุดของฉัน

ตัวกรอง Bloom เป็นชุดความยาวคงที่ของบิตที่เก็บผลลัพธ์ของชุดฟังก์ชันแฮชอิสระที่คงที่แต่ละตัวคำนวณบนค่าอินพุตเดียวกัน เอาต์พุตของแต่ละฟังก์ชันแฮชควรเป็นค่าดัชนีจากดัชนีที่เป็นไปได้ในตัวกรอง กล่าวคือหากคุณมีชุดข้อมูล 0 ดัชนี 10 บิตฟังก์ชันแฮชควรส่งคืนค่า (หรือถูกแมปไป) จาก 0 ถึง 9

ตัวกรองเริ่มต้นด้วยแต่ละบิตที่ตั้งค่าเป็น 0 หลังจากการแฮชค่าอินพุตกับแต่ละฟังก์ชันจากชุดของฟังก์ชันแฮชแต่ละบิตที่สอดคล้องกับค่าดัชนีที่ส่งคืนโดยฟังก์ชันแฮชใด ๆ จะถูกตั้งค่าเป็น 1 หากดัชนีเดียวกันถูกส่งคืนมากกว่า มากกว่าหนึ่งฟังก์ชันแฮชบิตที่ดัชนีนั้นถูกตั้งค่าเพียงครั้งเดียว คุณสามารถพิจารณาตัวกรอง Bloom ให้เป็นชุดซ้อนของชุดแฮชไปยังช่วงบิตคงที่

โพรโทคอลที่อธิบายไว้ในบทความที่เชื่อมโยงข้างต้นแบ่งสตริงออกเป็น n-grams ซึ่งอยู่ในชุดตัวอักษรกรณีนี้ ตัวอย่างเช่น"hello"อาจให้ชุด 2 กรัมต่อไปนี้:

["_h", "he", "el", "ll", "lo", "o_"]

การหุ้มด้านหน้าและด้านหลังด้วยช่องว่างน่าจะเป็นทางเลือกโดยทั่วไปเมื่อสร้าง n-grams ตัวอย่างที่ให้ไว้ในบทความที่เสนอวิธีการนี้ใช้การเติมเต็ม

n-gram แต่ละตัวสามารถถูกแฮชเพื่อสร้างตัวกรอง Bloom และชุดตัวกรอง Bloom นี้สามารถซ้อนทับบนตัวเอง (การทำงานแบบบิตหรือการดำเนินการ) เพื่อสร้างตัวกรอง Bloom สำหรับสตริง

หากตัวกรองมีบิตมากกว่าจำนวนมากที่มีฟังก์ชั่นแฮชหรือ n- กรัมสตริงที่กำหนดเองนั้นไม่น่าจะสร้างตัวกรองเดียวกันได้ อย่างไรก็ตามยิ่งมีสองสตริง n-กรัมเหมือนกันยิ่งกรองบิตของพวกเขาจะร่วมกันในที่สุด จากนั้นคุณสามารถเปรียบเทียบตัวกรองสองตัวA, Bโดยใช้สัมประสิทธิ์ Dice:

D _{A, B} = 2h / (a ​​+ b)

ที่ไหนhเป็นจำนวนบิตที่มีการตั้งค่าเป็น 1 ในตัวกรองทั้งสองaเป็นจำนวนบิตตั้งค่าเป็น 1 ในเพียงตัวกรองและbเป็นจำนวนบิตตั้งค่าเป็น 1 ในเพียงตัวกรอง B. หากสตริงเป็นสิ่งเดียวกัน ค่าสัมประสิทธิ์ลูกเต๋าจะเป็น 1 ยิ่งพวกเขาต่างกันเท่าใดค่าสัมประสิทธิ์ก็จะ0ยิ่งมากขึ้น

เนื่องจากฟังก์ชันแฮชกำลังทำแผนที่จำนวนอินพุตที่ไม่ซ้ำกันของดัชนีบิตที่เป็นไปได้จำนวนเล็กน้อยอินพุตที่ต่างกันอาจสร้างตัวกรองเดียวกันดังนั้นค่าสัมประสิทธิ์บ่งชี้เฉพาะความน่าจะเป็นที่สตริงจะเหมือนหรือคล้ายกัน จำนวนฟังก์ชันแฮชที่แตกต่างกันและจำนวนบิตในตัวกรองเป็นพารามิเตอร์ที่สำคัญสำหรับการพิจารณาความเป็นไปได้ของผลบวกปลอม - คู่ของอินพุตที่คล้ายกันน้อยกว่าค่าสัมประสิทธิ์ลูกเต๋าที่ผลิตโดยวิธีนี้ทำนาย

ฉันพบว่าบทช่วยสอนนี้มีประโยชน์มากสำหรับการทำความเข้าใจตัวกรอง Bloom

มีความยืดหยุ่นในการใช้วิธีนี้; ดูบทความในปี 2010 ฉบับนี้ (เชื่อมโยงตอนท้ายของคำถามด้วย) เพื่อบ่งชี้ว่านักแสดงมีความสัมพันธ์กับวิธีการอื่น ๆ อย่างไรและมีพารามิเตอร์ต่าง ๆ

ครึ่งทางที่อ่านคำถามของคุณฉันรู้ว่า Levenshtein Distance อาจเป็นทางออกที่ดีสำหรับปัญหาของคุณ เป็นเรื่องดีที่คุณเห็นว่าคุณมีลิงค์ไปยังกระดาษในหัวข้อนั้นให้ฉันดูว่าฉันจะสามารถแยกแสงออกจากสิ่งที่โซลูชัน Levenshtein จะมีลักษณะอย่างไร

ระยะทางของ Levenshtein ถูกใช้ในหลายอุตสาหกรรมสำหรับการแก้ปัญหาเอนทิตีสิ่งที่ทำให้มีประโยชน์คือมันเป็นเครื่องวัดความแตกต่างระหว่างสองลำดับ ในกรณีของการเปรียบเทียบสตริงมันเป็นเพียงแค่ลำดับอักขระ

วิธีนี้จะช่วยแก้ปัญหาของคุณได้โดยอนุญาตให้คุณระบุหมายเลขหนึ่งที่วัดความคล้ายคลึงกันของข้อความในฟิลด์อื่น

นี่คือตัวอย่างของวิธีพื้นฐานในการใช้ Levenshtein กับข้อมูลที่คุณให้:

นี่เป็นวิธีแก้ปัญหาที่ตกลงได้ระยะทาง 8 แสดงถึงความสัมพันธ์และเป็นไปตามมาตรฐาน PII อย่างไรก็ตามมันยังไม่มีประโยชน์มากนักลองมาดูกันว่าเกิดอะไรขึ้นถ้าเราใช้เวทย์มนตร์ข้อความเพื่อใช้ชื่อตัวแรกของชื่อแรกและนามสกุลเต็มจะปล่อยอะไรไว้ตรงกลาง:

อย่างที่คุณเห็นระยะทางของ Levenshtein 0 นั้นค่อนข้างบ่งบอกถึงความสัมพันธ์ ผู้ให้บริการข้อมูลทั่วไปจะรวมการเรียงสับเปลี่ยนของ Levenshtein ในชื่อและนามสกุลด้วยอักขระ 1, 2 หรืออักขระทั้งหมดเพื่อให้มีมิติที่เกี่ยวข้องกับเอนทิตีที่เกี่ยวข้องในขณะที่ยังคงรักษาข้อมูลที่ไม่เปิดเผยตัวตนไว้ในข้อมูล

ถ้าเป็นไปได้ฉันจะเชื่อมโยงบันทึกที่เกี่ยวข้อง (เช่น Dave, David, ฯลฯ ) และแทนที่ด้วยหมายเลขลำดับ (1,2,3 ฯลฯ ) หรือแฮชเค็ม ของสตริงที่ใช้เพื่อแสดงระเบียนที่เกี่ยวข้องทั้งหมด ( เช่นดาวิดแทนที่จะเป็นเดฟ)

ฉันคิดว่าบุคคลที่สามไม่จำเป็นต้องมีความคิดใด ๆ ว่าชื่อจริงคืออะไรมิฉะนั้นคุณอาจมอบให้พวกเขาเช่นกัน

แก้ไข : คุณต้องกำหนดและแสดงให้เห็นถึงประเภทของการดำเนินงานที่บุคคลที่สามต้องสามารถทำได้ ตัวอย่างเช่นมีความผิดปกติอะไรกับการใช้ชื่อย่อตามด้วยตัวเลข (เช่น BOA-1, BOA-2, ฯลฯ ) เพื่อทำให้เข้าใจผิดธนาคารแห่งอเมริกาจาก Benjamin Othello Ames? หากเปิดเผยมากเกินไปคุณสามารถวางจดหมายหรือชื่อบางส่วนได้ เช่น [AE] -> 1, [FJ] -> 2 เป็นต้นดังนั้น BOA จะกลายเป็น 1OA หรือ ["Bank", "Barry", "Bruce" ฯลฯ ] -> 1 ดังนั้น Bank of America จึงเป็นอีกครั้ง 1OA

สำหรับข้อมูลเพิ่มเติมโปรดดูK-ตัวตน

ตัวเลือกหนึ่ง (ขึ้นอยู่กับขนาดชุดข้อมูลของคุณ) คือเพียงแค่ให้ระยะทางแก้ไข (หรือมาตรการอื่น ๆ ของความคล้ายคลึงกันที่คุณใช้) เป็นชุดข้อมูลเพิ่มเติม

เช่น:

1. สร้างชุดชื่อเฉพาะในชุดข้อมูล
2. สำหรับแต่ละชื่อให้คำนวณระยะทางแก้ไขสำหรับชื่ออื่น
3. สร้าง ID หรือแฮชที่ไม่สามารถย้อนกลับได้สำหรับแต่ละชื่อ
4. แทนที่ชื่อในชุดข้อมูลดั้งเดิมด้วย ID นี้
5. จัดเตรียมเมทริกซ์ของการแก้ไขระยะทางระหว่างหมายเลข ID เป็นชุดข้อมูลใหม่

แม้ว่าจะยังมีอีกมากที่สามารถทำได้เพื่อลบล้างข้อมูลจากสิ่งเหล่านี้แม้

เช่นถ้า "ทิม" เป็นที่รู้จักกันว่าเป็นชื่อที่ได้รับความนิยมสูงสุดสำหรับเด็กผู้ชายการนับความถี่ของรหัสที่ตรงกับเปอร์เซ็นต์ของ Tims ที่รู้จักกันทั่วทั้งประชากรนั้นอาจจะทำให้เสียไป จากนั้นคุณสามารถค้นหาชื่อที่มีระยะทางแก้ไขเป็น 1 และสรุปได้ว่า ID เหล่านั้นอาจอ้างถึง "Tom" หรือ "Jim" (เมื่อรวมกับข้อมูลอื่น ๆ )

ฉันไม่แน่ใจนัก แต่อาจจะมีการตอบสนองต่อการสัญจรไปมาในพื้นที่ได้เป็นทางออกที่ดี มันมีการบีบอัดข้อมูลอินพุต (ในกรณีของคุณ - ชื่อ) ดังนั้นสตริงดั้งเดิมจะถูกเก็บไว้ ในอีกด้านหนึ่งความคิดหลักของ LSH คือการเพิ่มโอกาสแฮชให้มากที่สุดสำหรับรายการที่คล้ายกัน มีการใช้งาน LSH ที่แตกต่างกันมากมาย ฉันลองNilsimsa-hashเพื่อเปรียบเทียบข้อความทวีตและมันใช้งานได้ดี แต่ฉันไม่แน่ใจว่ามันจะทำงานได้ดีแค่ไหนในกรณีที่มีสตริงสั้น (ชื่อ) - ปัญหานี้ต้องมีการทดสอบ ฉันลองตัวอย่างของคุณแล้วและนี่คือผลลัพธ์ (ชื่อ A, ชื่อ B, "ระยะทาง" - สูงสุดคือ 120):

1. AMELIA BEDELIA  - CHRISTOPH BAUER - 107
2. AMELIA BEDELIA  - C J BAUER       - 82
3. AMELIA BEDELIA  - FRANZ HELLER    - 91
4. CHRISTOPH BAUER - C J BAUER       - 81
5. CHRISTOPH BAUER - FRANZ HELLER    - 98
6. C J BAUER       - FRANZ HELLER    - 83

อย่างที่คุณเห็น CHRISTOPH BAUER และ CJ BAUER กลายเป็นคู่ที่ใกล้ที่สุด แต่ความแตกต่างนั้นไม่สำคัญ ตัวอย่างเช่น - การแทนค่าแฮชของชื่อเหล่านี้:

AMELIA BEDELIA  6b208299602b5000c3005a048122a43a828020889042240005011c1880864502
CHRISTOPH BAUER 22226448000ab10102e2860b52062487ff0000928e0822ee106028016cc01237
C J BAUER       2282204100961060048050004400240006032400148000802000a80130402002
FRANZ HELLER    58002002400880080b49172044020008030002442631e004009195020ad01158

ต่อไปนี้เป็นวิธีที่ฉันไม่ได้กล่าวถึง: แยกกระบวนการออกเป็นสองขั้นตอน: ขั้นตอนแรกมุ่งเน้นไปที่การเข้ารหัสเพื่อให้ชื่อทางเลือกของชื่อเดียวกันถูกเข้ารหัสเหมือนกัน (หรือเกือบจะเหมือนกัน) และขั้นตอนที่สอง พวกเขาไม่ระบุชื่อ

สำหรับขั้นตอนแรกคุณสามารถใช้หนึ่งในอัลกอริทึมการออกเสียง (Soundex และตัวแปร)นำไปใช้กับชื่อนามสกุลและชื่อย่อในคำสั่งซื้อต่างๆ (ดูบทความนี้ด้วย) มันอยู่ในขั้นตอนนี้ที่คุณแก้ไขความคล้ายคลึงกันและความแตกต่างของชื่อเพื่อสร้างสมดุลที่เป็นบวกจากการลบที่ผิด

สำหรับขั้นตอนที่สองคุณสามารถเลือกวิธีแฮชหรือการเข้ารหัสที่คุณต้องการโดยไม่ต้องกังวลว่าวิธีการดังกล่าวจะมีผลต่อการจับคู่ชื่ออย่างไร สิ่งนี้จะช่วยให้คุณมีอิสระในการใช้วิธีการที่มีคุณสมบัติที่ดีที่สุดสำหรับทั้งประสิทธิภาพความทนทานและการไม่เปิดเผยตัวตน