Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Konformità mal-GDPR u Protezzjoni tad-Data

Lezzjoni 11 / 12 Aġġornat 3 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. L-IA u d-Data Personali: Qafas Strett
  2. Il-Kategorija PII fil-Moderazzjoni ta’ Mistral
  3. Anonimizzazzjoni Qabel l-Ipproċessar
  4. Logs ta’ Moderazzjoni Konformi mal-GDPR
  5. Traċċa tal-Awditjar għall-Konformità
  6. Lista ta’ Verifika tal-GDPR għall-Applikazzjoni tal-IA Tiegħek
  7. Punti Ewlenin

Aġġornat fit-3 ta’ Novembru 2026. Il-lista ta’ oġġetti skoperti mill-kategorija pii issa hija allinjata mad-definizzjoni ta’ Mistral (id-data dwar is-saħħa taqa’ taħt regoli differenti, u l-kategorija health timmira talbiet għal parir mediku). Il-logger konformi qabel ikkalkula ħażin id-data ta’ tmiem iż-żamma tiegħu, u kkawża li t-tħassir jħassar kollox; kien juża wkoll ċavetta tas-salting hardcoded għall-psewdonimizzazzjoni u l-funzjoni obsoleta datetime.utcnow(). Il-psewdonimizzazzjoni issa tuża HMAC-SHA-256 b’ċavetta obbligatorja. Sorsi: Moderazzjoni u Guardrailing · GDPR, Premessa 26 u l-Artikoli 4 u 22 · Python hmac.

L-IA u d-Data Personali: Qafas Strett

Hemm paradoss fil-qalba ta’ din il-lezzjoni, u li tarah b’mod ċar jevita ħafna żbalji fid-disinn: is-sistema ta’ moderazzjoni tiegħek hija hi stess operazzjoni ta’ ipproċessar ta’ data personali. Biex tipproteġi l-utenti tiegħek, tanalizza t-test tagħhom, tiġġenera punteġġi, u żżomm logs—operazzjonijiet kollha li l-GDPR jirregola eżattament bħal kwalunkwe attività oħra ta’ ipproċessar.

Għalhekk, il-konformità ma tfissirx li żżid saff ta’ protezzjoni fuq il-moderazzjoni. Tfisser li ddisinja s-sistema ta’ moderazzjoni nnifisha biex tipproċessa l-minimu ta’ data, għall-iqsar żmien possibbli, filwaqt li żżomm rekord tad-deċiżjonijiet tagħha. Dan huwa l-fil li jgħaqqad it-taqsimiet li ġejjin.

Il-GDPR (Regolament Ġenerali dwar il-Protezzjoni tad-Data) japplika bis-sħiħ għall-applikazzjonijiet tal-IA li jipproċessaw data ta’ residenti Ewropej. Il-moderazzjoni tal-kontenut hi nnifisha tiġġenera data li taqa’ fil-kamp ta’ applikazzjoni tal-GDPR. Trid tifhem l-obbligi tiegħek biex tevita penali li jistgħu jilħqu sa 4% tad-dħul annwali globali.

Il-Kategorija PII fil-Moderazzjoni ta’ Mistral

Il-kategorija pii tal-klassifikatur ta’ Mistral tiskopri talbiet għal jew żvelar ta’ informazzjoni personali. Punkt arkitettoniku wieħed irid isir immedjatament: dan il-klassifikatur huwa netwerk ta’ sigurtà, mhux garanzija. Jaqbad formulazzjonijiet varji li regex ma jaqbidx (“in-numru tiegħi huwa…”), iżda bħal kull mudell, għandu negattivi foloz. Bil-maqlub, regex jaqbad b’mod affidabbli formati strutturati—IBANs, numri tas-sigurtà soċjali, karti tal-kreditu—iżda xejn aktar. L-aħjar prattikka tgħaqqad it-tnejn: regex għal formati magħrufa, klassifikatur għall-bqija. It-tipi skoperti jinkludu:

  • Ismijiet sħaħ
  • Indirizzi
  • Numri tat-telefon
  • Numri tas-sigurtà soċjali
  • Dettalji ta’ kontijiet finanzjarji

Id-definizzjoni ta’ Mistral tiffoka fuq it-talba, il-qsim, jew it-tentattiv li tinkiseb din l-informazzjoni ta’ identifikazzjoni.

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
    }

Anonimizzazzjoni Qabel l-Ipproċessar

