Membership inference via embeddings

Bepalen of specifieke data in de trainingsset van een embeddingmodel zat via afstandsgebaseerde inferentie, statistische toetsen en analyse van embedding-gedrag.

Membership inference-aanvallen bepalen of een specifiek stuk data deel uitmaakte van de trainingsset van een embeddingmodel. Dit is een privacyrelevante vraag: het kan onthullen of de proprietaire data van een organisatie zonder toestemming is gebruikt om een commercieel model te trainen, of de persoonsgegevens van een individu in een systeem aanwezig zijn, of dat een dataset in strijd met de licentievoorwaarden is gebruikt.

Waarom membership inference werkt

Embeddingmodellen gedragen zich, net als alle machine learning-modellen, anders op data die ze tijdens de training hebben gezien dan op data die ze niet hebben gezien. Dit verschil in gedrag creëert een signaal dat met zorgvuldige analyse kan worden gedetecteerd.

Het overfittingsignaal

Modellen neigen ertoe lichtjes te overfitten op hun trainingsdata, waardoor ze "zelfverzekerdere" representaties voor trainingsvoorbeelden produceren. Voor embeddingmodellen uit zich dat als:

• Lagere reconstructie-loss — Het model codeert trainingsdata efficiënter
• Hogere zelfgelijkenis — Embeddings van trainingsdata zijn consistenter onder verstoringen
• Clusternabijheid — Trainingsvoorbeelden embedden dichter bij clustercentra dan niet-trainingsvoorbeelden
• Dimensionale concentratie — Trainingsdata levert embeddings op die in bepaalde dimensies meer geconcentreerd zijn

Het memorisatiesignaal

Grote modellen memoriseren delen van hun trainingsdata. Voor embeddingmodellen levert gememoriseerde data embeddings op met onderscheidende eigenschappen:

• Meer extreme waarden in specifieke dimensies
• Hogere cosinusgelijkenis met embeddings van verwante trainingsvoorbeelden
• Voorspelbaarder embedding-gedrag onder invoerverstoring

Afstandsgebaseerde inferentie

De eenvoudigste benadering van membership inference vergelijkt de embedding-afstand tussen de kandidaattekst en bekende referentiepunten.

Zelfgelijkenistoets

Embed de kandidaattekst en lichte verstoringen ervan. Trainingsdata heeft doorgaans consistentere (zelfgelijke) embeddings onder verstoringen:

def self_similarity_test(text, model, num_perturbations=50):
    """Toets via zelfgelijkenis of tekst in de trainingsdata zat."""
    original_embedding = model.encode(text)
 
    perturbation_similarities = []
    for _ in range(num_perturbations):
        # Maak een lichte verstoring (typefout, woordwissel, synoniem)
        perturbed = create_perturbation(text)
        perturbed_embedding = model.encode(perturbed)
 
        similarity = cosine_similarity(original_embedding, perturbed_embedding)
        perturbation_similarities.append(similarity)
 
    # Trainingsdata heeft doorgaans een hogere gemiddelde gelijkenis
    # (robuuster tegen verstoringen)
    avg_similarity = np.mean(perturbation_similarities)
    std_similarity = np.std(perturbation_similarities)
 
    return {
        'mean_similarity': avg_similarity,
        'std_similarity': std_similarity,
        'likely_member': avg_similarity > THRESHOLD  # Kalibreer de drempel
    }

Nearest-neighbor-afstand

Trainingsdata ligt doorgaans dichter bij haar naaste buren in de embeddingruimte dan niet-trainingsdata:

def nearest_neighbor_test(text, model, reference_corpus):
    """Vergelijk de nearest-neighbor-afstand voor member- versus non-member-data."""
    target_embedding = model.encode(text)
    reference_embeddings = model.encode(reference_corpus)
 
    # Bereken de afstand tot het dichtstbijzijnde referentiepunt
    distances = [
        1 - cosine_similarity(target_embedding, ref)
        for ref in reference_embeddings
    ]
    min_distance = min(distances)
 
    # Trainingsdata heeft doorgaans kleinere nearest-neighbor-afstanden
    return min_distance

Statistische toetsen

Strengere benaderingen gebruiken statistische toetsen om member- en non-member-embeddings van elkaar te onderscheiden.

Likelihood-ratiotoets

Vergelijk de aannemelijkheid van de embedding onder een "member"-model en een "non-member"-model:

