Moderering og sikkerhed for visuelt indhold
På denne side
Opdateret 3. november 2026 baseret på OpenAIs guide til Image generation: En modereringsafvisning identificeres ved
error.code == "moderation_blocked"med et valgfritmoderation_details-objekt, ikke ved tilstedeværelsen af ordenesafetyellercontent_policyi fejlmeddelelsen; parameterenmoderation(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, oggpt-image-1.5,gpt-image-1-minisamtchatgpt-image-latestvil blive afviklet den 1. december 2026. Eksemplerne bruger nugpt-image-2.5-sunburst, som er mest præcis til redigering;gpt-image-2.5-flareer hurtigere til standardgenerering. Begge accepterer også kvaliteternexhighogmax. GPT Image-modeller returnerer altid billedet i base64: parameterenresponse_formatfra æ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.