L-anonimizzazzjoni ‘l fuq mill-kurrent hija l-aktar miżura kost-effettiva f’din il-lezzjoni kollha għax tibdel in-natura tal-problema: data li qatt ma toħroġ mill-infrastruttura tiegħek ma tqajjem l-ebda kwistjoni ta’ trasferiment. Li tissostitwixxi ismijiet, emails, u numri b’tokens ([PERSON_1], [EMAIL_1]) qabel ma ssejjaħ il-mudell kważi dejjem iżżomm it-tifsira għall-analiżi—u jekk iżżomm it-tabella ta’ mappa lokalment, tista’ terġa’ ddaħħal il-valuri reali fir-risposta. Sakemm din it-tabella teżisti, din hija legalment psewdonimizzazzjoni, mhux anonimizzazzjoni: id-data tibqa’ personali, iżda d-data mibgħuta lill-mudell ma tippermettix l-identifikazzjoni tal-persuna waħedha.

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

Logs ta’ Moderazzjoni Konformi mal-GDPR

Il-logs huma l-punt għami klassiku: naħsbu “data personali” fir-rigward tal-messaġġi tal-utent, iżda rari fir-rigward tat-traċċi tekniċi li jikkupjawhom. Madankollu, log ta’ moderazzjoni li jżomm it-test analizzat huwa bażi tad-data personali, bl-obbligi kollha li ġejjin. Ir-regola bażika: irreġistra t-test biss għal kontenut imblukkat—ikollok bżonnu f’każ ta’ tilwima—u irreġistra biss il-punteġġi għal kontenut aċċettat.

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
        ]

Żewġ prekawzjonijiet f’dan il-kodiċi jisħqu li jissemmew. Iċ-ċavetta tal-psewdonimizzazzjoni m’għandha l-ebda valur default: ċavetta miktuba fil-kodiċi, magħrufa minn kulħadd, tippermetti li terġa’ tikkalkula l-hash ta’ kwalunkwe identifikatur. Barra minn hekk, id-data psewdonimizzata tibqa’ data personali skont il-GDPR (Premessa 26): dan il-log jibqa’ soġġett għal perjodi ta’ żamma u drittijiet tas-suġġett tad-data.

Traċċa tal-Awditjar għall-Konformità

It-traċċa tal-awditjar twieġeb mistoqsija speċifika li utent jew awtorità tista’ tistaqsik: “Għaliex dan il-kontenut ġie mblukkat?” Mingħajr traċċa, l-unika tweġiba onesta tiegħek hija “Ma nafx aktar”—li ma tinżammx meta jitqies li l-GDPR jirrikjedi, għal deċiżjonijiet kompletament awtomatizzati skont l-Artikolu 22, li tgħarraf lill-persuna dwar il-loġika sottostanti (Artikoli 13 sa 15), u l-Att dwar l-IA jżid l-obbligi ta’ trasparenza tiegħu stess. It-traċċa tal-awditjar iżżomm id-deċiżjoni, il-punteġġi li mmotivawha, u l-verżjoni tal-politika applikata—mingħajr ma neċessarjament iżżomm it-test innifsu.

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 ta’ Verifika tal-GDPR għall-Applikazzjoni tal-IA Tiegħek

Hawnhekk huma l-punti li għandek tivverifika biex tiżgura li s-sistema ta’ moderazzjoni tiegħek hija konformi:

Bażi Legali

  • Interess leġittimu ddokumentat għall-moderazzjoni tal-kontenut
  • Notifika lill-utent dwar l-ipproċessar awtomatizzat
  • Kapaċità li tiġi kkontestata deċiżjoni awtomatizzata

Minimizzazzjoni tad-Data

  • Aħżen biss data strettament meħtieġa
  • Anonimizza jew psewdonimizza identifikaturi tal-utent
  • Aqta’ t-test fil-logs ta’ moderazzjoni
  • Tżommx testi aċċettati (biss il-punteġġi)

Perjodu ta’ Żamma

  • Iddefinixxi perjodu ta’ żamma għal kull tip ta’ data
  • Logs ta’ moderazzjoni: massimu ta’ 90 jum (sakemm obbligu legali ma jirrikjedix mod ieħor)
  • Traċċa tal-awditjar: skont ir-regolament settorjali
  • Tħassir awtomatiku skedat

Drittijiet tal-Utent

  • Dritt ta’ aċċess għad-deċiżjonijiet ta’ moderazzjoni li jikkonċernawhom
  • Dritt għar-rettifika jekk id-deċiżjoni tiġi kkontestata
  • Dritt għal spjegazzjoni tad-deċiżjoni awtomatizzata

Punti Ewlenin

  • Il-GDPR japplika bis-sħiħ għas-sistemi ta’ moderazzjoni tal-IA tiegħek
  • Uża l-kategorija pii ta’ Mistral U regex biex tiskopri data personali
  • Anonimizza t-testi qabel ma tibgħathom lill-mudell meta possibbli
  • Psewdonimizza l-identifikaturi tal-utent fil-logs
  • Implimenta traċċa tal-awditjar għat-traċċabbiltà tad-deċiżjonijiet
  • Iddefinixxi perjodu ta’ żamma u ħassar il-logs awtomatikament