Menyamarkan data sulit dalam gesaan menggunakan Regex dan spaCy

Orang ramai mempunyai kebimbangan privasi mengenai LLM popular seperti OpenAI, Gemini, Claude dll...,. Kami tidak tahu apa yang berlaku di sebalik skrin melainkan model sumber terbuka. Jadi, kita kena berhati-hati dari pihak kita.

Perkara pertama ialah pengendalian maklumat yang kami sampaikan kepada LLM. Pakar mengesyorkan mengelakkan sebarang termasuk maklumat sulit atau pengecam peribadi dalam gesaan. Bunyinya lebih mudah, tetapi apabila saiz konteks LLM semakin meningkat, kami boleh menghantar teks besar kepada model. Jadi, ia mungkin menjadi semakan keras dan menutup semua pengecam. 

Jadi, saya cuba mencipta skrip python yang akan mengesan dan menutup pengecam dan maklumat sulit. Regex adalah ajaib dan dilaksanakan untuk mengenali maklumat sulit yang berbeza dan menggantikannya dengan topeng. Juga menggunakan perpustakaan spacy untuk mengesan pengecam biasa seperti nama, tempat dsb.,

Nota: Buat masa ini, ini sesuai untuk konteks India, tetapi pengecam biasa masih boleh dikesan. 

Jadi mari kita lihat pelaksanaannya (saya telah mengambil bantuan LLM untuk pelaksanaan)
Jika anda ingin melangkau penjelasan. 

Berikut ialah pautan ke pangkalan kod: aditykris/prompt-masker-Indian-context
Mengimport modul/pustaka yang diperlukan

import re 

from typing import Dict, List, Tuple

import spacy

nlp = spacy.load("en_core_web_sm")

Anda perlu memasang "en_core_web_sm" secara manual menggunakan coretan di bawah

muat turun python -m spacy en_core_web_sm

Menetapkan maklumat sulit umum India.

class IndianIdentifier:
    '''Regex for common Indian identifiers'''
    PAN = r'[A-Z]{5}[0-9]{4}[A-Z]{1}'
    AADHAR = r'[2-9]{1}[0-9]{3}\s[0-9]{4}\s[0-9]{4}'
    INDIAN_PASSPORT = r'[A-PR-WYa-pr-wy][1-9]\d\s?\d{4}[1-9]'
    DRIVING_LICENSE = r'(([A-Z]{2}[0-9]{2})( )|([A-Z]{2}-[0-9]{2}))((19|20)[0-9][0-9])[0-9]{7}'
    UPI_ID = r'[\.\-a-z0-9]+@[a-z]+'
    INDIAN_BANK_ACCOUNT = r'\d{9,18}'
    IFSC_CODE = r'[A-Z]{4}0[A-Z0-9]{6}'
    INDIAN_PHONE_NUMBER = r'(\+91|\+91\-|0)?[789]\d{9}'
    EMAIL = r'[\w\.-]+@[\w\.-]+\.\w+'

    @classmethod
    def get_all_patterns(cls) -> Dict[str, str]:
        """Returns all regex patterns defined in the class"""
        return {
            name: pattern 
            for name, pattern in vars(cls).items() 
            if isinstance(pattern, str) and not name.startswith('_')
        }

Jadi, saya sedang menyemak semula kelas dan kaedah ular sawa, jadi saya meneruskan untuk melaksanakannya di sini. 
Saya mendapati regex pengecam ini daripada DebugPointer, sangat membantu.
Sekarang ke fungsi pengesanan. Simple re.finditer() telah digunakan untuk menggelung melalui corak yang berbeza untuk mencari padanan. Padanan disimpan dalam senarai.

def find_matches(text: str, pattern: str) -> List[Tuple[int, int, str]]:
    """
    Find all matches of a pattern in text and return their positions and matched text
    """
    matches = []
    for match in re.finditer(pattern, text):
        matches.append((match.start(), match.end(), match.group()))
    return matches

Menggunakan kamus ringkas untuk menyimpan teks gantian. Membungkusnya dalam fungsi untuk mengembalikan teks gantian.

