Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

GDPR-vaatimustenmukaisuus ja tietosuoja

Oppitunti 11 / 12 Päivitetty 3. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Tekoäly ja henkilötiedot: tiukka viitekehys
  2. PII-luokka Mistral-moderaatiossa
  3. Anonymisointi ennen käsittelyä
  4. GDPR-vaatimustenmukaiset moderointilokit
  5. Tarkastusketju vaatimustenmukaisuutta varten
  6. Tarkistuslista tekoälysovelluksesi GDPR-vaatimustenmukaisuuteen
  7. Keskeiset asiat

Päivitetty 3. marraskuuta 2026. Luettelo kohteista, jotka pii-luokka havaitsee, on nyt linjassa Mistralin määritelmän kanssa (terveystiedot kuuluvat eri sääntöjen piiriin, ja health-luokka kohdistuu lääketieteellisiä neuvoja koskeviin pyyntöihin). Vaatimustenmukainen lokituslaskuri laski aiemmin säilytysajan päättymispäivän väärin, mikä johti siihen, että tyhjennykset poistivat kaiken; se käytti myös kovakoodattua oletussuolausavainta pseudonymisointiin ja vanhentunutta datetime.utcnow()-funktiota. Pseudonymisointi käyttää nyt pakollista avainta HMAC-SHA-256-algoritmilla. Lähteet: Moderation & Guardrailing · GDPR, johdanto-osan 26 kappale sekä 4 ja 22 artikla · Python hmac.

Tekoäly ja henkilötiedot: tiukka viitekehys

Tämän oppitunnin ytimessä on paradoksi, ja sen oivaltaminen säästää sinut monilta suunnitteluvirheiltä: moderaatiojärjestelmäsi on itsessään henkilötietojen käsittelytoimi. Suojellaksesi käyttäjiäsi analysoit heidän tekstiään, tuotat pisteytyksiä ja säilytät lokeja – kaikki nämä toimet, joita GDPR sääntelee täsmälleen kuten mitä tahansa muutakin käsittelytoimintaa.

Vaadittujen standardien noudattaminen ei siis tarkoita suojakerroksen lisäämistä moderaation päälle. Se tarkoittaa moderaatiojärjestelmän itsensä suunnittelemista siten, että se käsittelee mahdollisimman vähän dataa mahdollisimman lyhyen ajan, samalla kun se pitää kirjaa tekemistään päätöksistä. Tämä on punainen lanka, joka kulkee seuraavien osioiden läpi.

GDPR (yleinen tietosuoja-asetus) koskee täysimääräisesti tekoälysovelluksia, jotka käsittelevät Euroopan asukkaiden tietoja. Itse sisällon moderointi tuottaa dataa, joka kuuluu GDPR:n soveltamisalaan. Sinun on ymmärrettävä velvoitteesi välttääksesi sakot, jotka voivat nousta jopa 4 prosenttiin maailmanlaajuisesta vuosiliikevaihdosta.

PII-luokka Mistral-moderaatiossa

Mistralin luokittelijan pii-luokka havaitsee pyynnöt henkilökohtaisten tietojen jakamiseen tai niiden paljastumisen. Yksi arkkitehtoninen seikka on tehtävä heti selväksi: tämä luokittelija on turvallisuusverkko, ei takuu. Se sieppaa erilaisia sanamuotoja, jotka säännöllinen lauseke (regex) missaisi (“numeroni on…”), mutta kuten mikä tahansa malli, sillä on vääriä negatiivisia tuloksia. Päinvastoin, säännöllinen lauseke tunnistaa luotettavasti strukturoidut muodot – IBAN-numerot, henkilötunnukset, luottokortit – mutta ei mitään muuta. Paras käytäntö yhdistää molemmat: regex tunnettuihin muotoihin ja luokittelija kaikkeen muuhun. Havaittuihin tyyppeihin kuuluvat:

  • Koko nimet
  • Osoitteet
  • Puhelinnumerot
  • Henkilötunnukset
  • Rahoitustilien tiedot

Mistralin määritelmä keskittyy pyyntöön, jakamiseen tai yritykseen hankkia tätä tunnistetietoja.

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
    }

Anonymisointi ennen käsittelyä

