Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Moderatie en veiligheid van visuele inhoud

Les 12 van 12 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Moderatie en veiligheid van visuele inhoud
  2. Het ingebouwde moderatiesysteem
  3. Prompts vooraf filteren
  4. Controleer ook gegenereerde afbeeldingen
  5. Wanneer gebruikers de prompts schrijven
  6. Loggen voor verantwoordingsplicht
  7. Auteursrecht en handelsmerken
  8. Naleving van de AVG
  9. Voordat u de sluizen opent
  10. Test uw kennis

Bijgewerkt op 3 november 2026 op basis van de handleiding Image generation van OpenAI: Een weigering door moderatie wordt geïdentificeerd via error.code == "moderation_blocked", met een optioneel moderation_details-object, en niet door de aanwezigheid van de woorden safety of content_policy in het foutbericht; de parameter moderation (auto, low) is toegevoegd. Bron: Image generation.

Update 2 november 2026 — Afbeeldingsmodellen. gpt-image-1, waarop deze cursus oorspronkelijk was gebaseerd, werd stopgezet op 23 oktober 2026, en gpt-image-1.5, gpt-image-1-mini en chatgpt-image-latest worden uitgefaseerd op 1 december 2026. Voorbeelden gebruiken nu gpt-image-2.5-sunburst, het meest nauwkeurige model voor bewerkingen; gpt-image-2.5-flare is sneller voor standaardgeneratie. Beide accepteren ook de kwaliteiten xhigh en max. GPT Image-modellen retourneren de afbeelding altijd in base64: de parameter response_format van oudere DALL·E-modellen wordt niet geaccepteerd en is uit de code verwijderd. Bron: Image generation (OpenAI).

Moderatie en veiligheid van visuele inhoud

Zolang u afbeeldingen alleen voor uzelf genereert, is moderatie een kwestie van persoonlijk oordeel. Zodra u generatie voor gebruikers mogelijk maakt, wordt het een wettelijke en ethische verantwoordelijkheid die op u rust. Deze les behandelt de moderatietools van OpenAI, hoe u deze als opeenvolgende filters koppelt, en de maatregelen die zowel uw applicatie als de mensen die deze gebruiken beschermen.

Het ingebouwde moderatiesysteem

GPT Image weigert bepaalde inhoud zelfstandig—geweld, seksueel expliciet materiaal, onder andere—en signaleert deze weigering met een specifieke fout. Uw code moet daarom een weigering vanwege inhoudsbeleid onderscheiden van een technische storing, omdat deze twee omgekeerde reacties vereisen: de eerste resulteert in een bericht aan de gebruiker, de tweede in een alarm voor uw team. De documentatie van OpenAI specificeert het onderscheidingsmiddel: een weigering door moderatie komt binnen als een BadRequestError waarbij error.code gelijk is aan moderation_blocked (type image_generation_user_error), en de foutbody kan een moderation_details-object bevatten dat de fase (input, output of unknown) en algemene categorieën (harassment, sexual, violence…) specificeert. Zoek niet naar woorden in het foutbericht: de tekst is geen contract, de code wel. De onderstaande functie werpt de uitzondering alleen opnieuw op als het geen weigering door moderatie betreft.

from openai import OpenAI, BadRequestError

client = OpenAI()

def generate_with_moderation(prompt: str, output: str) -> dict:
    """Genereert een afbeelding met afhandeling van moderatieweigeringen."""
    try:
        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=prompt,
            size="1024x1024",
            quality="medium",
        )

        import base64
        data = base64.b64decode(response.data[0].b64_json)
        with open(output, "wb") as f:
            f.write(data)

        return {"status": "ok", "path": output}

    except BadRequestError as e:
        if e.code != "moderation_blocked":
            raise  # technische storing, quota, ongeldig verzoek: elders afhandelen
        body = e.body if isinstance(e.body, dict) else {}
        details = body.get("moderation_details") or {}
        return {
            "status": "refused",
            "reason": "Inhoud geweigerd door veiligheidsbeleid",
            "stage": details.get("moderation_stage"),        # input, output of unknown
            "categories": details.get("categories") or [],  # voor uw logs
        }


result = generate_with_moderation(
    "A kitten playing with a ball of yarn",
    "kitten.png"
)
print(result)

