Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Moderering og sikkerhed for visuelt indhold

Lektion 12 af 12 Opdateret 3. november 2026 Udvikler
På denne side
  1. Moderering og sikkerhed for visuelt indhold
  2. Det indbyggede modereringssystem
  3. Forud-filtrering af prompts
  4. Tjek også genererede billeder
  5. Når brugere skriver prompts
  6. Logning for ansvarlighed
  7. Ophavsret og varemærker
  8. Overholdelse af GDPR
  9. Før du åbner sluserne
  10. Test din viden

Opdateret 3. november 2026 baseret på OpenAIs guide til Image generation: En modereringsafvisning identificeres ved error.code == "moderation_blocked" med et valgfrit moderation_details-objekt, ikke ved tilstedeværelsen af ordene safety eller content_policy i fejlmeddelelsen; parameteren moderation (auto, low) er tilføjet. Kilde: Image generation.

Opdatering 2. november 2026 — Billedmodeller. gpt-image-1, som dette kursus oprindeligt blev skrevet om, blev afviklet den 23. oktober 2026, og gpt-image-1.5, gpt-image-1-mini samt chatgpt-image-latest vil blive afviklet den 1. december 2026. Eksemplerne bruger nu gpt-image-2.5-sunburst, som er mest præcis til redigering; gpt-image-2.5-flare er hurtigere til standardgenerering. Begge accepterer også kvaliteterne xhigh og max. GPT Image-modeller returnerer altid billedet i base64: parameteren response_format fra ældre DALL·E-modeller accepteres ikke og er fjernet fra koden. Kilde: Image generation (OpenAI).

Moderering og sikkerhed for visuelt indhold

Så længe du genererer billeder til dig selv, er moderering et spørgsmål om personlig dømmekraft. Når du åbner genereringen for brugere, bliver det et juridisk og etisk ansvar, der binder dig. Denne lektion dækker OpenAIs modereringsværktøjer, hvordan du kæder dem sammen i successive filtre, og de foranstaltninger, der beskytter både din applikation og de mennesker, der bruger den.

Det indbyggede modereringssystem

GPT Image afviser selv visse typer indhold – vold, seksuelt eksplicit materiale og andet – og signalerer denne afvisning med en specifik fejl. Din kode skal derfor kunne skelne mellem en afvisning baseret på indholdsretningslinjer og en teknisk fejl, da de to kræver modsatrettede reaktioner: den første resulterer i en besked til brugeren, den anden i en alarm til dit team. OpenAIs dokumentation specificerer diskriminatoren, der skal bruges: en modereringsafvisning ankommer som en BadRequestError, hvor error.code er lig med moderation_blocked (type image_generation_user_error), og fejlens body kan indeholde et moderation_details-objekt, der specificerer fasen (input, output eller unknown) samt generelle kategorier (harassment, sexual, violence…). Led ikke efter ord i fejlmeddelelsen: teksten er ikke en kontrakt, koden er. Funktionen nedenfor gen-kaster kun undtagelsen, hvis det ikke er en modereringsafvisning.

from openai import OpenAI, BadRequestError

client = OpenAI()

def generate_with_moderation(prompt: str, output: str) -> dict:
    """Genererer et billede under håndtering af modereringsafvisninger."""
    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  # teknisk fejl, kvote, ugyldig anmodning: håndteres andetsteds
        body = e.body if isinstance(e.body, dict) else {}
        details = body.get("moderation_details") or {}
        return {
            "status": "refused",
            "reason": "Indhold afvist af sikkerhedspolitik",
            "stage": details.get("moderation_stage"),        # input, output eller unknown
            "categories": details.get("categories") or [],  # til dine logs
        }


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

OpenAI anbefaler at bruge en generisk besked til slutbrugeren og reservere moderation_details til dine logs og support. Disse fejl løses ikke ved genforsøg: uden at ændre prompten eller de leverede billeder, vil den samme anmodning blive afvist igen. Bemærk endelig, at filtreringsstyrken indstilles via parameteren moderation hos GPT Image-modellerne: auto (standardfiltrering, standardværdi) eller low (mindre restriktiv).

Forud-filtrering af prompts

