Moderering och säkerhet för visuellt innehåll
På denna sida
Uppdaterad 3 november 2026 baserat på OpenAI:s guide Image generation: Ett modereringsavslag identifieras genom
error.code == "moderation_blocked", med ett valfrittmoderation_details-objekt, inte genom förekomsten av ordensafetyellercontent_policyi felmeddelandet; parameternmoderation(auto,low) har lagts till. Källa: Image generation.
Uppdatering 2 november 2026 — Bildmodeller.
gpt-image-1, som denna kurs ursprungligen skrevs för, lades ner den 23 oktober 2026, ochgpt-image-1.5,gpt-image-1-minisamtchatgpt-image-latestkommer att tas ur bruk den 1 december 2026. Exemplen använder nugpt-image-2.5-sunburst, den mest precisa för redigering;gpt-image-2.5-flareär snabbare för standardgenerering. Båda accepterar även kvaliteternaxhighochmax. GPT Image-modeller returnerar alltid bilden i base64: parameternresponse_formatfrån äldre DALL·E-modeller accepteras inte och har tagits bort från koden. Källa: Image generation (OpenAI).
Moderering och säkerhet för visuellt innehåll
Så länge du genererar bilder för eget bruk är moderering en fråga om personligt omdöme. Så snart du öppnar genereringen för användare blir det ett juridiskt och etiskt ansvar som binder dig. Denna lektion täcker OpenAI:s modereringsverktyg, hur du kedjar dem till successiva filter, och de åtgärder som skyddar både din applikation och de människor som använder den.
Det inbyggda modereringssystemet
GPT Image vägrar självmant visst innehåll – våld, sexuellt explicit material med mera – och signalerar detta vägran med ett specifikt fel. Din kod måste därför skilja på ett avslag grundat på innehållspolicy och ett tekniskt fel, eftersom de två kräver motsatta reaktioner: det förra resulterar i ett meddelande till användaren, det senare i en varning till ditt team. OpenAI:s dokumentation specificerar diskriminatorn att använda: ett modereringsavslag anländer som ett BadRequestError där error.code är lika med moderation_blocked (typ image_generation_user_error), och felkroppen kan innehålla ett moderation_details-objekt som specificerar steget (input, output eller unknown) samt allmänna kategorier (harassment, sexual, violence…). Sök inte efter ord i felmeddelandet: dess text är inte ett kontrakt, koden är det. Funktionen nedan kastar om undantaget endast om det inte rör sig om ett modereringsavslag.
from openai import OpenAI, BadRequestError
client = OpenAI()
def generate_with_moderation(prompt: str, output: str) -> dict:
"""Genererar en bild medan modereringsavslag hanteras."""
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 # tekniskt fel, kvot, ogiltig förfrågan: hanteras elsewhere
body = e.body if isinstance(e.body, dict) else {}
details = body.get("moderation_details") or {}
return {
"status": "refused",
"reason": "Innehåll vägrat enligt säkerhetspolicy",
"stage": details.get("moderation_stage"), # input, output eller unknown
"categories": details.get("categories") or [], # för dina loggar
}
result = generate_with_moderation(
"A kitten playing with a ball of yarn",
"kitten.png"
)
print(result)
OpenAI rekommenderar att du behåller ett generiskt meddelande för slutanvändaren och reserverar moderation_details för dina loggar och support. Dessa fel löses inte vid försök att upprepa: utan att ändra prompten eller de tillhandahållna bilderna kommer samma förfrågan att vägras igen. Notera slutligen att filtreringens svårighetsgrad ställs in via parametern moderation hos GPT Image-modeller: auto (standardfiltrering, default) eller low (mindre restriktiv).
Förfiltrering av prompter
Att vänta på att GPT Image ska vägra en prompt innan du upptäcker att den var problematisk är otillfredsställande: du har redan förbrukat API-anropet, och du lär dig inget specifikt om orsaken. Modererings-API:t är dock gratis, snabbt och returnerar namngivna kategorier. Att anropa det före generering låter dig vägra rent, förklara för användaren vad som flaggades, och behålla denna information för din revision. Funktionen verify_prompt extraherar listan över utlösta kategorier, och generate_safe_image kedjar helt enkelt ihop de två stegen: kontrollera först, generera sedan.
from openai import OpenAI
client = OpenAI()
def verify_prompt(prompt: str) -> dict:
"""Kontrollerar en prompt med Moderations-API:t före 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": "Denna prompt flaggades av modereringssystemet."
}
return {"allowed": True}
def generate_safe_image(prompt: str, output: str):
"""Komplett pipeline: moderering + generering."""
# Steg 1: förfiltrering
check = verify_prompt(prompt)
if not check["allowed"]:
print(f"Prompt vägrad: {check['message']}")
print(f"Kategorier: {check['categories']}")
return None
# Steg 2: generering
print("Prompt validerad, genererar...")
return generate_with_moderation(prompt, output)
# Testa med en ofarlig prompt
generate_safe_image(
"A mountain landscape with a crystal clear lake",
"mountain.png"
)
Kontrollera även genererade bilder
En oskyldig prompt kan ge upphov till en bild som inte är det. En omskrivning, tvetydigheten hos ett begrepp, eller helt enkelt en olycklig modelltolkning räcker för att producera visuellt innehåll som du inte vill se visas under din logotyp. Modellen omni-moderation-latest accepterar bilder som indata, vilket låter dig sluta loopen: samma kategorimekanik gäller för den genererade filen. Den kompletta pipelinen nedan kedjar ihop de tre faserna – promptkontroll, generering, bildkontroll – och avgörande nog, vid en flaggning, raderas filen från disken innan domen returneras. En problematisk bild som lämnas kvar på servern “medan vi tittar” är en bild som så småningom kommer att läcka.
from openai import OpenAI
import base64
client = OpenAI()
def moderate_generated_image(image_path: str) -> dict:
"""Analyserar en genererad bild för att upptäcka problematiskt innehåll."""
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):
"""Komplett pipeline: prompt-moderering + generering + bild-moderering."""
# 1. Kontrollera prompten
check_prompt = verify_prompt(prompt)
if not check_prompt["allowed"]:
return {"status": "prompt_refused", "details": check_prompt}
# 2. Generera bilden
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. Kontrollera den genererade bilden
check_image = moderate_generated_image(output)
if not check_image["safe"]:
import os
os.remove(output)
return {
"status": "image_deleted",
"reason": "Genererad bild flaggades",
"categories": check_image["categories"]
}
return {"status": "ok", "path": output}
När användare skriver prompterna
Användargenererat innehåll ändrar problemets natur: du står inte längre inför klumpighet utan ibland medvetna försök till kringgående. Klassen PromptModerator staplar fyra försvar av olika slag, vilket är själva principen för seriöst skydd. Rengöring tar bort kontrolltecken genom vilka injektioner transporteras och capar längden till femhundra tecken, vilket sätter stopp för flödesprompter designade för att dränka instruktioner. Lokal verifiering via en lista över förbjudna ord – lämnad tom, att fyllas enligt din policy och sektor – fångar upp vid nollkostnad det du redan vet. Modererings-API:t tar sedan över för allt som din lista inte förutsett. Slutligen påminner säkerhetsprefixet som konkateneras före den slutliga prompten explicit modellen om det förväntade ramverket, vilket flyttar gränsen till din fördel vid gränsfall.
from openai import OpenAI
import re
client = OpenAI()
class PromptModerator:
"""Flerskiktsfilter för användarprompter."""
def __init__(self):
self.forbidden_words = [] # Fyll enligt din policy
self.security_prefix = (
"Säker och lämplig bild för alla åldrar. "
"Inget våldsamt, sexuellt eller diskriminerande innehåll. "
)
def clean(self, prompt: str) -> str:
"""Rengör och normaliserar en användarprompt."""
# Ta bort potentiella injektioner
prompt = prompt.strip()
# Begränsa längd
prompt = prompt[:500]
# Ta bort kontrolltecken
prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
return prompt
def check_words(self, prompt: str) -> bool:
"""Kontrollerar frånvaro av förbjudna 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:
"""Lägger till ett säkerhetsprefix i prompten."""
return f"{self.security_prefix}{prompt}"
def pipeline(self, raw_prompt: str) -> dict:
"""Komplett modereringspipeline för en användarprompt."""
# Steg 1: rengöring
prompt = self.clean(raw_prompt)
# Steg 2: lokal verifiering
if not self.check_words(prompt):
return {"allowed": False, "reason": "Förbjudet ord upptäckt"}
# Steg 3: API-moderering
check = verify_prompt(prompt)
if not check["allowed"]:
return {"allowed": False, "reason": check["message"]}
# Steg 4: lägg till säkerhetsprefix
final_prompt = self.secure(prompt)
return {"allowed": True, "prompt": final_prompt}
moderator = PromptModerator()
# Simulera en användarprompt
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
print(f"Säker prompt: {result['prompt']}")
else:
print(f"Vägrad: {result['reason']}")
Loggning för ansvarsutkrävande
Den dag en problematisk bild dyker upp igen är frågan du kommer att få: vem begärde den, när, och vad gjorde ditt system? Utan loggar har du inget svar. AuditLogger skriver en JSON-rad per generering till en .jsonl-fil – ett format som endast tillåter tillägg, stöder samtidig skrivning och kan läsas rad för rad utan att ladda allt i minnet. Varje post länkar ett användar-ID till en trunkerad prompt, genereringsresultatet och, i förekommande fall, orsaken till avslag. Metoden report härleder sedan acceptansgraden över de senaste hundra genereringarna och detaljerar avslagen: detta är den instrumentpanel som varnar dig om ett särskilt konto ackumulerar flaggningar.
import json
import os
from datetime import datetime
class AuditLogger:
"""Granskningslogg för bildgenereringar."""
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
):
"""Loggar en granskningspost."""
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):
"""Genererar en rapport över senaste genereringarna."""
if not os.path.exists(self.log_file):
print("Inga loggar hittades.")
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 över senaste {total} genereringar:")
print(f" Accepterade: {ok} ({100*ok/total:.1f}%)")
print(f" Vägrade : {refused} ({100*refused/total:.1f}%)")
if refused > 0:
print(f"\nDetaljer om vägran:")
for e in recent:
if e["result"] != "ok":
print(f" [{e['timestamp'][:10]}] {e['user_id']} : {e['refusal_reason']}")
logger = AuditLogger()
logger.report()
Upphovsrätt och varumärken
GPT Image kan producera bilder som efterliknar en konstnärs stil eller ett varumärkes visuella identitet, och det är just denna förmåga som exponerar dig. Teknisk moderering skyddar dig inte på denna grund: den upptäcker inte att en affisch liknar en konkurrents alltför mycket. Skyddet är därför avtalsmässigt och organisatoriskt, i form av en skriven, verkställbar användningspolicy som dina användare accepterar och ditt team tillämpar. Blocket PRODUCTION_RULES ger den minimala formuleringen, att visas i din dokumentation såväl som påminnas om i dina villkor.
# Bästa praxis att integrera i din användningspolicy
PRODUCTION_RULES = """
1. Begär inte efterliknande av en levande konstnärs stil vid namn
2. Reproducer inte logotyper eller registrerade varumärken
3. Generera inte ansikten på verkliga personer
4. Lägg till en notis "AI-genererad bild" när så krävs
5. Behåll genereringsloggar i minst 12 månader
6. Tillåt användare att rapportera problematiskt innehåll
"""
def usage_warning():
"""Visar regler för produktionsanvändning."""
print("=" * 60)
print("PRODUKTIONSREGLER — AI-bildgenerering")
print("=" * 60)
print(PRODUCTION_RULES)
Efterlevnad av GDPR
För ett europeiskt företag är lagringstider och samtycke inte konfigurationsalternativ utan skyldigheter vars efterlevnad måste kunna bevisas. Att registrera dem i ett explicit konfigurationsobjekt, snarare än att sprida dem genom koden, ger dig en enda plats att visa upp vid en revision. ComplianceConfig sätter därmed loggbehållning till ett år, bildbehållning till nittio dagar, och gör AI-notisen samt samtycke obligatoriska. Metoden add_ai_metadata förtjänar särskild uppmärksamhet: den skriver in i själva PNG-filen, via PngInfo, att bilden är genererad, verktyget som producerade den, och datumet. Dessa metadata färdas med filen, även utanför din plattform, vilket ingen notis visad på en webbsida gör.
class ComplianceConfig:
"""Efterlevnadskonfiguration för bildgenerering."""
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:
"""Verifierar att användaren har samtyckt till AI-generering."""
# Implementera med ditt system för hantering av samtycke
return True
def add_ai_metadata(self, image_path: str):
"""Lägger till metadata som indikerar 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 tillagd: {image_path}")
Innan du öppnar slussarna
Åtta bestämmelser måste vara på plats den dag ditt system blir tillgängligt, och det är mer ärligt att ställa dem innan snarare än efter. Moderering först, i sina två faser: förfiltrering av prompter och efterkontroll av bilder, såsom secure_pipeline gör. Loggning därefter, komplett, som kopplar varje generering till sin prompt, författare och resultat – detta är ditt enda bevis vid tvist, och det måste sparas oberoende av bilderna själva, annars tar en lagringsrensning bort din spårbarhet tillsammans med dem.
Sedan kommer användarsidan. En hastighetsbegränsning per konto förhindrar att en enda prenumerant förbrukar din månatliga budget på en natt, avsiktligt eller via ett dåligt skrivet skript. Information om bilders genererade natur rör både rättvisa och, i ökande grad, regulatoriska krav; den dubblas av teknisk märkning i filens PNG- eller EXIF-metadata. Rätten till radering förutsätter att du kan hitta och radera alla en användares data på enkel begäran, vilket bara är möjligt om dina granskningsposter bär ett user_id. Öppna slutligen en rapporteringskanal: dina användare kommer alltid att se vad som är problematiskt innan du gör det, och att ta ifrån dem möjligheten att berätta för dig får inte problemet att försvinna.
Sammanfoga nu allt till en enda tjänst för bildgenerering: förfiltrering av prompter via Moderations-API:t och ordlista, säkerhetsprefix, efterverifiering av den producerade bilden, granskningslogg och AI-metadata på varje fil. Testa det med fem varierade prompter, varav minst en måste vägras – detta är det enda sättet att verifiera att dina skyddsräcken faktiskt fungerar snarare än att bara finnas i koden.
Testa dina kunskaper
Visuell generering via API: validera reflexerna före produktion.
1. Vad möjliggör inpainting och outpainting?
Svar: Inpainting modifierar en specifik yta av en befintlig bild (ersätta, korrigera); outpainting utvidgar bilden bortom dess ursprungliga ram – två riktade redigeringar utan att generera om allt.
2. Vad kännetecknar en bra avancerad visuell prompt?
Svar: Beskriv subjekt, komposition, belysning och perspektiv – inte bara temat: ju mer prompten ramar in scenen som en filmfotograf, desto mer lyder bilden.
3. Hur arbetar man effektivt med iterationer?
Svar: Börja med en basgenerering, begär sedan riktade variationer (stil, inramning, detalj) snarare än att skriva om prompten från grunden – behåll det som fungerar, justera bara gapet.
4. Vilka hävstänger finns för att optimera genereringskostnader?
Svar: Anpassa kvalitet och upplösning till det verkliga behovet (utkast i låg, finaler i hög), begränsa iterationer med bättre prompter, och cacha/återanvänd validerade visuella element.
5. Varför är moderering av visuellt innehåll avgörande?
Svar: Eftersom API:t och dina villkor ålägger gränser (förbjudet innehåll, verkliga personer, varumärken): filtrering av prompter och kontroll av utdata skyddar dina användare och din applikation.
Rama in, iterera, bemästra kostnader och efterlevnad: visuell produktion är en pipeline – inte ett tärningskast.