def get_replacement_text(identifier_type: str) -> str:
    """
    Returns appropriate replacement text based on the type of identifier
    """
    replacements = {
        'PAN': '[PAN_NUMBER]',
        'AADHAR': '[AADHAR_NUMBER]',
        'INDIAN_PASSPORT': '[PASSPORT_NUMBER]',
        'DRIVING_LICENSE': '[DL_NUMBER]',
        'UPI_ID': '[UPI_ID]',
        'INDIAN_BANK_ACCOUNT': '[BANK_ACCOUNT]',
        'IFSC_CODE': '[IFSC_CODE]',
        'INDIAN_PHONE_NUMBER': '[PHONE_NUMBER]',
        'EMAIL': '[EMAIL_ADDRESS]',
        'PERSON': '[PERSON_NAME]',
        'ORG': '[ORGANIZATION]',
        'GPE': '[LOCATION]'
    }
    return replacements.get(identifier_type, '[MASKED]')

Ah! bahagian utama bermula.

def analyze_identifiers(text: str) -> Tuple[str, Dict[str, List[str]]]:
    """
    Function to identify and hide sensitive information.
    Returns:
        - masked_text: Text with all sensitive information masked
        - found_identifiers: Dictionary containing all identified sensitive information
    """
    # Initialize variables
    masked_text = text
    found_identifiers = {}
    positions_to_mask = []

    # First, find all regex matches
    for identifier_name, pattern in IndianIdentifier.get_all_patterns().items():
        matches = find_matches(text, pattern)
        if matches:
            found_identifiers[identifier_name] = [match[2] for match in matches]
            positions_to_mask.extend(
                (start, end, identifier_name) for start, end, _ in matches
            )

    # Then, process named entities using spaCy
    doc = nlp(text)
    for ent in doc.ents:
        if ent.label_ in ["PERSON", "ORG", "GPE"]:
            positions_to_mask.append((ent.start_char, ent.end_char, ent.label_))
            if ent.label_ not in found_identifiers:
                found_identifiers[ent.label_] = []
            found_identifiers[ent.label_].append(ent.text)

    # Sort positions by start index in reverse order to handle overlapping matches
    positions_to_mask.sort(key=lambda x: x[0], reverse=True)

    # Apply masking
    for start, end, identifier_type in positions_to_mask:
        replacement = get_replacement_text(identifier_type)
        masked_text = masked_text[:start] + replacement + masked_text[end:]

    return masked_text, found_identifiers

Fungsi ini mengambil gesaan sebagai input dan mengembalikan gesaan bertopeng bersama-sama elemen yang dikenal pasti sebagai kamus.

Biar saya terangkan satu persatu.

Mengikuti gelung melalui regex pengecam yang berbeza untuk mencari padanan dalam gesaan. Jika ditemui, maka ia akan:
 1. Simpan maklumat yang dikenal pasti dalam kamus dengan jenis pengecam sebagai kuncinya untuk menjejaki.
 2. Catatkan kedudukan dan simpannya dalam positions_to_mask supaya kita boleh menggunakan masking nanti.

import re 

from typing import Dict, List, Tuple

import spacy

nlp = spacy.load("en_core_web_sm")

Sekarang masa lapang. Ia adalah perpustakaan yang bagus untuk tugas pemprosesan bahasa semula jadi (nlp). Kita boleh mengekstrak pengecam daripada teks menggunakan modul nlp.
Pada masa ini, saya telah biasa mengesan Nama, Organisasi dan lokasi.
Ini berfungsi seperti gelung di atas untuk mengenal pasti dan menyimpan lokasi.

class IndianIdentifier:
    '''Regex for common Indian identifiers'''
    PAN = r'[A-Z]{5}[0-9]{4}[A-Z]{1}'
    AADHAR = r'[2-9]{1}[0-9]{3}\s[0-9]{4}\s[0-9]{4}'
    INDIAN_PASSPORT = r'[A-PR-WYa-pr-wy][1-9]\d\s?\d{4}[1-9]'
    DRIVING_LICENSE = r'(([A-Z]{2}[0-9]{2})( )|([A-Z]{2}-[0-9]{2}))((19|20)[0-9][0-9])[0-9]{7}'
    UPI_ID = r'[\.\-a-z0-9]+@[a-z]+'
    INDIAN_BANK_ACCOUNT = r'\d{9,18}'
    IFSC_CODE = r'[A-Z]{4}0[A-Z0-9]{6}'
    INDIAN_PHONE_NUMBER = r'(\+91|\+91\-|0)?[789]\d{9}'
    EMAIL = r'[\w\.-]+@[\w\.-]+\.\w+'

    @classmethod
    def get_all_patterns(cls) -> Dict[str, str]:
        """Returns all regex patterns defined in the class"""
        return {
            name: pattern 
            for name, pattern in vars(cls).items() 
            if isinstance(pattern, str) and not name.startswith('_')
        }