At vente på, at GPT Image afviser en prompt, før du opdager, at den var problematisk, er utilfredsstillende: du har allerede brugt API-kaldet, og du lærer intet specifikt om årsagen. Modererings-API’et er derimod gratis, hurtigt og returnerer navngivne kategorier. Ved at kalde det før generering kan du afvise rent, forklare brugeren, hvad der blev flagget, og gemme disse oplysninger til din revision. Funktionen verify_prompt udtrækker listen over udløste kategorier, og generate_safe_image kæder blot de to trin sammen: tjek først, generér derefter.

from openai import OpenAI

client = OpenAI()

def verify_prompt(prompt: str) -> dict:
    """Tjekker en prompt med Moderations-API'et før generering."""
    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": "Denne prompt blev flagget af modereringssystemet."
        }

    return {"allowed": True}


def generate_safe_image(prompt: str, output: str):
    """Komplet pipeline: moderering + generering."""
    # Trin 1: Forud-filtrering
    check = verify_prompt(prompt)

    if not check["allowed"]:
        print(f"Prompt afvist: {check['message']}")
        print(f"Kategorier: {check['categories']}")
        return None

    # Trin 2: Generering
    print("Prompt valideret, genererer...")
    return generate_with_moderation(prompt, output)


# Test med en uskadelig prompt
generate_safe_image(
    "A mountain landscape with a crystal clear lake",
    "mountain.png"
)

Tjek også genererede billeder

En uskyldig prompt kan give et billede, der ikke er det. En omskrivning, tvetydigheden i et begreb eller blot en uheldig fortolkning fra modellen er nok til at producere visuelt indhold, du ikke ønsker vist under dit logo. Modellen omni-moderation-latest accepterer billeder som input, hvilket giver dig mulighed for at lukke sløjfen: de samme kategorimekanismer gælder for den genererede fil. Den komplette pipeline nedenfor kæder de tre faser sammen – prompt-tjek, generering, billedtjek – og vigtigst af alt: i tilfælde af et flag slettes filen fra disken, før dommen returneres. Et problematisk billede, der ligger på serveren, „mens vi kigger”, er et billede, der før eller siden vil lække.

from openai import OpenAI
import base64

client = OpenAI()

def moderate_generated_image(image_path: str) -> dict:
    """Analyserer et genereret billede for at opdage problematisk indhold."""
    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):
    """Komplet pipeline: prompt-moderering + generering + billed-moderering."""
    # 1. Tjek prompten
    check_prompt = verify_prompt(prompt)
    if not check_prompt["allowed"]:
        return {"status": "prompt_refused", "details": check_prompt}

    # 2. Generér billedet
    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. Tjek det genererede billede
    check_image = moderate_generated_image(output)
    if not check_image["safe"]:
        import os
        os.remove(output)
        return {
            "status": "image_deleted",
            "reason": "Genereret billede blev flagget",
            "categories": check_image["categories"]
        }

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

Når brugere skriver prompts

Brugergenereret indhold ændrer problemets natur: du står ikke længere over for klodsethed, men til tider bevidste forsøg på omgåelse. Klassen PromptModerator stabler fire forsvar af forskellig art, hvilket er selve princippet for seriøs beskyttelse. Rensning fjerner kontroltegn, hvorigennem injektioner transporteres, og begrænser længden til fem hundrede tegn, hvilket sætter en stopper for flood-prompts designet til at drukne instruktioner. Lokal verifikation via en liste over forbudte ord – efterladt tom, så du kan udfylde den efter din politik og sektor – opfanger til nul omkostninger det, du allerede kender. Modererings-API’et tager derefter over for alt det, din liste ikke forudså. Endelig minder sikkerhedspræfikset, der sammenkædes før den endelige prompt, eksplicit modellen om det forventede framework, hvilket flytter grænsen i din favør i grænsetilfælde.

from openai import OpenAI
import re

client = OpenAI()

