Privacy Parser

पाठ के ढेर में PII का हर अंश खोजें और उसे संरचित स्पैन के रूप में वापस पाएं।

OpenAI Privacy Filter पर आधारित: वही 1.5B मॉडल, वही लेबल, वही वेट्स।
Privacy Filter मास्क करता है। Privacy Parser निकालता है।

Hi Quindle Testwick ([email protected] / +1-415-555-0102),
account 40702810500001234567, 14 Beautiful Ct, Anytown USA,
password Priv4cy-Filt3r-2026.

private_person      Quindle Testwick
private_email       [email protected]
private_phone       +1-415-555-0102
account_number      40702810500001234567
private_address     14 Beautiful Ct, Anytown USA
secret              Priv4cy-Filt3r-2026

<REDACTED> के बजाय आपको क्या मिला, कहाँ है (start, end) और कौन सा प्रकार है, यह मिलता है।

क्यों

Privacy Filter का उत्तर है "इस टेक्स्ट को सुरक्षित बनाओ"। कभी-कभी आपको एक अलग उत्तर चाहिए: "इसमें वास्तव में क्या है?"

अपने परिधि से बाहर जाने से पहले लॉग, डंप और एक्सपोर्ट का ऑडिट करें
GDPR / CCPA अनुरोधों के लिए व्यक्तिगत डेटा की इन्वेंटरी बनाएं
लीक हुए रहस्यों और संपर्क डेटा के लिए प्री-कमिट और CI जांच
डेटासेट बनाएं: प्रशिक्षण या मूल्यांकन के लिए PII स्पैन लेबल करें

तीन बैकएंड

बैकएंड	वेट्स चाहिए	गति	F1 *	कब उपयोग करें
`PIIParser`	नहीं	µs	1.000	शून्य निर्भरता, संरचित पैटर्न
`ModelPIIParser`	1.5B	~500 ms CPU	0.733	कच्चा मॉडल आउटपुट
`HybridPIIParser`	1.5B	~600 ms CPU	0.929	डिफ़ॉल्ट विकल्प

* पाँच opf नमूना फ़िक्स्चर पर सटीक स्पैन मिलान। एक छोटा सेट: इसे स्मोक टेस्ट मानें, बेंचमार्क नहीं।

इंस्टॉल

git clone https://github.com/openai/privacy-filter
git clone https://github.com/chiefautism/privacy-parser

uv venv
uv pip install -e ./privacy-filter    # only for the model backends
uv pip install -e ./privacy-parser

पहला मॉडल रन opf चेकपॉइंट (~3 GB) को ~/.opf/privacy_filter/ में डाउनलोड करता है। किसी अन्य स्थान का उपयोग करने के लिए OPF_CHECKPOINT सेट करें या model= पास करें।

त्वरित शुरुआत

हाइब्रिड (अनुशंसित)

from pii_parser.hybrid import HybridPIIParser

parser = HybridPIIParser(device="cpu")   # or "cuda"
result = parser.parse("Hi Quindle Testwick, call me at +1-415-555-0102")

for s in result.spans:
    print(s.label, s.start, s.end, s.text)

print(result.to_json())

केवल Regex, कोई वेट नहीं

from pii_parser import parse

result = parse("mail [email protected], token ghp_abcdefghijklmnopqrstuvwxyz0123456789")

result.detected_spans   # (DetectedSpan(label='private_email', ...), ...)
result.redacted_text    # 'mail <REDACTED>, token <REDACTED>'
result.summary          # {'span_counts': {...}, 'total_spans': 2}

CLI

Regex बैकएंड, कोई मॉडल नहीं:

$ echo "Alice paid 40702810500001234567 on 2026-05-17." | pii-parser --mode spans
account_number  11  31  40702810500001234567
private_date    35  45  2026-05-17

$ pii-parser "mail [email protected]" --mode redacted
mail <REDACTED>

फ़्लैग	मान	डिफ़ॉल्ट
`TEXT`	टेक्स्ट, या `-f FILE`, या stdin
`--mode`	`json` · `spans` · `redacted`	`json`
`--placeholder`	कोई भी स्ट्रिंग	`<REDACTED>`
`--indent`	int, कॉम्पैक्ट JSON के लिए `0`	`2`

मॉडल बैकएंड:

python -m pii_parser.cli_model "Alice paid 40702810500001234567 on 2026-05-17."
python -m pii_parser.cli_model -f dump.txt --device cuda --mode spans

लेबल

opf v2 टैक्सोनॉमी, 8 श्रेणियाँ:

लेबल	उदाहरण
`private_person`	Quindle Testwick
`private_email`	[email protected]
`private_phone`	+1-415-555-0102
`private_address`	14 Beautiful Ct, Anytown USA
`private_url`	https://example.com/u/quindle
`private_date`	2026-05-17
`account_number`	40702810500001234567
`secret`	`sk-…`, `ghp_…`, `AKIA…`, `Bearer …`

जब स्पैन ओवरलैप होते हैं, तो लंबा वाला जीतता है, फिर उच्च प्राथमिकता वाला लेबल: email > url > secret > account > phone > date > address > person।

हाइब्रिड कैसे काम करता है

text
  │
  ▼
opf 1.5B ──► BIOES logits ──► Viterbi (tuned biases) ──► char spans
  │
  ▼
span merge        glues "Quindle" + "Testwick" into one person
  │
  ▼
regex backstop    adds url / secret / account where the model missed them
  │
  ▼
spans[]

प्रत्येक चरण को बंद किया जा सकता है:

HybridPIIParser(
    enable_merge=True,
    enable_regex_backstop=True,
    enable_viterbi_tuning=True,
    decode_mode="viterbi",   # or "argmax"
)

आउटपुट स्कीमा

{
  "text": "Hi Quindle Testwick ...",
  "spans": [
    { "label": "private_person", "start": 3, "end": 19, "text": "Quindle Testwick" }
  ]
}

PIIParser regex opf.RedactionResult (schema_version, summary, detected_spans, redacted_text) को दर्शाता है, इसलिए आप उपभोक्ताओं को छुए बिना बैकएंड बदल सकते हैं।

परीक्षण

परीक्षण अपेक्षा करते हैं कि privacy-filter इस रेपो के बगल में क्लोन किया गया हो (वे इसके नमूना फ़िक्स्चर पढ़ते हैं)।

python tests/test_hybrid.py

Fixture F1:  0.929
Scenarios:   8/8 passed
Latency:     ~600 ms CPU

उत्तरदायी उपयोग

यह एक दोहरे उपयोग वाला टूल है। इसे केवल उस डेटा पर चलाएँ जिसका आप स्वामी हैं या जिसे संसाधित करने के लिए आप अधिकृत हैं। लीक हुए या चोरी हुए स्रोतों से व्यक्तिगत डेटा निकालना अधिकांश न्यायक्षेत्रों में अवैध है।

लाइसेंस

Apache-2.0

privacy-parser

सबसे लोकप्रिय