Salt la conținutul principal
Română— Alege o limbă
Meniu

Conformitatea cu GDPR și protecția datelor

Lecția 11 din 12 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. IA și datele cu caracter personal: Un cadru strict
  2. Categoria PII în moderarea Mistral
  3. Anonimizarea înainte de prelucrare
  4. Jurnale de moderare conforme cu GDPR
  5. Pistă de audit pentru conformitate
  6. Listă de verificare GDPR pentru aplicația dumneavoastră de IA
  7. Puncte cheie

Actualizat la 3 noiembrie 2026. Lista elementelor detectate de categoria pii se aliniază acum cu definiția Mistral (datele privind sănătatea intră sub incidența unor reguli diferite, iar categoria health vizează solicitările de sfaturi medicale). Jurnalistul conform calcula anterior incorect data de sfârșit a retenției, ceea ce ducea la ștergerea tuturor datelor în timpul curățării; folosea, de asemenea, o cheie de salting implicită hardcoded pentru pseudonimizare și funcția depreciată datetime.utcnow(). Pseudonimizarea utilizează acum HMAC-SHA-256 cu o cheie obligatorie. Surse: Moderare și Guardrailing · GDPR, Considerentul 26 și Articolele 4 și 22 · Python hmac.

IA și datele cu caracter personal: Un cadru strict

Există un paradox în centrul acestei lecții, iar înțelegerea sa clară evită multe erori de proiectare: sistemul dumneavoastră de moderare este, în sine, o operațiune de prelucrare a datelor cu caracter personal. Pentru a vă proteja utilizatorii, analizați textul acestora, generați scoruri și păstrați jurnale – toate operațiuni pe care GDPR le reglementează exact ca pe orice altă activitate de prelucrare.

Prin urmare, conformitatea nu înseamnă adăugarea unui strat de protecție peste moderare. Înseamnă proiectarea sistemului de moderare însuși pentru a prelucra cantitatea minimă de date, pe durata cea mai scurtă posibilă, menținând în același timp o înregistrare a deciziilor sale. Acesta este firul conductor al secțiunilor următoare.

GDPR (Regulamentul General privind Protecția Datelor) se aplică pe deplin aplicațiilor de IA care prelucrează date ale rezidenților europeni. Moderarea conținutului generează ea însăși date care intră în sfera de aplicare a GDPR. Trebuie să vă înțelegeți obligațiile pentru a evita amenzi care pot ajunge până la 4% din cifra de afaceri anuală globală.

Categoria PII în moderarea Mistral

Categoria pii a clasificatorului Mistral detectează solicitările sau divulgările de informații personale. Un punct arhitectural trebuie subliniat imediat: acest clasificator este o plasă de siguranță, nu o garanție. Acesta prinde formulări variate pe care o expresie regulată (regex) le-ar rata („numărul meu este…“), dar, ca orice model, are fals negative. Invers, o expresie regulată prinde sigur formatele structurate – IBAN-uri, numere de securitate socială, carduri de credit – dar nimic altceva. Cea mai bună practică le combină pe ambele: regex pentru formatele cunoscute, clasificator pentru restul. Tipurile detectate includ:

  • Nume complete
  • Adrese
  • Numere de telefon
  • Numere de securitate socială
  • Detalii ale conturilor financiare

Definiția Mistral se concentrează pe solicitarea, partajarea sau încercarea de a obține aceste informații de identificare.

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
    }

Anonimizarea înainte de prelucrare

Anonimizarea în amonte este măsura cea mai eficientă din punct de vedere al costurilor în întreaga această lecție, deoarece schimbă natura problemei: datele care nu părăsesc niciodată infrastructura dumneavoastră nu ridică probleme de transfer. Înlocuirea numelor, adreselor de e-mail și numerelor cu token-uri ([PERSON_1], [EMAIL_1]) înainte de a apela modelul păstrează aproape întotdeauna sensul pentru analiză – iar dacă păstrați tabelul de corespondență local, puteți reinjecta valorile reale în răspuns. Atâta timp cât acest tabel există, din punct de vedere legal aceasta este pseudonimizare, nu anonimizare: datele rămân cu caracter personal, dar datele trimise modelului nu mai permit identificarea persoanei de unele singure.

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}]
)

Jurnale de moderare conforme cu GDPR

Jurnalele sunt punctul orb clasic: ne gândim la „date cu caracter personal“ în ceea ce privește mesajele utilizatorilor, dar rareori în ceea ce privește urmele tehnice care le copiază. Totuși, un jurnal de moderare care păstrează textul analizat este o bază de date cu caracter personal, cu toate obligațiile care decurg de aici. Regula de bază: stocați textul doar pentru conținutul blocat – veți avea nevoie de el în caz de litigiu – și stocați doar scorurile pentru conținutul acceptat.

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
        ]

Două precauții în acest cod merită menționate. Cheia de pseudonimizare nu are o valoare implicită: o cheie scrisă în cod, cunoscută de toată lumea, ar permite recalcularea hash-ului oricărui identificator. În plus, datele pseudonimizate rămân date cu caracter personal conform GDPR (Considerentul 26): acest jurnal rămâne supus perioadelor de retenție și drepturilor persoanelor vizate.

Pistă de audit pentru conformitate

Pista de audit răspunde unei întrebări specifice pe care un utilizator sau o autoritate v-o poate adresa: „De ce a fost blocat acest conținut?“. Fără o urmă, singurul răspuns onest este „Nu mai știu“ – lucru insustenabil, având în vedere că GDPR cere, pentru deciziile complet automatizate în temeiul Articolului 22, informarea persoanei cu privire la logica din spate (Articolele 13-15), iar Legea privind IA adaugă propriile obligații de transparență. Pista de audit păstrează decizia, scorurile care au motivat-o și versiunea politicii aplicate – fără a fi necesar să păstreze textul însuși.

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

Listă de verificare GDPR pentru aplicația dumneavoastră de IA

Iată punctele de verificat pentru a vă asigura că sistemul de moderare este conform:

  • Interes legitim documentat pentru moderarea conținutului
  • Notificarea utilizatorului cu privire la prelucrarea automată
  • Capacitatea de a contesta o decizie automată

Minimizarea datelor

  • Stocarea doar a datelor strict necesare
  • Anonimizarea sau pseudonimizarea identificatorilor utilizatorilor
  • Trunchierea textului în jurnalele de moderare
  • Neretenția textelor acceptate (doar scorurile)

Perioada de retenție

  • Definirea unei perioade de retenție pentru fiecare tip de date
  • Jurnale de moderare: maximum 90 de zile (cu excepția cazului în care o obligație legală impune altfel)
  • Pistă de audit: conform reglementării sectoriale
  • Curățare automată programată

Drepturile utilizatorilor

  • Dreptul de acces la deciziile de moderare care îi privesc
  • Dreptul la rectificare dacă decizia este contestată
  • Dreptul la explicații privind decizia automată

Puncte cheie

  • GDPR se aplică pe deplin sistemelor dumneavoastră de moderare IA
  • Utilizați categoria pii a Mistral ȘI expresii regulate (regex) pentru a detecta datele cu caracter personal
  • Anonimizați textele înainte de a le trimite modelului, atunci când este posibil
  • Pseudonimizați identificatorii utilizatorilor în jurnale
  • Implementați o pistă de audit pentru trasabilitatea deciziilor
  • Definiți o perioadă de retenție și curățați automat jurnalele