Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Megfelelés a GDPR-nak és adatvédelem

11. lecke 12 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. MI és személyes adatok: Szigorú keretrendszer
  2. A pii kategória a Mistral moderációban
  3. Anonimizálás a feldolgozás előtt
  4. GDPR-kompatibilis moderációs naplók
  5. Ellenőrzési nyomvonal a megfeleléshez
  6. GDPR ellenőrzőlista az MI-alkalmazásodhoz
  7. Főbb megállapítások

Frissítve: 2026. november 3. A pii kategória által észlelt elemek listája most igazodik a Mistral definíciójához (az egészségügyi adatok eltérő szabályozás alá esnek, a health kategória pedig az orvosi tanácsadásra irányuló kéréseket célozza). A megfelelőségi naplózó korábban hibásan számolta ki a megőrzési időszak végét, ami miatt a tisztítási folyamatok mindent töröltek; emellett rögzített alapértelmezett sót kulcsként használt az álanevesítéshez, és a már elavult datetime.utcnow() függvényt hívta meg. Az álanevesítés mostantól HMAC-SHA-256 algoritmust használ kötelező kulccsal. Források: Moderálás és védelmi korlátok · GDPR, (26) preambulumbekezdés, valamint 4. és 22. cikk · Python hmac.

MI és személyes adatok: Szigorú keretrendszer

Ebben a leckében egy paradoxon áll a középpontban, amelynek felismerése számos tervezési hibát megelőz: a moderációs rendszered maga is személyesadat-kezelési műveletnek minősül. Felhasználóid védelme érdekében elemzed a szövegeiket, pontszámokat generálsz és naplókat tárolsz – ezek mind olyan műveletek, amelyeket a GDPR pontosan úgy szabályoz, mint bármely más adatkezelési tevékenységet.

A megfelelés tehát nem azt jelenti, hogy egy védőréteget helyezel a moderáció fölé. Hanem azt, hogy magát a moderációs rendszert úgy tervezed meg, hogy a lehető legkevesebb adatot dolgozza fel, a lehető legrövidebb ideig, miközben rögzíti a döntéseit. Ez a fonal húzódik végig a következő szakaszokon.

A GDPR (Általános Adatvédelmi Rendelet) teljes mértékben alkalmazandó az európai lakosok adatait feldolgozó MI-alkalmazásokra. Maga a tartalommoderálás is olyan adatokat generál, amelyek a GDPR hatálya alá esnek. Ismerned kell a kötelezettségeidet, hogy elkerüld a globális éves árbevétel akár 4%-át is elérő bírságokat.

A pii kategória a Mistral moderációban

A Mistral osztályozójának pii (személyes azonosításra alkalmas információ) kategóriája észleli a személyes információkra irányuló kéréseket vagy azok felfedését. Egy építészeti szempontot azonnal tisztáznunk kell: ez az osztályozó biztonsági háló, nem pedig garancia. Elkaphat olyan változatos megfogalmazásokat, amelyeket egy reguláris kifejezés (regex) kihagyna („a számom…“), de mint minden modell, ennek is vannak hamis negatív eredményei. Ezzel szemben a regex megbízhatóan elfogja a strukturált formátumokat – IBAN-számokat, társadalombiztosítási azonosítókat, bankkártyaszámokat –, de semmi mást. A legjobb gyakorlat mindkettő kombinálása: regex az ismert formátumokhoz, osztályozó minden másra. Az észlelt típusok közé tartoznak:

  • Teljes nevek
  • Címek
  • Telefonszámok
  • Társadalombiztosítási azonosítók
  • Pénzügyi számlaadatok

A Mistral definíciója a kérelemre, a megosztásra vagy ezen azonosító információk megszerzésére irányuló kísérletre fókuszál.

from mistralai.client import Mistral
import os
import re

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