OpenAI adviseert een generiek bericht voor de eindgebruiker te hanteren en moderation_details te reserveren voor uw logs en ondersteuning. Deze fouten lossen niet op bij een nieuwe poging: zonder wijziging van de prompt of de verstrekte afbeeldingen zal hetzelfde verzoek opnieuw worden geweigerd. Merk tot slot op dat de ernst van filtering wordt ingesteld via de parameter moderation van GPT Image-modellen: auto (standaardfiltering, standaardwaarde) of low (minder restrictief).

Prompts vooraf filteren

Wachten tot GPT Image een prompt weigert voordat u ontdekt dat deze problematisch was, is onbevredigend: u hebt de API-aanroep al verbruikt en leert niets specifieks over de reden. De Moderation API is echter gratis, snel en retourneert benoemde categorieën. Deze aanroepen vóór generatie stelt u in staat schoon schip te maken, de gebruiker uit te leggen wat als problematisch is gemarkeerd, en deze informatie voor uw audit te bewaren. De functie verify_prompt haalt de lijst met geactiveerde categorieën op, en generate_safe_image koppelt eenvoudigweg de twee stappen: eerst controleren, daarna genereren.

from openai import OpenAI

client = OpenAI()

def verify_prompt(prompt: str) -> dict:
    """Controleert een prompt met de Moderation API vóór generatie."""
    moderation = client.moderations.create(
        model="omni-moderation-latest",
        input=prompt
    )

    result = moderation.results[0]

    if result.flagged:
        categories_flagged = [
            cat for cat, flagged in result.categories.__dict__.items()
            if flagged
        ]
        return {
            "allowed": False,
            "categories": categories_flagged,
            "message": "Deze prompt is gemarkeerd door het moderatiesysteem."
        }

    return {"allowed": True}


def generate_safe_image(prompt: str, output: str):
    """Volledige pipeline: moderatie + generatie."""
    # Stap 1: voorfiltering
    check = verify_prompt(prompt)

    if not check["allowed"]:
        print(f"Prompt geweigerd: {check['message']}")
        print(f"Categorieën: {check['categories']}")
        return None

    # Stap 2: generatie
    print("Prompt gevalideerd, genereren...")
    return generate_with_moderation(prompt, output)


# Test met een onschuldige prompt
generate_safe_image(
    "A mountain landscape with a crystal clear lake",
    "mountain.png"
)

Controleer ook gegenereerde afbeeldingen

Een onschuldige prompt kan leiden tot een afbeelding die dat niet is. Een omslachtige formulering, de dubbelzinnigheid van een term, of simpelweg een ongelukkige interpretatie door het model is genoeg om visuele inhoud te produceren die u niet onder uw logo wilt zien. Het model omni-moderation-latest accepteert afbeeldingen als input, waardoor u de cirkel kunt sluiten: dezelfde categoriemechanismen gelden voor het gegenereerde bestand. De onderstaande volledige pipeline koppelt de drie fasen—promptcontrole, generatie, afbeeldingscontrole—en verwijdert cruciaal gezien het bestand van de schijf bij een markering voordat het oordeel wordt teruggegeven. Een problematische afbeelding die “terwijl we kijken” op de server blijft staan, is een afbeelding die uiteindelijk zal lekken.

from openai import OpenAI
import base64

client = OpenAI()

def moderate_generated_image(image_path: str) -> dict:
    """Analyseert een gegenereerde afbeelding op problematische inhoud."""
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode()

    moderation = client.moderations.create(
        model="omni-moderation-latest",
        input=[
            {
                "type": "image_url",
                "image_url": {
                    "url": f"data:image/png;base64,{image_b64}"
                }
            }
        ]
    )

    result = moderation.results[0]

    if result.flagged:
        categories_flagged = [
            cat for cat, flagged in result.categories.__dict__.items()
            if flagged
        ]
        return {
            "safe": False,
            "categories": categories_flagged
        }

    return {"safe": True}


def secure_pipeline(prompt: str, output: str):
    """Volledige pipeline: prompt-moderatie + generatie + afbeeldingsmoderatie."""
    # 1. Controleer de prompt
    check_prompt = verify_prompt(prompt)
    if not check_prompt["allowed"]:
        return {"status": "prompt_refused", "details": check_prompt}

    # 2. Genereer de afbeelding
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1024x1024",
        quality="medium",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)

    # 3. Controleer de gegenereerde afbeelding
    check_image = moderate_generated_image(output)
    if not check_image["safe"]:
        import os
        os.remove(output)
        return {
            "status": "image_deleted",
            "reason": "Gegenereerde afbeelding was gemarkeerd",
            "categories": check_image["categories"]
        }

    return {"status": "ok", "path": output}

