Przejdź do głównej treści
Polski— Wybierz język
Menu

Zgodność z RODO i ochrona danych

Lekcja 11 z 12 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Sztuczna inteligencja a dane osobowe: ścisłe ramy prawne
  2. Kategoria PII w moderacji Mistral
  3. Anonimizacja przed przetwarzaniem
  4. Logi moderacji zgodne z RODO
  5. Ścieżka audytowa dla zgodności
  6. Lista kontrolna RODO dla Twojej aplikacji AI
  7. Kluczowe wnioski

Zaktualizowano 3 listopada 2026 r. Lista elementów wykrywanych przez kategorię pii jest teraz zgodna z definicją firmy Mistral (dane zdrowotne podlegają innym przepisom, a kategoria health dotyczy próśb o porady medyczne). Poprzedni rejestrator zgodny z RODO błędnie obliczał datę końca retencji, co powodowało usuwanie wszystkich danych podczas czyszczenia; używał również sztywno zakodowanego domyślnego klucza solącego do pseudonimizacji oraz przestarzałej funkcji datetime.utcnow(). Pseudonimizacja korzysta teraz z HMAC-SHA-256 z obowiązkowym kluczem. Źródła: Moderation & Guardrailing · RODO, motyw 26 oraz artykuły 4 i 22 · Python hmac.

Sztuczna inteligencja a dane osobowe: ścisłe ramy prawne

W sercu tej lekcji tkwi pewien paradoks, a jego jasne zrozumienie pozwala uniknąć wielu błędów projektowych: Twój system moderacji stanowi sam w sobie operację przetwarzania danych osobowych. Aby chronić użytkowników, analizujesz ich tekst, generujesz wyniki i przechowujesz logi – wszystkie te czynności są regulowane przez RODO dokładnie tak samo, jak każda inna działalność przetwarzania.

Zgodność z przepisami nie oznacza więc dodawania warstwy ochronnej na wierzchu moderacji. Oznacza zaprojektowanie samego systemu moderacji tak, aby przetwarzał minimalną ilość danych, przez jak najkrótszy czas, jednocześnie prowadząc rejestr podejmowanych decyzji. To jest nić przewodnia kolejnych sekcji.

RODO (Rozporządzenie Ogólne o Ochronie Danych) ma pełne zastosowanie do aplikacji AI przetwarzających dane mieszkańców Europy. Sama moderacja treści generuje dane, które wchodzą w zakres RODO. Musisz zrozumieć swoje obowiązki, aby uniknąć kar sięgających 4% rocznego globalnego obrotu.

Kategoria PII w moderacji Mistral

Klasyfikator Mistrala w kategorii pii wykrywa prośby o dane osobowe lub ich ujawnianie. Należy od razu zaznaczyć jeden aspekt architektoniczny: ten klasyfikator to siatka bezpieczeństwa, a nie gwarancja. Wyłapuje on różne sformułowania, które ominęłyby wyrażenia regularne („mój numer to…“), ale jak każdy model, obarczony jest fałszywymi wynikami negatywnymi. Z drugiej strony, wyrażenia regularne niezawodnie wyłapują ustrukturyzowane formaty – numery IBAN, numery ubezpieczenia społecznego, karty kredytowe – ale nic więcej. Najlepszą praktyką jest połączenie obu metod: wyrażeń regularnych dla znanych formatów i klasyfikatora dla reszty. Wykrywane typy obejmują:

  • Imiona i nazwiska
  • Adresy
  • Numery telefonów
  • Numery ubezpieczenia społecznego
  • Dane kont finansowych

Definicja firmy Mistral koncentruje się na żądaniu, udostępnianiu lub próbie uzyskania tych danych identyfikujących.

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
    }

Anonimizacja przed przetwarzaniem