Ennakkoon tehtävä anonymisointi on koko tämän oppitunnin kustannustehokkain toimenpide, koska se muuttaa ongelman luonnetta: data, joka ei koskaan poistu infrastruktuuristasi, ei aiheuta siirtoongelmia. Nimien, sähköpostiosoitteiden ja numeroiden korvaaminen tunnisteilla ([PERSON_1], [EMAIL_1]) ennen mallin kutsumista säilyttää lähes aina merkityksen analyysiä varten – ja jos pidät kartoitustaulukon paikallisesti, voit injektoida todelliset arvot takaisin vastaukseen. Niin kauan kuin tämä taulukko on olemassa, kyseessä on juridisesti pseudonymisointi, ei anonymisointi: data pysyy henkilötietona, mutta mallille lähetetty data ei enää mahdollista henkilön tunnistamista itsessään.

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-vaatimustenmukaiset moderointilokit

Lokit ovat klassinen sokea piste: ajattelemme “henkilötietoja” käyttäjien viestien osalta, mutta harvoin niitä teknisiä jälkiä, jotka kopioivat niitä. Kuitenkin moderointiloki, joka säilyttää analysoidun tekstin, on henkilötietorekisteri, ja siihen sovelletaan kaikkia siitä seuraavia velvoitteita. Nyrkkisääntö: lokita tekstiä vain estetylle sisällölle – tarvitset sitä riitatilanteissa – ja lokita vain pisteytykset hyväksytylle sisällölle.

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
        ]

Tässä koodissa on kaksi varotoimenpidettä, jotka kannattaa mainita. Pseudonymisointiavaimella ei ole oletusarvoa: koodiin kirjoitettu, kaikkien tiedossa oleva avain mahdollistaisi minkä tahansa tunnisteen hashin uudelleenlaskennan. Lisäksi pseudonymisoitu data pysyy henkilötietona GDPR:n nojalla (johdanto-osan 26 kappale): tämä loki pysyy säilytysaikojen ja rekisteröityjen oikeuksien alaisena.

Tarkastusketju vaatimustenmukaisuutta varten

Tarkastusketju (audit trail) vastaa erityiseen kysymykseen, jonka käyttäjä tai viranomainen voi sinulle esittää: “Miksi tämä sisältö estettiin?” Ilman jälkeä ainoa rehellinen vastauksesi on “En enää tiedä” – mikä on kestämätöntä, sillä GDPR vaatii täysin automatisoiduista päätöksistä (22 artikla) ilmoittamaan henkilölle taustalla olevasta logiikasta (13–15 artikla), ja tekoälylaki lisää omat läpinäkyvyysvelvoitteensa. Tarkastusketju säilyttää päätöksen, sen perustelleet pisteytykset ja sovelletun käytännön version – välttämättä säilyttämättä itse tekstiä.

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

Tarkistuslista tekoälysovelluksesi GDPR-vaatimustenmukaisuuteen

Tässä ovat kohdat, jotka sinun tulee varmistaa varmistaaksesi moderaatiojärjestelmäsi vaatimustenmukaisuuden:

Oikeusperusta

  • Dokumentoitu oikeutettu etu sisällon moderointiin
  • Käyttäjän ilmoittaminen automatisoidusta käsittelystä
  • Mahdollisuus riitauttaa automatisoitu päätös

Datan minimointi

  • Säilytä vain ehdottoman välttämätön data
  • Anonymisoi tai pseudonymisoi käyttäjätunnisteet
  • Lyhennä tekstiä moderointilokeissa
  • Älä säilytä hyväksyttyjä tekstejä (vain pisteytykset)

Säilytysaika

  • Määritä säilytysaika kullekin datatyypille
  • Moderointilokit: enintään 90 päivää (ellei lakisääteinen velvoite vaadi muuta)
  • Tarkastusketju: alakohtaisen sääntelyn mukaisesti
  • Ajoitettu automaattinen tyhjennys

Käyttäjän oikeudet

  • Oikeus saada pääsy itseä koskeviin moderointipäätöksiin
  • Oikeus oikaisuun, jos päätöstä riitautetaan
  • Oikeus saada selitys automatisoidusta päätöksestä

Keskeiset asiat

  • GDPR koskee täysimääräisesti tekoälyn moderointijärjestelmiäsi
  • Käytä Mistralin pii-luokkaa JA säännöllisiä lausekkeita henkilötietojen havaitsemiseen
  • Anonymisoi tekstit ennen niiden lähettämistä mallille, kun se on mahdollista
  • Pseudonymisoi käyttäjätunnisteet lokeissa
  • Toteuta tarkastusketju päätösten jäljitettävyyden varmistamiseksi
  • Määritä säilytysaika ja tyhjennä lokit automaattisesti