def likelihood_ratio_test(embedding, member_distribution, nonmember_distribution):
    """Bereken de likelihood-ratio voor membership inference."""
    # Pas verdelingen aan op bekende member- en non-member-embeddings
    member_likelihood = member_distribution.log_prob(embedding)
    nonmember_likelihood = nonmember_distribution.log_prob(embedding)
 
    ratio = member_likelihood - nonmember_likelihood
    return ratio  # Positief = waarschijnlijk member

Gekalibreerde betrouwbaarheidstoets

Train een classifier om member- en non-member-embeddings te onderscheiden aan de hand van bekende voorbeelden:

from sklearn.ensemble import RandomForestClassifier
 
def train_membership_classifier(known_members, known_nonmembers, model):
    """Train een classifier om membership te voorspellen."""
    member_embeddings = [model.encode(t) for t in known_members]
    nonmember_embeddings = [model.encode(t) for t in known_nonmembers]
 
    X = np.vstack(member_embeddings + nonmember_embeddings)
    y = [1] * len(member_embeddings) + [0] * len(nonmember_embeddings)
 
    # Extraheer features uit de embeddings
    features = extract_embedding_features(X)  # Norm, dimensiestatistieken, enz.
 
    clf = RandomForestClassifier(n_estimators=100)
    clf.fit(features, y)
    return clf
 
def predict_membership(text, model, classifier):
    embedding = model.encode(text)
    features = extract_embedding_features(embedding.reshape(1, -1))
    probability = classifier.predict_proba(features)[0][1]
    return probability

Feature engineering voor membership inference

De features die voor classificatie worden gebruikt, zijn onder meer:

Praktijkscenario's

Ongeautoriseerd datagebruik opsporen

Een organisatie vermoedt dat een commerciële embedding-dienst op hun proprietaire documenten heeft getraind. Ze kunnen membership inference testen op bekende proprietaire teksten:

# Test of proprietaire documenten in de training zijn gebruikt
proprietary_texts = load_proprietary_documents()
public_texts = load_public_documents_same_domain()
 
# Vergelijk de membership-scores
proprietary_scores = [membership_score(t, target_model) for t in proprietary_texts]
public_scores = [membership_score(t, target_model) for t in public_texts]
 
# Statistische toets: zijn de proprietaire scores significant hoger?
from scipy.stats import mannwhitneyu
statistic, p_value = mannwhitneyu(proprietary_scores, public_scores, alternative='greater')
print(f"p-value: {p_value}")  # Een lage p-waarde wijst erop dat proprietaire data is gebruikt

Aanwezigheid van data van een individu

Bepalen of de data van een specifiek individu in een AI-systeem aanwezig is, heeft gevolgen voor inzageverzoeken van betrokkenen onder de AVG:

# Test of de e-mails van een specifiek individu in de trainingsdata zitten
individual_texts = [
    "Meeting with Sarah regarding Q3 projections",
    "Please find attached the revised contract for Project Atlas",
    # ... meer bekende teksten van het individu
]
 
for text in individual_texts:
    score = membership_score(text, target_model)
    print(f"Membership score: {score:.4f} - {text[:50]}...")

Audit van trainingsdata

Modelaanbieders kunnen membership inference als audittool gebruiken om te verifiëren dat hun trainingspipeline data die zich heeft afgemeld of die beperkt is, correct heeft uitgesloten.

Beperkingen en kanttekeningen

Membership inference op embeddingmodellen kent een aantal belangrijke beperkingen:

False-positiveratio. Teksten die sterk op trainingsdata lijken (zelfde domein, vergelijkbare formulering) kunnen als member scoren, zelfs als ze niet in de trainingsset zaten. De techniek detecteert gelijkenis met trainingsdata, niet exacte membership.

Afhankelijkheid van de modelgrootte. Grotere modellen memoriseren meer en zijn gevoeliger voor membership inference. Kleinere modellen vertonen mogelijk geen detecteerbaar membership-signaal.

Diversiteit van de trainingsdata. Modellen die op zeer diverse data zijn getraind, zijn lastiger te proben, omdat het membership-signaal zwakker is wanneer geen enkel voorbeeld vaak wordt gezien.

Verwerking na de training. Kwantisatie, distillatie en fine-tuning kunnen het membership-signaal veranderen, waardoor de nauwkeurigheid van de inferentie afneemt.

Verwante onderwerpen

• Inversion Attacks — Content herstellen in plaats van alleen aanwezigheid detecteren
• Adversarial Embeddings — Embeddings manipuleren in plaats van analyseren
• Training Pipeline Attacks — De bredere context van de beveiliging van trainingsdata