Dalam sesetengah kes ujian, saya perasan bahawa beberapa topeng telah hilang dan ia disebabkan terutamanya oleh pertindihan pengecam. Jadi, Isih dalam susunan terbalik membantu dalam menyelesaikannya.

 

def find_matches(text: str, pattern: str) -> List[Tuple[int, int, str]]:
    """
    Find all matches of a pattern in text and return their positions and matched text
    """
    matches = []
    for match in re.finditer(pattern, text):
        matches.append((match.start(), match.end(), match.group()))
    return matches

Kemudian Akhirnya, kami menyembunyikan berlaku menggunakan data daripada found_identifiers dan positions_to_mask.

def get_replacement_text(identifier_type: str) -> str:
    """
    Returns appropriate replacement text based on the type of identifier
    """
    replacements = {
        'PAN': '[PAN_NUMBER]',
        'AADHAR': '[AADHAR_NUMBER]',
        'INDIAN_PASSPORT': '[PASSPORT_NUMBER]',
        'DRIVING_LICENSE': '[DL_NUMBER]',
        'UPI_ID': '[UPI_ID]',
        'INDIAN_BANK_ACCOUNT': '[BANK_ACCOUNT]',
        'IFSC_CODE': '[IFSC_CODE]',
        'INDIAN_PHONE_NUMBER': '[PHONE_NUMBER]',
        'EMAIL': '[EMAIL_ADDRESS]',
        'PERSON': '[PERSON_NAME]',
        'ORG': '[ORGANIZATION]',
        'GPE': '[LOCATION]'
    }
    return replacements.get(identifier_type, '[MASKED]')

Sampel input program ini ialah:

Input:

def analyze_identifiers(text: str) -> Tuple[str, Dict[str, List[str]]]:
    """
    Function to identify and hide sensitive information.
    Returns:
        - masked_text: Text with all sensitive information masked
        - found_identifiers: Dictionary containing all identified sensitive information
    """
    # Initialize variables
    masked_text = text
    found_identifiers = {}
    positions_to_mask = []

    # First, find all regex matches
    for identifier_name, pattern in IndianIdentifier.get_all_patterns().items():
        matches = find_matches(text, pattern)
        if matches:
            found_identifiers[identifier_name] = [match[2] for match in matches]
            positions_to_mask.extend(
                (start, end, identifier_name) for start, end, _ in matches
            )

    # Then, process named entities using spaCy
    doc = nlp(text)
    for ent in doc.ents:
        if ent.label_ in ["PERSON", "ORG", "GPE"]:
            positions_to_mask.append((ent.start_char, ent.end_char, ent.label_))
            if ent.label_ not in found_identifiers:
                found_identifiers[ent.label_] = []
            found_identifiers[ent.label_].append(ent.text)

    # Sort positions by start index in reverse order to handle overlapping matches
    positions_to_mask.sort(key=lambda x: x[0], reverse=True)

    # Apply masking
    for start, end, identifier_type in positions_to_mask:
        replacement = get_replacement_text(identifier_type)
        masked_text = masked_text[:start] + replacement + masked_text[end:]

    return masked_text, found_identifiers

Output:
Teks Bertopeng:

for identifier_name, pattern in IndianIdentifier.get_all_patterns().items():
        matches = find_matches(text, pattern)
        if matches:
            found_identifiers[identifier_name] = [match[2] for match in matches]
            positions_to_mask.extend(
                (start, end, identifier_name) for start, end, _ in matches
            )

Atas ialah kandungan terperinci Menyamarkan data sulit dalam gesaan menggunakan Regex dan spaCy. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!