def detect_pii(text: str) -> dict:
    """Személyes adatokat észlel a szövegben."""
    # 1. réteg: Mistral osztályozó
    response = client.classifiers.moderate(
        model="mistral-moderation-2603",
        inputs=[text]
    )
    pii_score = (response.results[0].category_scores or {}).get("pii", 0)

    # 2. réteg: Regex gyakori mintákhoz
    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
    }

Anonimizálás a feldolgozás előtt

A feldolgozás előtti anonimizálás a leghatékonyabb intézkedés ebben a leckében, mert megváltoztatja a probléma jellegét: az az adat, amely soha nem hagyja el az infrastruktúrádat, nem vet fel adatátviteli kérdéseket. Ha a neveket, e-mail címeket és számokat tokenekkel ([PERSON_1], [EMAIL_1]) helyettesíted a modell hívása előtt, az szinte mindig megőrzi a jelentést az elemzés számára – és ha helyben tartod a leképezési táblázatot, visszaillesztheted a valós értékeket a válaszba. Amíg ez a táblázat létezik, jogilag ez álanevesítés, nem anonimizálás: az adat továbbra is személyesnek minősül, de a modellnek küldött adat önmagában már nem teszi lehetővé a személy azonosítását.

def anonymize_text(text: str) -> tuple:
    """Anonimizálja a szöveget és megtartja a visszaállítási leképezést."""
    mapping = {}
    anonymized_text = text

    # E-mailek anonimizálása
    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)

    # Telefonszámok anonimizálása
    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)

    # Nevek anonimizálása (ha a korábbi NER észlelte)
    # Ide add hozzá a saját NER logikádat

    return anonymized_text, mapping

def restore_text(anonymized_text: str, mapping: dict) -> str:
    """Visszaállítja az anonimizált adatokat a feldolgozás után."""
    restored_text = anonymized_text
    for placeholder, value in mapping.items():
        restored_text = restored_text.replace(placeholder, value)
    return restored_text

# Használat a folyamatban
original_text = "Contactez [email protected] au 06 12 34 56 78"
anonymized_text, mapping = anonymize_text(original_text)
# → "Contactez [EMAIL_1] au [TEL_1]"

# Anonimizált szöveg küldése a modellnek
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": anonymized_text}]
)

GDPR-kompatibilis moderációs naplók

A naplók a klasszikus gyenge pontok: a „személyes adat“ fogalmára a felhasználói üzenetek kapcsán gondolunk, de ritkán a azokat másoló technikai nyomokra. Pedig egy moderációs napló, amely tárolja az elemzett szöveget, személyes adatbázisnak minősül, az abból fakadó összes kötelezettséggel. Az aranyszabály: csak a blokkolt tartalmak esetén naplózd a szöveget – vitás esetekre lesz szükséged rá –, a jóváhagyott tartalmaknál pedig csak a pontszámokat rögzítsd.

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