Wanneer gebruikers de prompts schrijven

Inhoud gegenereerd door gebruikers verandert de aard van het probleem: u hebt niet langer te maken met onhandigheid, maar soms met bewuste pogingen tot omzeiling. De klasse PromptModerator stapelt vier verdedigingslagen van verschillende aard op, wat het principe is van serieuze bescherming. Opschoning verwijdert besturingstekens waardoor injecties verlopen en beperkt de lengte tot vijfhonderd tekens, waardoor een einde komt aan flood-prompts die instructies moeten verdrinken. Lokale verificatie via een lijst met verboden woorden—leeg gelaten, in te vullen volgens uw beleid en sector—onderschept tegen nul kosten wat u al weet. De Moderation API neemt vervolgens alles over wat uw lijst niet had voorzien. Tot slot herinnert het veiligheidsvoorvoegsel dat vóór de uiteindelijke prompt wordt geplakt, het model expliciet aan het verwachte kader, waardoor de grens in uw voordeel verschuift voor randgevallen.

from openai import OpenAI
import re

client = OpenAI()

class PromptModerator:
    """Meerlagig filter voor gebruikersprompts."""

    def __init__(self):
        self.forbidden_words = []  # Vul in volgens uw beleid
        self.security_prefix = (
            "Veilige en passende afbeelding voor alle doelgroepen. "
            "Geen gewelddadige, seksuele of discriminerende inhoud. "
        )

    def clean(self, prompt: str) -> str:
        """Schoont en normaliseert een gebruikersprompt."""
        # Verwijder potentiële injecties
        prompt = prompt.strip()
        # Beperk lengte
        prompt = prompt[:500]
        # Verwijder besturingstekens
        prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
        return prompt

    def check_words(self, prompt: str) -> bool:
        """Controleert op afwezigheid van verboden woorden."""
        prompt_lower = prompt.lower()
        for word in self.forbidden_words:
            if word in prompt_lower:
                return False
        return True

    def secure(self, prompt: str) -> str:
        """Voegt een veiligheidsvoorvoegsel toe aan de prompt."""
        return f"{self.security_prefix}{prompt}"

    def pipeline(self, raw_prompt: str) -> dict:
        """Volledige moderatiepipeline voor een gebruikersprompt."""
        # Stap 1: opschoning
        prompt = self.clean(raw_prompt)

        # Stap 2: lokale verificatie
        if not self.check_words(prompt):
            return {"allowed": False, "reason": "Verboden woord gedetecteerd"}

        # Stap 3: API-moderatie
        check = verify_prompt(prompt)
        if not check["allowed"]:
            return {"allowed": False, "reason": check["message"]}

        # Stap 4: veiligheidsvoorvoegsel toevoegen
        final_prompt = self.secure(prompt)

        return {"allowed": True, "prompt": final_prompt}


moderator = PromptModerator()

# Simuleer een gebruikersprompt
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
    print(f"Veilige prompt: {result['prompt']}")
else:
    print(f"Geweigerd: {result['reason']}")

Loggen voor verantwoordingsplicht

De dag dat een problematische afbeelding weer opduikt, is de vraag die u gesteld wordt: wie heeft deze aangevraagd, wanneer, en wat heeft uw systeem gedaan. Zonder logs hebt u geen antwoord. AuditLogger schrijft één JSON-regel per generatie naar een .jsonl-bestand—een alleen-aan-te-vullen-formaat dat gelijktijdig schrijven ondersteunt en regel voor regel kan worden gelezen zonder alles in het geheugen te laden. Elke entry koppelt een gebruikers-ID aan een ingekorte prompt, de uitkomst van de generatie en, indien van toepassing, de reden voor weigering. De methode report leidt vervolgens het acceptatiepercentage af over de laatste honderd generaties en detailleert weigeringen: dit is het dashboard dat u alarmeert als een specifiek account opeenstapeling van markeringen vertoont.

