Moderacja i bezpieczeństwo treści wizualnych
Na tej stronie
Zaktualizowano 3 listopada 2026 na podstawie przewodnika Image generation od OpenAI: Odmowa moderacji jest identyfikowana przez
error.code == "moderation_blocked", z opcjonalnym obiektemmoderation_details, a nie przez obecność słówsafetylubcontent_policyw komunikacie błędu; dodano parametrmoderation(auto,low). Źródło: Image generation.
Aktualizacja z 2 listopada 2026 — Modele obrazowe.
gpt-image-1, na którym pierwotnie napisano ten kurs, został wycofany 23 października 2026, agpt-image-1.5,gpt-image-1-miniorazchatgpt-image-latestzostaną wycofane 1 grudnia 2026. Przykłady wykorzystują terazgpt-image-2.5-sunburst, najbardziej precyzyjny do edycji;gpt-image-2.5-flarejest szybszy do standardowej generacji. Oba akceptują również jakościxhighimax. Modele GPT Image zawsze zwracają obraz w formacie base64: parametrresponse_formatze starszych modeli DALL·E nie jest obsługiwany i został usunięty z kodu. Źródło: Image generation (OpenAI).
Moderacja i bezpieczeństwo treści wizualnych
Dopóki generujesz obrazy tylko dla siebie, moderacja jest kwestią osobistego osądu. Gdy jednak udostępniasz generowanie użytkownikom, staje się ona odpowiedzialnością prawną i etyczną, która cię wiąże. Ta lekcja omawia narzędzia moderacyjne OpenAI, sposób ich łączenia w kolejne filtry oraz środki chroniące zarówno twoją aplikację, jak i osoby, które z niej korzystają.
Wbudowany system moderacji
GPT Image samodzielnie odrzuca pewne treści – przemoc, materiały o charakterze seksualnym i inne – sygnalizując tę odmowę konkretnym błędem. Twój kod musi więc rozróżniać odmowę wynikającą z polityki treści od awarii technicznej, ponieważ wymagają one przeciwnych reakcji: pierwsza skutkuje komunikatem dla użytkownika, druga – alertem dla twojego zespołu. Dokumentacja OpenAI precyzuje wyróżnik do użycia: odmowa moderacji przychodzi jako BadRequestError z error.code równym moderation_blocked (typ image_generation_user_error), a treść błędu może zawierać obiekt moderation_details, określający etap (input, output lub unknown) oraz ogólne kategorie (harassment, sexual, violence…). Nie szukaj słów w komunikacie błędu: jego tekst nie jest umową, kod nią jest. Poniższa funkcja ponownie zgłasza wyjątek tylko wtedy, gdy nie jest to odmowa moderacji.
from openai import OpenAI, BadRequestError
client = OpenAI()
def generate_with_moderation(prompt: str, output: str) -> dict:
"""Generuje obraz, obsługując odmowy moderacji."""
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 # awaria techniczna, limit, nieprawidłowe żądanie: obsłuż gdzie indziej
body = e.body if isinstance(e.body, dict) else {}
details = body.get("moderation_details") or {}
return {
"status": "refused",
"reason": "Treść odrzucona przez politykę bezpieczeństwa",
"stage": details.get("moderation_stage"), # input, output lub unknown
"categories": details.get("categories") or [], # do twoich logów
}
result = generate_with_moderation(
"A kitten playing with a ball of yarn",
"kitten.png"
)
print(result)
OpenAI zaleca stosowanie ogólnego komunikatu dla użytkownika końcowego, a moderation_details rezerwowanie dla logów i wsparcia. Błędy te nie ustępują przy ponownej próbie: bez modyfikacji promptu lub dostarczonych obrazów to samo żądanie zostanie ponownie odrzucone. Pamiętaj też, że surowość filtrowania ustawia się parametrem moderation modeli GPT Image: auto (standardowe filtrowanie, domyślne) lub low (mniej restrykcyjne).
Wstępne filtrowanie promptów
Czekanie, aż GPT Image odrzuci prompt, zanim odkryjesz, że był problematyczny, jest niewystarczające: zużyłeś już wywołanie API i nie dowiadujesz się niczego konkretnego o przyczynie. API Moderacji jest jednak darmowe, szybkie i zwraca nazwane kategorie. Wywołanie go przed generacją pozwala czysto odmówić, wyjaśnić użytkownikowi, co zostało oflagowane, i zachować te informacje do audytu. Funkcja verify_prompt ekstrahuje listę uruchomionych kategorii, a generate_safe_image po prostu łączy dwa kroki: najpierw sprawdź, potem generuj.
from openai import OpenAI
client = OpenAI()
def verify_prompt(prompt: str) -> dict:
"""Sprawdza prompt za pomocą API Moderacji przed generacją."""
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": "Ten prompt został oflagowany przez system moderacji."
}
return {"allowed": True}
def generate_safe_image(prompt: str, output: str):
"""Pełny potok: moderacja + generacja."""
# Krok 1: wstępne filtrowanie
check = verify_prompt(prompt)
if not check["allowed"]:
print(f"Prompt odrzucony: {check['message']}")
print(f"Kategorie: {check['categories']}")
return None
# Krok 2: generacja
print("Prompt zweryfikowany, generowanie...")
return generate_with_moderation(prompt, output)
# Test z nieszkodliwym promptem
generate_safe_image(
"A mountain landscape with a crystal clear lake",
"mountain.png"
)
Sprawdzaj również wygenerowane obrazy
Niewinny prompt może dać obraz, który już niewinny nie jest. Okrężne sformułowanie, niejednoznaczność terminu lub po prostu pechowa interpretacja modelu wystarczą, by wyprodukować treści wizualne, których nie chciałbyś wyświetlać pod swoim logo. Model omni-moderation-latest akceptuje obrazy jako dane wejściowe, pozwalając domknąć pętlę: te same mechanizmy kategorii dotyczą wygenerowanego pliku. Poniższy kompletny potok łączy trzy fazy – sprawdzenie promptu, generację, sprawdzenie obrazu – i co kluczowe, w przypadku oflagowania usuwa plik z dysku przed zwróceniem werdyktu. Problematiczny obraz pozostawiony na serwerze „na czas sprawdzenia“ to obraz, który w końcu wycieknie.
from openai import OpenAI
import base64
client = OpenAI()
def moderate_generated_image(image_path: str) -> dict:
"""Analizuje wygenerowany obraz w celu wykrycia problematycznych treści."""
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):
"""Pełny potok: moderacja promptu + generacja + moderacja obrazu."""
# 1. Sprawdź prompt
check_prompt = verify_prompt(prompt)
if not check_prompt["allowed"]:
return {"status": "prompt_refused", "details": check_prompt}
# 2. Wygeneruj obraz
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. Sprawdź wygenerowany obraz
check_image = moderate_generated_image(output)
if not check_image["safe"]:
import os
os.remove(output)
return {
"status": "image_deleted",
"reason": "Wygenerowany obraz został oflagowany",
"categories": check_image["categories"]
}
return {"status": "ok", "path": output}
Gdy użytkownicy piszą prompty
Treści tworzone przez użytkowników zmieniają naturę problemu: nie masz już do czynienia z niezgrabnością, lecz czasem z celowymi próbami obejścia zabezpieczeń. Klasa PromptModerator stackuje cztery warstwy obrony o różnym charakterze, co jest samą zasadą poważnej ochrony. Czyszczenie usuwa znaki kontrolne, przez które przechodzą iniekcje, i ogranicza długość do pięciuset znaków, ucinaąc prompty powodziowe mające na celu zatopienie instrukcji. Lokalna weryfikacja poprzez listę słów zakazanych – pozostawiona pusta, do wypełnienia zgodnie z twoją polityką i sektorem – перехwytuje za darmo to, co już wiesz. API Moderacji przejmuje potem wszystko, czego twoja lista nie przewidziała. Na koniec prefiks bezpieczeństwa doklejony przed finalny prompt wyraźnie przypomina modelowi oczekiwane ramy, przesuwając granicę na twoją korzyść w przypadkach brzegowych.
from openai import OpenAI
import re
client = OpenAI()
class PromptModerator:
"""Wielowarstwowy filtr dla promptów użytkownika."""
def __init__(self):
self.forbidden_words = [] # Wypełnij zgodnie z twoją polityką
self.security_prefix = (
"Bezpieczny i odpowiedni obraz dla wszystkich odbiorców. "
"Brak treści przemocy, seksualnych lub dyskryminujących. "
)
def clean(self, prompt: str) -> str:
"""Czyści i normalizuje prompt użytkownika."""
# Usuń potencjalne iniekcje
prompt = prompt.strip()
# Ogranicz długość
prompt = prompt[:500]
# Usuń znaki kontrolne
prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
return prompt
def check_words(self, prompt: str) -> bool:
"""Sprawdza brak słów zakazanych."""
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:
"""Dodaje prefiks bezpieczeństwa do promptu."""
return f"{self.security_prefix}{prompt}"
def pipeline(self, raw_prompt: str) -> dict:
"""Kompletny potok moderacji dla promptu użytkownika."""
# Krok 1: czyszczenie
prompt = self.clean(raw_prompt)
# Krok 2: weryfikacja lokalna
if not self.check_words(prompt):
return {"allowed": False, "reason": "Wykryto słowo zakazane"}
# Krok 3: moderacja przez API
check = verify_prompt(prompt)
if not check["allowed"]:
return {"allowed": False, "reason": check["message"]}
# Krok 4: dodaj prefiks bezpieczeństwa
final_prompt = self.secure(prompt)
return {"allowed": True, "prompt": final_prompt}
moderator = PromptModerator()
# Symuluj prompt użytkownika
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
print(f"Bezpieczny prompt: {result['prompt']}")
else:
print(f"Odrzucono: {result['reason']}")
Logowanie dla rozliczalności
Dnia, gdy problematyczny obraz wypłynie na jaw, pytanie, które ci zadadzą, brzmi: kto go zażądał, kiedy i co zrobił twój system. Bez logów nie masz odpowiedzi. AuditLogger zapisuje jedną linię JSON na generację do pliku .jsonl – formatu tylko do dopisywania, który obsługuje zapis współbieżny i może być czytany linia po linii bez ładowania wszystkiego do pamięci. Każde wejście łączy ID użytkownika ze skróconym promptem, wynikiem generacji i, w razie potrzeby, przyczyną odmowy. Metoda report wyprowadza następnie wskaźnik akceptacji dla ostatnich stu generacji i szczegółowo opisuje odmowy: to jest dashboard, który cię ostrzeże, jeśli konkretne konto nagromadzi oflagowania.
import json
import os
from datetime import datetime
class AuditLogger:
"""Log audytowy dla generacji obrazów."""
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
):
"""Loguje wpis audytowy."""
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):
"""Generuje raport ostatnich generacji."""
if not os.path.exists(self.log_file):
print("Nie znaleziono logów.")
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"Raport ostatnich {total} generacji:")
print(f" Zaakceptowano: {ok} ({100*ok/total:.1f}%)")
print(f" Odrzucono : {refused} ({100*refused/total:.1f}%)")
if refused > 0:
print(f"\nSzczegóły odmów:")
for e in recent:
if e["result"] != "ok":
print(f" [{e['timestamp'][:10]}] {e['user_id']} : {e['refusal_reason']}")
logger = AuditLogger()
logger.report()
Prawa autorskie i znaki towarowe
GPT Image potrafi tworzyć obrazy przywołujące styl artysty lub tożsamość wizualną marki i ta zdolność jest właśnie tym, co cię naraża. Moderacja techniczna nie chroni cię na tym polu: nie wykryje, że plakat wygląda bardzo podobnie do konkurencji. Ochrona jest więc kontraktowa i organizacyjna, przybierając formę pisemnej, egzekwowalnej polityki użytkowania, którą akceptują twoi użytkownicy, a stosuje zespół. Blok PRODUCTION_RULES daje minimalne sformułowanie, do wyświetlenia w dokumentacji oraz przypomnienia w regulaminie.
# Najlepsze praktyki do integracji z twoją polityką użytkowania
PRODUCTION_RULES = """
1. Nie żądaj naśladowania stylu żyjącego artysty z nazwiska
2. Nie reprodukuj logotypów ani zastrzeżonych znaków towarowych
3. Nie generuj twarzy rzeczywistych osób
4. Dodaj informację „Obraz wygenerowany przez AI“, gdy wymagane
5. Przechowuj logi generacji przez co najmniej 12 miesięcy
6. Pozwól użytkownikom zgłaszać problematyczne treści
"""
def usage_warning():
"""Wyświetla zasady użytkowania produkcyjnego."""
print("=" * 60)
print("ZASADY PRODUKCYJNE — Generacja obrazów AI")
print("=" * 60)
print(PRODUCTION_RULES)
Zgodność z RODO
Dla firmy europejskiej okresy przechowywania i zgody nie są opcjami konfiguracji, lecz obowiązkami, których przestrzeganie musi być wykazalne. Zapisanie ich w jawnym obiekcie konfiguracji, zamiast rozpraszania po kodzie, daje ci jedno miejsce do pokazania podczas audytu. ComplianceConfig ustawia zatem przechowywanie logów na jeden rok, obrazów na dziewięćdziesiąt dni i czyni informację o AI oraz zgodę obowiązkowymi. Metoda add_ai_metadata zasługuje na szczególną uwagę: zapisuje w samym pliku PNG, poprzez PngInfo, fakt, że obraz jest wygenerowany, narzędzie, które go stworzyło, oraz datę. Te metadane podróżują z plikiem, także poza twoją platformę, czego nie robi żadna informacja wyświetlana na stronie internetowej.
class ComplianceConfig:
"""Konfiguracja zgodności dla generacji obrazów."""
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:
"""Weryfikuje, czy użytkownik wyraził zgodę na generację AI."""
# Zaimplementuj ze swoim systemem zarządzania zgodami
return True
def add_ai_metadata(self, image_path: str):
"""Dodaje metadane wskazujące na generację AI."""
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"Dodano metadane AI: {image_path}")
Przed otwarciem śluz
Osiem postanowień musi być na miejscu w dniu, gdy twój system stanie się dostępny, i uczciwiej jest poprosić o nie przed, a nie po. Najpierw moderacja w dwóch fazach: wstępne filtrowanie promptów i poweryfikacja obrazów, tak jak robi to secure_pipeline. Następnie logowanie, kompletne, łączące każdą generację z jej promptem, autorem i wynikiem – to twój jedyny dowód w razie sporu i musi być zapisane niezależnie od samych obrazów, inaczej czyszczenie magazynu zabierze wraz z sobą twoją możliwość śledzenia.
Potem strona użytkownika. Limit stawek na konto zapobiega sytuacji, w której jeden subskrybent zużywa twój miesięczny budżet w jedną noc, celowo lub przez źle napisany skrypt. Informacja o wygenerowanym charakterze obrazów dotyczy zarówno uczciwości, jak i, coraz częściej, ograniczeń regulacyjnych; jest podwojona przez techniczne znakowanie w metadanych PNG lub EXIF pliku. Prawo do usunięcia zakłada, że potrafisz znaleźć i usunąć wszystkie dane użytkownika na proste żądanie, co jest możliwe tylko wtedy, gdy twoje wpisy audytowe niosą user_id. Na koniec otwórz kanał zgłoszeń: twoi użytkownicy zawsze zobaczą to, co problematyczne, zanim ty to zrobisz, a odebranie im means do powiedzenia ci o tym nie sprawi, że problem zniknie.
Teraz złóż całość w jedną usługę generacji obrazów: wstępne filtrowanie promptów przez API Moderacji i listę słów, prefiks bezpieczeństwa, poweryfikacja wyprodukowanego obrazu, log audytowy i metadane AI na każdym pliku. Przetestuj to pięcioma różnymi promptami, z których co najmniej jeden musi zostać odrzucony – to jedyny sposób, by zweryfikować, że twoje guardraile faktycznie działają, a nie tylko są obecne w kodzie.
Sprawdź swoją wiedzę
Generacja wizualna przez API: zweryfikuj odruchy przed produkcją.
1. Co pozwalają robić inpainting i outpainting?
Odpowiedź: Inpainting modyfikuje konkretny obszar istniejącego obrazu (zamiana, korekta); outpainting rozszerza obraz poza jego oryginalną ramę – dwie celowane edycje bez regenerowania wszystkiego.
2. Co czyni dobry zaawansowany prompt wizualny?
Odpowiedź: Opisz temat, kompozycję, oświetlenie i perspektywę – nie tylko temat: im bardziej prompt kadruje scenę jak operator filmowy, tym bardziej obraz słucha.
3. Jak skutecznie pracować iteracyjnie?
Odpowiedź: Zacznij od bazowej generacji, a potem żądaj celowanych wariacji (styl, kadrowanie, detal), zamiast przepisywać prompt od zera – zachowaj to, co działa, tylko dostroj lukę.
4. Jakie dźwignie optymalizują koszty generacji?
Odpowiedź: Dostosuj jakość i rozdzielczość do rzeczywistej potrzeby (szkice w niskiej, finały w wysokiej), ogranicz iteracje lepszymi promptami i buforuj/powtarzaj zwalidowane wizualizacje.
5. Dlaczego moderacja treści wizualnych jest kluczowa?
Odpowiedź: Ponieważ API i twój regulamin nakładają limity (treści zakazane, rzeczywiste osoby, marki): filtrowanie promptów i kontrola wyjść chroni twoich użytkowników i twoją aplikację.
Kadruj, iteruj, opanuj koszty i zgodność: produkcja wizualna to potok – nie rzut kostką.