Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Overholdelse af GDPR og databeskyttelse

Lektion 11 af 12 Opdateret 3. november 2026 Udvikler
På denne side
  1. AI og personoplysninger: En streng ramme
  2. Kategorien PII i Mistral Moderation
  3. Anonymisering før behandling
  4. GDPR-kompatible moderationslogs
  5. Revisionsspor til overholdelse
  6. GDPR-tjekliste til din AI-applikation
  7. Vigtige pointer

Opdateret 3. november 2026. Listen over elementer, der registreres af kategorien pii, er nu tilpasset Mistrals definition (sundhedsdata falder under andre regler, og kategorien health målretter anmodninger om medicinsk rådgivning). Den tidligere overholdelseslogger beregnede forkert sin opbevaringsudløbsdato, hvilket fik rydninger til at slette alt; den brugte også en hardkodet standardnøgle til saltning ved pseudonymisering og den forældede datetime.utcnow(). Pseudonymisering bruger nu HMAC-SHA-256 med en obligatorisk nøgle. Kilder: Moderation & Guardrailing · GDPR, betragtning 26 samt artikel 4 og 22 · Python hmac.

AI og personoplysninger: En streng ramme

Der er et paradoks i hjertet af denne lektion, og ser du det klart, undgår du mange designfejl: dit moderationssystem er i sig selv en behandling af personoplysninger. For at beskytte dine brugere analyserer du deres tekst, genererer scorer og gemmer logs – alt sammen operationer, som GDPR regulerer præcis som enhver anden behandlingsaktivitet.

Overholdelse betyder derfor ikke, at du lægger et beskyttelseslag oven på moderationen. Det betyder, at du designer selve moderationssystemet til at behandle mindst mulige mængder data, i kortest mulig tid, samtidig med at du fører register over dets beslutninger. Dette er den røde tråd i de følgende afsnit.

GDPR (General Data Protection Regulation) finder fuld anvendelse på AI-applikationer, der behandler data for europæiske borgere. Selve indholdsmoderationen genererer data, der falder ind under GDPR’s anvendelsesområde. Du skal forstå dine forpligtelser for at undgå bøder på op til 4 % af den globale årsomsætning.

Kategorien PII i Mistral Moderation

Mistrals klassifikator i kategorien pii registrerer anmodninger om eller videregivelse af personlige oplysninger. Et arkitektonisk punkt skal slås fast med det samme: denne klassifikator er et sikkerhedsnet, ikke en garanti. Den fanger varierede formuleringer, som et regex ville overse (“mit nummer er…”), men som enhver model har den falske negativer. Omvendt fanger et regex pålideligt strukturerede formater – IBAN’er, CPR-numre, kreditkort – men intet andet. Bedste praksis kombinerer begge: regex til kendte formater, klassifikator til resten. Registrerede typer inkluderer:

  • Fulde navne
  • Adresser
  • Telefonnumre
  • CPR-numre (eller tilsvarende nationale ID-numre)
  • Oplysninger om finansielle konti

Mistrals definition fokuserer på anmodningen om, delingen af eller forsøget på at opnå disse identificerende oplysninger.

from mistralai.client import Mistral
import os
import re

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

def detect_pii(text: str) -> dict:
    """Detects personal data in text."""
    # Layer 1: Mistral Classifier
    response = client.classifiers.moderate(
        model="mistral-moderation-2603",
        inputs=[text]
    )
    pii_score = (response.results[0].category_scores or {}).get("pii", 0)

    # Layer 2: Regex for common patterns
    pii_patterns = {
        "email": r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
        "telephone_fr": r"(?:0|\+33)[1-9](?:\d{2}){4}",
        "secu_sociale": r"\d{13,15}",
        "carte_bancaire": r"\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}",
        "iban": r"FR\d{2}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{3}"
    }

    detected_pii = {}
    for name, pattern in pii_patterns.items():
        matches = re.findall(pattern, text)
        if matches:
            detected_pii[name] = len(matches)

    return {
        "score_classifieur": round(pii_score, 3),
        "pii_regex": detected_pii,
        "contient_pii": pii_score > 0.2 or len(detected_pii) > 0
    }