Anonimizacja przeprowadzana na wstępie jest najskuteczniejszą pod względem kosztów miarą w całej tej lekcji, ponieważ zmienia naturę problemu: dane, które nigdy nie opuszczają Twojej infrastruktury, nie rodzą kwestii związanych z transferem. Zastąpienie imion, adresów e-mail i numerów tokenami ([PERSON_1], [EMAIL_1]) przed wywołaniem modelu prawie zawsze zachowuje sens potrzebny do analizy – a jeśli przechowujesz tabelę mapowania lokalnie, możesz ponownie wstawić rzeczywiste wartości do odpowiedzi. Dopóki tabela ta istnieje, jest to prawnie pseudonimizacja, a nie anonimizacja: dane pozostają danymi osobowymi, ale dane wysyłane do modelu same w sobie nie pozwalają już na identyfikację osoby.

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

Logi moderacji zgodne z RODO

Logi to klasyczny ślepy punkt: myślimy o „danych osobowych“ w kontekście wiadomości użytkowników, ale rzadko w kontekście śladów technicznych, które je kopiują. Tymczasem log moderacji przechowujący analizowany tekst jest bazą danych osobowych, z wszystkimi wynikającymi z tego obowiązkami. Zasada jest prosta: przechowuj tekst tylko dla treści zablokowanych – będziesz go potrzebować w przypadku sporu – a dla treści zaakceptowanych loguj wyłącznie wyniki.

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
        ]

Warto wspomnieć o dwóch środkach ostrożności w tym kodzie. Klucz pseudonimizacji nie ma wartości domyślnej: klucz zapisany w kodzie, znany wszystkim, pozwoliłby na przeliczenie hasha dowolnego identyfikatora. Co więcej, dane pseudonimizowane pozostają danymi osobowymi w rozumieniu RODO (motyw 26): ten log nadal podlega okresom retencji i prawom osób, których dane dotyczą.

Ścieżka audytowa dla zgodności

Ścieżka audytowa odpowiada na konkretne pytanie, które może zadać Ci użytkownik lub organ nadzorczy: „Dlaczego ta treść została zablokowana?“. Bez śladu Twoją jedyną uczciwą odpowiedzią jest „Już nie wiem“ – co jest nie do przyjęcia, biorąc pod uwagę, że RODO wymaga w przypadku w pełni zautomatyzowanych decyzji (art. 22) poinformowania osoby o zastosowanej logice (art. 13–15), a Akt o AI nakłada własne obowiązki przejrzystości. Ścieżka audytowa przechowuje decyzję, wyniki, które ją uzasadniały, oraz wersję zastosowanej polityki – niekoniecznie sam tekst.

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

Lista kontrolna RODO dla Twojej aplikacji AI

Oto punkty, które musisz zweryfikować, aby upewnić się, że Twój system moderacji jest zgodny z przepisami:

Podstawa prawna

  • Udokumentowany prawnie uzasadniony interes w zakresie moderacji treści
  • Powiadomienie użytkowników o przetwarzaniu zautomatyzowanym
  • Możliwość zakwestionowania zautomatyzowanej decyzji

Minimalizacja danych

  • Przechowuj tylko dane ściśle niezbędne
  • Anonimizuj lub pseudonimizuj identyfikatory użytkowników
  • Skracaj tekst w logach moderacji
  • Nie przechowuj zaakceptowanych tekstów (tylko wyniki)

Okres retencji

  • Zdefiniuj okres retencji dla każdego typu danych
  • Logi moderacji: maksymalnie 90 dni (chyba że obowiązek prawny stanowi inaczej)
  • Ścieżka audytowa: zgodnie z regulacjami sektorowymi
  • Zaplanowane automatyczne czyszczenie

Prawa użytkowników

  • Prawo dostępu do decyzji moderacyjnych ich dotyczących
  • Prawo do sprostowania, jeśli decyzja zostanie zakwestionowana
  • Prawo do wyjaśnienia zautomatyzowanej decyzji

Kluczowe wnioski

  • RODO ma pełne zastosowanie do Twoich systemów moderacji AI
  • Używaj kategorii pii od Mistrala ORAZ wyrażeń regularnych do wykrywania danych osobowych
  • Anonimizuj teksty przed wysłaniem ich do modelu, gdy to możliwe
  • Pseudonimizuj identyfikatory użytkowników w logach
  • Wdróż ścieżkę audytową dla możliwości śledzenia decyzji
  • Zdefiniuj okres retencji i automatycznie czyść logi