class PromptModerator:
    """Flerlags filter til bruger-prompts."""

    def __init__(self):
        self.forbidden_words = []  # Udfyld efter din politik
        self.security_prefix = (
            "Sikkert og passende billede for alle målgrupper. "
            "Intet voldeligt, seksuelt eller diskriminerende indhold. "
        )

    def clean(self, prompt: str) -> str:
        """Renser og normaliserer en bruger-prompt."""
        # Fjern potentielle injektioner
        prompt = prompt.strip()
        # Begræns længden
        prompt = prompt[:500]
        # Fjern kontroltegn
        prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
        return prompt

    def check_words(self, prompt: str) -> bool:
        """Tjekker for fravær af forbudte ord."""
        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:
        """Tilføjer et sikkerhedspræfiks til prompten."""
        return f"{self.security_prefix}{prompt}"

    def pipeline(self, raw_prompt: str) -> dict:
        """Komplet modereringspipeline for en bruger-prompt."""
        # Trin 1: Rensning
        prompt = self.clean(raw_prompt)

        # Trin 2: Lokal verifikation
        if not self.check_words(prompt):
            return {"allowed": False, "reason": "Forbudt ord opdaget"}

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

        # Trin 4: Tilføj sikkerhedspræfiks
        final_prompt = self.secure(prompt)

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


moderator = PromptModerator()

# Simulér en bruger-prompt
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
    print(f"Sikker prompt: {result['prompt']}")
else:
    print(f"Afvist: {result['reason']}")

Logning for ansvarlighed

Den dag et problematisk billede dukker op igen, vil spørgsmålet, du bliver stillet, være: hvem anmodede om det, hvornår, og hvad gjorde dit system? Uden logs har du intet svar. AuditLogger skriver én JSON-linje pr. generering til en .jsonl-fil – et format, der kun tillader tilføjelse (append-only), understøtter samtidig skrivning og kan læses linje for linje uden at indlæse alt i hukommelsen. Hver post linker et bruger-ID til en trunkeret prompt, genereringsresultatet og, hvis relevant, årsagen til afvisning. Metoden report udleder derefter acceptfrekvensen over de sidste hundrede genereringer og detaljerer afvisninger: dette er dashboardet, der vil advare dig, hvis en bestemt konto ophober flag.

import json
import os
from datetime import datetime

class AuditLogger:
    """Revisionslog for billedgenereringer."""

    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
    ):
        """Logger en revisionspost."""
        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):
        """Genererer en rapport over seneste genereringer."""
        if not os.path.exists(self.log_file):
            print("Ingen logs fundet.")
            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 over sidste {total} genereringer:")
        print(f"  Accepteret: {ok} ({100*ok/total:.1f}%)")
        print(f"  Afvist    : {refused} ({100*refused/total:.1f}%)")

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


logger = AuditLogger()
logger.report()

Ophavsret og varemærker

GPT Image kan producere billeder, der minder om en kunstners stil eller en brands visuelle identitet, og netop denne evne er det, der udsætter dig. Teknisk moderering beskytter dig ikke på dette område: den opdager ikke, at en plakat ligner en konkurrents meget. Beskyttelsen er derfor kontraktuel og organisatorisk i form af en skriftlig, håndhævelig brugspolitik, som dine brugere accepterer, og dit team anvender. Blokken PRODUCTION_RULES giver den minimale formulering, som skal vises i din dokumentation samt gentages i dine vilkår.

# Bedste praksis til integration i din brugspolitik

PRODUCTION_RULES = """
1. Anmod ikke om efterligning af en levende kunstners stil ved navn
2. Reproducer ikke logoer eller registrerede varemærker
3. Generer ikke ansigter på rigtige mennesker
4. Tilføj en meddelelse om „AI-genereret billede", når det kræves
5. Opbevar genereringslogs i mindst 12 måneder
6. Tillad brugere at rapportere problematisk indhold
"""

def usage_warning():
    """Viser regler for produktionsbrug."""
    print("=" * 60)
    print("PRODUKTIONSREGLER — AI-billedgenerering")
    print("=" * 60)
    print(PRODUCTION_RULES)

Overholdelse af GDPR