class LogModerationRGPD:
    """GDPR-kompatibilis moderációs naplózó."""

    def __init__(self, retention_jours: int = 90):
        self.retention_jours = retention_jours
        # Kötelező titkos kulcs, tartsd távol a kódtól (trezor vagy környezeti változó)
        self.key = os.environ["PII_HMAC_KEY"].encode()

    def _pseudonymiser(self, user_id: str) -> str:
        """Felhasználói azonosító álanevesítése (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:
        """Egy moderációs döntést rögzít."""
        maintenant = datetime.now(timezone.utc)
        entry = {
            "timestamp": maintenant.isoformat(),
            "user_hash": self._pseudonymiser(user_id),
            "scores": scores,
            "decision": decision,
            # Alapértelmezetten NE tárold a teljes szöveget
            "texte_longueur": len(text) if text else 0,
            "conserver_jusqu_au": (maintenant + timedelta(days=self.retention_jours)).isoformat(),
        }

        # Csak akkor tárold a szövegrészletet, ha blokkolva lett (ellenőrzés céljából)
        if decision == "blocked" and text:
            entry["texte_tronque"] = text[:200]

        return entry

    def purger_anciens_logs(self, logs: list[dict]) -> list[dict]:
        """Megtartja azokat a naplóbejegyzéseket, amelyek megőrzési ideje még nem járt le."""
        maintenant = datetime.now(timezone.utc)
        return [
            log for log in logs
            if datetime.fromisoformat(log["conserver_jusqu_au"]) > maintenant
        ]

Két óvintézkedést érdemes kiemelni ebben a kódban. Az álanevesítési kulcsnak nincs alapértelmezett értéke: egy kódba írt, mindenki által ismert kulcs lehetővé tenné bármely azonosító hash-értékének újraszámítását. Továbbá az álanevesített adat a GDPR szerint továbbra is személyes adatnak minősül ((26) preambulumbekezdés): ez a napló továbbra is alá van vetve a megőrzési időkorlátoknak és az érintetti jogoknak.

Ellenőrzési nyomvonal a megfeleléshez

Az ellenőrzési nyomvonal (audit trail) egy specifikus kérdésre ad választ, amelyet egy felhasználó vagy hatóság feltehet neked: „Miért lett blokkolva ez a tartalom?“ Nyom nélkül az egyetlen őszinte válaszod az lenne, hogy „Már nem tudom“ – ez pedig tarthatatlan, tekintve, hogy a GDPR megköveteli (a 22. cikk szerinti teljesen automatizált döntések esetén), hogy tájékoztasd az érintettet az underlying logikáról (13–15. cikkek), a MI-törvény (AI Act) pedig saját átláthatósági kötelezettségeket ír elő. Az ellenőrzési nyomvonal megőrzi a döntést, az azt indokló pontszámokat és az alkalmazott szabályzat verzióját – anélkül, hogy feltétlenül megőrizné magát a szöveget.

class AuditTrail:
    """Ellenőrzési nyomvonal a moderációs döntésekhez."""

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

    def record_decision(self, data: dict) -> str:
        """Egy döntést rögzít egy egyedi azonosítóval."""
        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"
        }

        # Írás az ellenőrzési fájlba
        import json
        with open(self.storage_path, "a") as f:
            f.write(json.dumps(entry, ensure_ascii=False) + "\n")

        return audit_id

GDPR ellenőrzőlista az MI-alkalmazásodhoz

Íme azok a pontok, amelyeket ellenőrizned kell, hogy biztosítsd moderációs rendszered megfelelőségét:

Jogalap

  • Dokumentált jogos érdek a tartalommoderációhoz
  • A felhasználók tájékoztatása az automatizált feldolgozásról
  • Lehetőség egy automatizált döntés megtámadására

Adatminimalizálás

  • Csak a szigorúan szükséges adatok tárolása
  • Felhasználói azonosítók anonimizálása vagy álanevesítése
  • Szövegek csonkolása a moderációs naplókban
  • Ne tárolj jóváhagyott szövegeket (csak pontszámokat)

Megőrzési idő

  • Megőrzési idő meghatározása minden adattípusra
  • Moderációs naplók: maximum 90 nap (kivéve, ha jogi kötelezettség másként rendelkezik)
  • Ellenőrzési nyomvonal: ágazati szabályozás szerint
  • Ütemezett automatikus tisztítás

Felhasználói jogok

  • Hozzáférési jog a rájuk vonatkozó moderációs döntésekhez
  • Helyesbítési jog, ha a döntést vitatják
  • Magyarázathoz való jog az automatizált döntéssel kapcsolatban

Főbb megállapítások

  • A GDPR teljes mértékben alkalmazandó az MI-moderációs rendszereidre
  • Használd a Mistral pii kategóriáját ÉS a regexet a személyes adatok észlelésére
  • Anonimizáld a szövegeket, mielőtt elküldenéd őket a modellnek, amikor csak lehetséges
  • Álanevesítsd a felhasználói azonosítókat a naplókban
  • Implementálj egy ellenőrzési nyomvonalat a döntések nyomon követhetőségéhez
  • Határozz meg egy megőrzési időt, és automatikusan tisztítsd a naplókat