import json
import os
from datetime import datetime

class AuditLogger:
    """Auditlog voor afbeeldingsgeneraties."""

    def __init__(self, log_file: str = "audit_images.jsonl"):
        self.log_file = log_file

    def log(
        self,
        prompt: str,
        user_id: str,
        result: str,
        image_path: str = None,
        refusal_reason: str = None
    ):
        """Logt een audit-entry."""
        entry = {
            "timestamp": datetime.now().isoformat(),
            "user_id": user_id,
            "prompt": prompt[:200],
            "result": result,  # "ok", "prompt_refused", "image_deleted"
            "image_path": image_path,
            "refusal_reason": refusal_reason,
        }

        with open(self.log_file, "a") as f:
            f.write(json.dumps(entry, ensure_ascii=False) + "\n")

    def report(self, last_n: int = 100):
        """Genereert een rapport van recente generaties."""
        if not os.path.exists(self.log_file):
            print("Geen logs gevonden.")
            return

        entries = []
        with open(self.log_file, "r") as f:
            for line in f:
                entries.append(json.loads(line))

        recent = entries[-last_n:]

        total = len(recent)
        ok = sum(1 for e in recent if e["result"] == "ok")
        refused = sum(1 for e in recent if e["result"] != "ok")

        print(f"Rapport van laatste {total} generaties:")
        print(f"  Geaccepteerd: {ok} ({100*ok/total:.1f}%)")
        print(f"  Geweigerd   : {refused} ({100*refused/total:.1f}%)")

        if refused > 0:
            print(f"\nDetails weigeringen:")
            for e in recent:
                if e["result"] != "ok":
                    print(f"  [{e['timestamp'][:10]}] {e['user_id']} : {e['refusal_reason']}")


logger = AuditLogger()
logger.report()

Auteursrecht en handelsmerken

GPT Image weet afbeeldingen te produceren die de stijl van een kunstenaar of de visuele identiteit van een merk evoceren, en precies deze capability stelt u bloot. Technische moderatie beschermt u hier niet tegen: deze detecteert niet dat een poster erg veel lijkt op die van een concurrent. Bescherming is daarom contractueel en organisatorisch, in de vorm van een schriftelijk, afdwingbaar gebruiksbeleid dat uw gebruikers accepteren en uw team toepast. Het blok PRODUCTION_RULES geeft de minimale formulering, weer te geven in uw documentatie en te herhalen in uw voorwaarden.

# Best practices om op te nemen in uw gebruiksbeleid

PRODUCTION_RULES = """
1. Vraag niet om imitatie van de stijl van een levende kunstenaar bij naam
2. Reproduceer geen logo's of geregistreerde handelsmerken
3. Genereer geen gezichten van bestaande personen
4. Voeg een melding "AI-gegenereerde afbeelding" toe wanneer vereist
5. Bewaar generatielogs minimaal 12 maanden
6. Sta gebruikers toe problematische inhoud te melden
"""

def usage_warning():
    """Toont regels voor productiegebruik."""
    print("=" * 60)
    print("PRODUCTIEREGELS — AI Afbeeldingsgeneratie")
    print("=" * 60)
    print(PRODUCTION_RULES)

Naleving van de AVG

Voor een Europees bedrijf zijn bewaartermijnen en toestemming geen configuratieopties maar verplichtingen waarvan de naleving aantoonbaar moet zijn. Deze vastleggen in een expliciet configuratieobject, in plaats van ze door de code te verspreiden, geeft u één plek om tijdens een audit te tonen. ComplianceConfig stelt zo de logbewaring in op één jaar, afbeeldingsbewaring op negentig dagen, en maakt de AI-melding en toestemming verplicht. De methode add_ai_metadata verdient speciale aandacht: deze schrijft via PngInfo direct in de PNG dat de afbeelding gegenereerd is, met welk tool deze is gemaakt en op welke datum. Deze metadata reizen mee met het bestand, ook buiten uw platform, wat geen enkele melding op een webpagina doet.