For en europæisk virksomhed er opbevaringsperioder og samtykke ikke konfigurationsmuligheder, men forpligtelser, hvis overholdelse skal kunne påvises. Ved at registrere dem i et eksplicit konfigurationsobjekt i stedet for at sprede dem gennem koden, får du ét sted at vise frem under en revision. ComplianceConfig sætter dermed log-opbevaring til ét år, billed-opbevaring til halvfems dage og gør AI-meddelelsen samt samtykke obligatorisk. Metoden add_ai_metadata fortjener særlig opmærksomhed: den skriver direkte ind i PNG-filen via PngInfo, at billedet er genereret, hvilket værktøj der producerede det, og datoen. Disse metadata rejser med filen, også uden for din platform, hvilket ingen meddelelse vist på en webside gør.

class ComplianceConfig:
    """Overholdelseskonfiguration for billedgenerering."""

    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:
        """Verificerer, at brugeren har givet samtykke til AI-generering."""
        # Implementér med dit system til håndtering af samtykke
        return True

    def add_ai_metadata(self, image_path: str):
        """Tilføjer metadata, der indikerer AI-generering."""
        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 tilføjet: {image_path}")

Før du åbner sluserne

Otte bestemmelser skal være på plads den dag, dit system bliver tilgængeligt, og det er mere ærligt at stille kravene før snarere end efter. Moderering først, i sine to faser: forud-filtrering af prompts og efter-verificering af billeder, som secure_pipeline gør. Derefter logning, komplet, der forbinder hver generering med dens prompt, forfatter og resultat – dette er dit eneste bevis i tilfælde af tvist, og det skal gemmes uafhængigt af selve billederne, ellers vil en oprydning af lageret også fjerne din sporbarhed.

Derefter kommer brugersiden. En hastighedsbegrænsning (rate limit) pr. konto forhindrer, at en enkelt abonnent bruger dit månedlige budget på én nat, будь det frivilligt eller via et dårligt skrevet script. Information om billeders genererede natur vedrører både fair play og, i stigende grad, regulatoriske krav; det dobbeltspores af teknisk mærkning i filens PNG- eller EXIF-metadata. Retten til sletning forudsætter, at du kan finde og slette alle en brugers data på simpel anmodning, hvilket kun er muligt, hvis dine revisionsposter bærer et user_id. Åbn endelig en rapporteringskanal: dine brugere vil altid se det problematiske før dig, og at tage deres mulighed for at fortælle dig det fra, får ikke problemet til at forsvinde.

Saml nu det hele i én enkelt tjeneste til billedgenerering: forud-filtrering af prompts via Moderations-API og ordliste, sikkerhedspræfiks, efter-verificering af det producerede billede, revisionslog og AI-metadata på hver fil. Test det med fem varierede prompts, hvoraf mindst én skal afvises – dette er den eneste måde at verificere, at dine værn faktisk virker, i stedet for blot at være til stede i koden.

Test din viden

Visuel generering via API: valider reflekser før produktion.

1. Hvad muliggør inpainting og outpainting?

Svar: Inpainting modificerer et specifikt område af et eksisterende billede (erstat, ret); outpainting udvider billedet ud over dets oprindelige ramme – to målrettede redigeringer uden at regenerere alt.

2. Hvad kendetegner en god avanceret visuel prompt?

Svar: Beskriv motiv, komposition, belysning og perspektiv – ikke bare temaet: jo mere prompten rammer scenen som en filmfotograf, jo mere adlyder billedet.

3. Hvordan arbejder man effektivt med iterationer?

Svar: Start med en basisgenerering, og anmod derefter om målrettede variationer (stil, indramning, detalje) i stedet for at omskrive prompten fra bunden – behold det, der virker, og justér kun afstanden.

4. Hvilke løftestænger optimerer genereringsomkostninger?

Svar: Tilpas kvalitet og opløsning til det reelle behov (kladder i lav, finaler i høj), begræns iterationer med bedre prompts, og cache/genbrug validerede visuals.

5. Hvorfor er moderering af visuelt indhold essentiel?

Svar: Fordi API’et og dine vilkår pålægger grænser (forbudt indhold, rigtige mennesker, brands): filtrering af prompts og kontrol af outputs beskytter dine brugere og din applikation.

Ram ind, iterér, mestér omkostninger og overholdelse: visuel produktion er en pipeline – ikke et terningkast.