Anonymisering før behandling

Anonymisering upstream er den mest omkostningseffektive foranstaltning i hele denne lektion, fordi den ændrer problemets natur: data, der aldrig forlader din infrastruktur, rejser ingen overførselsproblemer. Ved at erstatte navne, e-mails og numre med tokens ([PERSON_1], [EMAIL_1]) før kaldet til modellen bevares betydningen næsten altid til analyseformål – og hvis du beholder mapping-tabellen lokalt, kan du indsætte de rigtige værdier igen i svaret. Så længe denne tabel eksisterer, er dette juridisk set pseudonymisering, ikke anonymisering: dataene forbliver personoplysninger, men de data, der sendes til modellen, muliggør ikke længere identificering af personen alene.

def anonymize_text(text: str) -> tuple:
    """Anonymizes text and keeps a restoration mapping."""
    mapping = {}
    anonymized_text = text

    # Anonymize emails
    emails = re.findall(
        r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
        text
    )
    for i, email in enumerate(set(emails)):
        placeholder = f"[EMAIL_{i+1}]"
        mapping[placeholder] = email
        anonymized_text = anonymized_text.replace(email, placeholder)

    # Anonymize phones
    phones = re.findall(
        r"(?:0|\+33)[1-9](?:[\s.-]?\d{2}){4}",
        text
    )
    for i, tel in enumerate(set(phones)):
        placeholder = f"[TEL_{i+1}]"
        mapping[placeholder] = tel
        anonymized_text = anonymized_text.replace(tel, placeholder)

    # Anonymize names (if detected by upstream NER)
    # Add your own NER logic here

    return anonymized_text, mapping

def restore_text(anonymized_text: str, mapping: dict) -> str:
    """Restores anonymized data after processing."""
    restored_text = anonymized_text
    for placeholder, value in mapping.items():
        restored_text = restored_text.replace(placeholder, value)
    return restored_text

# Usage in pipeline
original_text = "Contactez [email protected] au 06 12 34 56 78"
anonymized_text, mapping = anonymize_text(original_text)
# → "Contactez [EMAIL_1] au [TEL_1]"

# Send anonymized text to model
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": anonymized_text}]
)

GDPR-kompatible moderationslogs

Logs er det klassiske blinde punkt: vi tænker på „personoplysninger” i forhold til brugerbeskeder, men sjældent i forhold til de tekniske spor, der kopierer dem. Alligevel er en moderationslog, der gemmer den analyserede tekst, en persondatabase med alle deraf følgende forpligtelser. Tommelfingerreglen er: gem kun tekst for blokeret indhold – du får brug for det i tilfælde af tvist – og gem kun scorer for accepteret indhold.

import hashlib
import hmac
from datetime import datetime, timedelta, timezone


class LogModerationRGPD:
    """GDPR-compliant moderation logger."""

    def __init__(self, retention_jours: int = 90):
        self.retention_jours = retention_jours
        # Mandatory secret key, kept out of code (vault or environment variable)
        self.key = os.environ["PII_HMAC_KEY"].encode()

    def _pseudonymiser(self, user_id: str) -> str:
        """Pseudonymizes a user identifier (HMAC-SHA-256)."""
        return hmac.new(self.key, user_id.encode(), hashlib.sha256).hexdigest()[:16]

    def log_moderation(self, user_id: str, scores: dict, decision: str,
                       text: str | None = None) -> dict:
        """Records a moderation decision."""
        maintenant = datetime.now(timezone.utc)
        entry = {
            "timestamp": maintenant.isoformat(),
            "user_hash": self._pseudonymiser(user_id),
            "scores": scores,
            "decision": decision,
            # Do NOT store full text by default
            "texte_longueur": len(text) if text else 0,
            "conserver_jusqu_au": (maintenant + timedelta(days=self.retention_jours)).isoformat(),
        }

        # Store text excerpt only if blocked (for audit)
        if decision == "blocked" and text:
            entry["texte_tronque"] = text[:200]

        return entry

    def purger_anciens_logs(self, logs: list[dict]) -> list[dict]:
        """Keeps logs whose retention end date has not passed."""
        maintenant = datetime.now(timezone.utc)
        return [
            log for log in logs
            if datetime.fromisoformat(log["conserver_jusqu_au"]) > maintenant
        ]