class ComplianceConfig:
    """Compliance-configuratie voor afbeeldingsgeneratie."""

    def __init__(self):
        self.log_retention_days = 365
        self.image_retention_days = 90
        self.ai_notice_mandatory = True
        self.consent_required = True

    def verify_consent(self, user_id: str) -> bool:
        """Verifieert dat de gebruiker toestemming heeft gegeven voor AI-generatie."""
        # Implementeer met uw toestemmingsbeheersysteem
        return True

    def add_ai_metadata(self, image_path: str):
        """Voegt metadata toe die AI-generatie aangeven."""
        from PIL import Image
        from PIL.PngImagePlugin import PngInfo

        img = Image.open(image_path)
        metadata = PngInfo()
        metadata.add_text("AI-Generated", "true")
        metadata.add_text("Generator", "GPT Image via OpenAI API")
        metadata.add_text("Date", datetime.now().isoformat())
        img.save(image_path, pnginfo=metadata)
        print(f"AI-metadata toegevoegd: {image_path}")

Voordat u de sluizen opent

Acht bepalingen moeten op hun plaats zijn de dag dat uw systeem toegankelijk wordt, en het is eerlijker deze vooraf te vragen dan achteraf. Moderatie eerst, in zijn twee fasen: prompts vooraf filteren en afbeeldingen achteraf verifiëren, zoals secure_pipeline doet. Daarna loggen, compleet, waarbij elke generatie gekoppeld wordt aan zijn prompt, auteur en uitkomst—dit is uw enige bewijs bij geschillen, en het moet onafhankelijk van de afbeeldingen zelf worden bewaard, anders neemt een opslagopschoning uw traceerbaarheid mee.

Dan komt de gebruikerskant. Een snelheidslimiet per account voorkomt dat één abonnee uw maandbudget in één nacht opmaakt, vrijwillig of via een slecht geschreven script. Informatie over het gegenereerde karakter van afbeeldingen heeft te maken met zowel eerlijkheid als, steeds vaker, regelgeving; dit wordt verdubbeld door technische markering in de PNG- of EXIF-metadata van het bestand. Het recht op wissen veronderstelt dat u op eenvoudig verzoek alle gegevens van een gebruiker kunt vinden en verwijderen, wat alleen mogelijk is als uw audit-entries een user_id bevatten. Open tot slot een meldkanaal: uw gebruikers zullen altijd eerder zien wat problematisch is dan u, en het wegnemen van hun middelen om u dit te vertellen, laat het probleem niet verdwijnen.

Voeg nu het geheel samen tot één dienst voor afbeeldingsgeneratie: prompts vooraf filteren via Moderation API en woordenlijst, veiligheidsvoorvoegsel, achteraf-controle van de geproduceerde afbeelding, auditlog, en AI-metadata op elk bestand. Test dit met vijf gevarieerde prompts, waarvan er minstens één geweigerd moet worden—dit is de enige manier om te verifiëren dat uw veiligheidsmaatregelen daadwerkelijk werken en niet alleen in de code staan.

Test uw kennis

Visuele generatie via API: valideer reflexen vóór productie.

1. Wat maken inpainting en outpainting mogelijk?

Antwoord: Inpainting wijzigt een specifiek gebied van een bestaande afbeelding (vervangen, corrigeren); outpainting breidt de afbeelding uit buiten het oorspronkelijke kader—twee gerichte bewerkingen zonder alles opnieuw te genereren.

2. Wat maakt een goede geavanceerde visuele prompt?

Antwoord: Beschrijf onderwerp, compositie, belichting en perspectief—niet alleen het thema: hoe meer de prompt de scène kadert als een director of photography, hoe meer de afbeelding gehoorzaamt.

3. Hoe werkt u effectief via iteraties?

Antwoord: Begin met een basisgeneratie en vraag vervolgens gerichte variaties (stijl, kader, detail) in plaats van de prompt helemaal opnieuw te schrijven—houd wat werkt, tweak alleen het verschil.

4. Welke hefbomen optimaliseren generatiekosten?

Antwoord: Pas kwaliteit en resolutie aan aan de reële behoefte (concepten in laag, finals in hoog), beperk iteraties met betere prompts, en cache/hergebruik gevalideerde visuals.

5. Waarom is moderatie van visuele inhoud essentieel?

Antwoord: Omdat de API en uw voorwaarden limieten opleggen (verboden inhoud, bestaande personen, merken): het filteren van prompts en controleren van outputs beschermt uw gebruikers en uw applicatie.

Kader, iteratie, beheersing van kosten en compliance: visuele productie is een pipeline—geen dobbelsteenworp.