To forholdsregler i denne kode fortjener at blive nævnt. Nøglen til pseudonymisering har ingen standardværdi: en nøgle skrevet direkte i koden, kendt af alle, ville gøre det muligt at genberegne hash-værdien for enhver identifikator. Derudover forbliver pseudonymiserede data personoplysninger under GDPR (betragtning 26): denne log forbliver underlagt opbevaringsperioder og de registreredes rettigheder.

Revisionsspor til overholdelse

Revisionssporet besvarer et specifikt spørgsmål, som en bruger eller en myndighed kan stille dig: „Hvorfor blev dette indhold blokeret?” Uden et spor er dit eneste ærlige svar „Det ved jeg ikke længere” – hvilket er uholdbart, da GDPR kræver, at du ved fuldt automatiserede beslutninger i henhold til artikel 22 informerer personen om den underliggende logik (artikel 13 til 15), og AI-loven tilføjer sine egne gennemsigtighedsforpligtelser. Revisionssporet gemmer beslutningen, de scorer, der begrundedes den, og den version af politikken, der blev anvendt – uden nødvendigvis at gemme selve teksten.

class AuditTrail:
    """Audit trail for moderation decisions."""

    def __init__(self, storage_path: str):
        self.storage_path = storage_path

    def record_decision(self, data: dict) -> str:
        """Records a decision with a unique identifier."""
        import uuid

        audit_id = str(uuid.uuid4())
        entry = {
            "audit_id": audit_id,
            "timestamp": datetime.now(timezone.utc).isoformat(),
            "type_decision": data.get("decision"),
            "modele_moderation": "mistral-moderation-2603",
            "scores": data.get("scores"),
            "seuils_appliques": data.get("seuils"),
            "politique_version": data.get("politique_version"),
            "action_prise": data.get("action"),
            "base_legale": "interet_legitime",
            "responsable": "systeme_automatise"
        }

        # Write to audit file
        import json
        with open(self.storage_path, "a") as f:
            f.write(json.dumps(entry, ensure_ascii=False) + "\n")

        return audit_id

GDPR-tjekliste til din AI-applikation

Her er de punkter, du skal verificere for at sikre, at dit moderationssystem er compliant:

Juridisk grundlag

  • Dokumenteret berettiget interesse for indholdsmoderation
  • Brugeren underrettes om automatiseret behandling
  • Mulighed for at gøre indsigelse mod en automatiseret beslutning

Dataminimering

  • Gem kun strengt nødvendige data
  • Anonymiser eller pseudonymiser brugeridentifikatorer
  • Afkort tekst i moderationslogs
  • Gem ikke accepterede tekster (kun scorer)

Opbevaringsperiode

  • Definer en opbevaringsperiode for hver datatype
  • Moderationslogs: maksimalt 90 dage (medmindre en juridisk forpligtelse kræver andet)
  • Revisionsspor: efter sektorspecifik regulering
  • Planlagt automatisk rydning

Brugerrettigheder

  • Ret til indsigt i moderationsbeslutninger, der vedrører dem
  • Ret til berigtigelse, hvis beslutningen anfægtes
  • Ret til forklaring på den automatiserede beslutning

Vigtige pointer

  • GDPR finder fuld anvendelse på dine AI-moderationssystemer
  • Brug både Mistrals kategori pii OG regex til at registrere personoplysninger
  • Anonymiser tekster, før du sender dem til modellen, når det er muligt
  • Pseudonymiser brugeridentifikatorer i logs
  • Implementer et revisionsspor til sporbarhed af beslutninger
  • Definer en opbevaringsperiode og ryd logs automatisk