Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Moderace a bezpečnost vizuálního obsahu

Lekce 12 z 12 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Moderace a bezpečnost vizuálního obsahu
  2. Vestavěný systém moderace
  3. Prefiltrování promptů
  4. Kontroluj také vygenerované obrázky
  5. Když prompty píší uživatelé
  6. Logování pro odpovědnost
  7. Autorská práva a ochranné známky
  8. Soulad s GDPR
  9. Než otevřeš stavidla
  10. Otestuj své znalosti

Aktualizováno 3. listopadu 2026 na základě příručky OpenAI Image generation: Odmítnutí moderací je identifikováno pomocí error.code == "moderation_blocked" s volitelným objektem moderation_details, nikoli přítomností slov safety nebo content_policy v chybové zprávě; přidán parametr moderation (auto, low). Zdroj: Image generation.

Aktualizace z 2. listopadu 2026 — obrazové modely. Model gpt-image-1, na kterém byl tento kurz původně napsán, byl ukončen 23. října 2026 a modely gpt-image-1.5, gpt-image-1-mini a chatgpt-image-latest budou vyřazeny 1. prosince 2026. Příklady nyní používají gpt-image-2.5-sunburst, který je nejpřesnější pro úpravy; gpt-image-2.5-flare je rychlejší pro standardní generování. Oba také přijímají kvality xhigh a max. Modely GPT Image vždy vracejí obrázek v base64: parametr response_format ze starších modelů DALL·E není podporován a byl z kódu odstraněn. Zdroj: Image generation (OpenAI).

Moderace a bezpečnost vizuálního obsahu

Dokud generuješ obrázky pouze pro sebe, je moderace otázkou osobního úsudku. Jakmile však zpřístupníš generování uživatelům, stává se z toho právní a etická odpovědnost, která tě zavazuje. Tato lekce pokrývá nástroje pro moderaci od OpenAI, způsob jejich řazení do postupných filtrů a opatření, která chrání jak tvou aplikaci, tak lidi, kteří ji používají.

Vestavěný systém moderace

GPT Image sám o sobě odmítá určitý obsah – násilí, sexuálně explicitní materiály a další – a toto odmítnutí signalizuje specifickou chybou. Tvůj kód musí proto rozlišovat odmítnutí kvůli zásadám obsahu od technické chyby, protože obě situace vyžadují opačnou reakci: první vede k zprávě pro uživatele, druhá k alertu pro tvůj tým. Dokumentace OpenAI specifikuje rozlišovací prvek: odmítnutí moderací přichází jako BadRequestError s error.code rovným moderation_blocked (typ image_generation_user_error) a tělo chyby může obsahovat objekt moderation_details, který určuje fázi (input, output nebo unknown) a obecné kategorie (harassment, sexual, violence…). Nehledej slova v textu chybové zprávy: její text není smlouvou, kód ano. Následující funkce znovu vyvolá výjimku pouze tehdy, pokud nejde o odmítnutí moderací.

from openai import OpenAI, BadRequestError

client = OpenAI()

def generate_with_moderation(prompt: str, output: str) -> dict:
    """Generuje obrázek při současném zpracování odmítnutí moderací."""
    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  # technická chyba, kvóta, neplatný požadavek: řešit jinde
        body = e.body if isinstance(e.body, dict) else {}
        details = body.get("moderation_details") or {}
        return {
            "status": "refused",
            "reason": "Obsah odmítnut bezpečnostní politikou",
            "stage": details.get("moderation_stage"),        # input, output nebo unknown
            "categories": details.get("categories") or [],  # pro tvé logy
        }


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

OpenAI doporučuje ponechat pro koncového uživatele obecnou zprávu a moderation_details si rezervovat pro své logy a podporu. Tyto chyby se při opakovaném pokusu nevyřeší: bez úpravy promptu nebo poskytnutých obrázků bude stejný požadavek znovu odmítnut. Nakonec měj na paměti, že závažnost filtrování se nastavuje parametrem moderation modelů GPT Image: auto (standardní filtrování, výchozí) nebo low (méně restriktivní).

Prefiltrování promptů

Čekat, až GPT Image odmítne prompt, abys zjistil, že byl problematický, není uspokojivé: již jsi spotřeboval volání API a nedozvíš se nic konkrétního o důvodu. Moderation API je však zdarma, rychlé a vrací pojmenované kategorie. Jeho zavolání před generováním ti umožní čisté odmítnutí, vysvětlení uživateli, co bylo označeno, a uchování těchto informací pro audit. Funkce verify_prompt extrahuje seznam spuštěných kategorií a generate_safe_image jednoduše řetězí dva kroky: nejprve zkontroluj, poté generuj.

from openai import OpenAI

client = OpenAI()

def verify_prompt(prompt: str) -> dict:
    """Zkontroluje prompt pomocí Moderation API před generováním."""
    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": "Tento prompt byl označen systémem moderace."
        }

    return {"allowed": True}


def generate_safe_image(prompt: str, output: str):
    """Kompletní pipeline: moderace + generování."""
    # Krok 1: prefiltrování
    check = verify_prompt(prompt)

    if not check["allowed"]:
        print(f"Prompt odmítnut: {check['message']}")
        print(f"Kategorie: {check['categories']}")
        return None

    # Krok 2: generování
    print("Prompt validován, generuji...")
    return generate_with_moderation(prompt, output)


# Test s neškodným promptem
generate_safe_image(
    "A mountain landscape with a crystal clear lake",
    "mountain.png"
)

Kontroluj také vygenerované obrázky

Nevinný prompt může vést k obrázku, který neviný není. Okolikaté formulace, nejednoznačnost termínu nebo prostě jen nešťastná interpretace modelem stačí k vytvoření vizuálního obsahu, který bys pod svým logem nechtěl zobrazovat. Model omni-moderation-latest přijímá jako vstup obrázky, což ti umožňuje uzavřít smyčku: na vygenerovaný soubor se vztahují stejné mechanismy kategorií. Níže uvedená kompletní pipeline řetězí tři fáze – kontrola promptu, generování, kontrola obrázku – a co je klíčové, v případě označení smaže soubor z disku před vrácením verdiktu. Problematický obrázek ponechaný na serveru „dokud se podíváme“ je obrázek, který dříve či později unikne.

from openai import OpenAI
import base64

client = OpenAI()

def moderate_generated_image(image_path: str) -> dict:
    """Analyzuje vygenerovaný obrázek a detekuje problematický obsah."""
    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):
    """Kompletní pipeline: moderace promptu + generování + moderace obrázku."""
    # 1. Zkontroluj prompt
    check_prompt = verify_prompt(prompt)
    if not check_prompt["allowed"]:
        return {"status": "prompt_refused", "details": check_prompt}

    # 2. Vygeneruj obrázek
    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. Zkontroluj vygenerovaný obrázek
    check_image = moderate_generated_image(output)
    if not check_image["safe"]:
        import os
        os.remove(output)
        return {
            "status": "image_deleted",
            "reason": "Vygenerovaný obrázek byl označen",
            "categories": check_image["categories"]
        }

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

Když prompty píší uživatelé

Obsah generovaný uživateli mění povahu problému: už nečelíš jen neobratnosti, ale občas i záměrným pokusům o obejití systému. Třída PromptModerator vrství čtyři obrany různé povahy, což je samotný princip seriózní ochrany. Čištění odstraňuje řídicí znaky, kterými procházejí injekce, a omezuje délku na pět set znaků, čímž krátí floodové prompty určené k utopení instrukcí. Lokální ověření prostřednictvím seznamu zakázaných slov – ponechaného prázdného, aby byl vyplněn podle tvé politiky a sektoru – zachytí za nulovou cenu to, co již znáš. Moderation API pak převezme vše, co tvůj seznam nepředvídal. Nakonec bezpečnostní prefix připojený před finální prompt explicitně připomene modelu očekávaný rámec a posune hranici ve tvůj prospěch u hraničních případů.

from openai import OpenAI
import re

client = OpenAI()

class PromptModerator:
    """Vrstvený filtr pro uživatelské prompty."""

    def __init__(self):
        self.forbidden_words = []  # Vyplň podle své politiky
        self.security_prefix = (
            "Safe and appropriate image for all audiences. "
            "No violent, sexual, or discriminatory content. "
        )

    def clean(self, prompt: str) -> str:
        """Vyčistí a normalizuje uživatelský prompt."""
        # Odstraň potenciální injekce
        prompt = prompt.strip()
        # Omez délku
        prompt = prompt[:500]
        # Odstraň řídicí znaky
        prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
        return prompt

    def check_words(self, prompt: str) -> bool:
        """Zkontroluje nepřítomnost zakázaných slov."""
        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:
        """Přidá k promptu bezpečnostní prefix."""
        return f"{self.security_prefix}{prompt}"

    def pipeline(self, raw_prompt: str) -> dict:
        """Kompletní pipeline moderace pro uživatelský prompt."""
        # Krok 1: čištění
        prompt = self.clean(raw_prompt)

        # Krok 2: lokální ověření
        if not self.check_words(prompt):
            return {"allowed": False, "reason": "Detekováno zakázané slovo"}

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

        # Krok 4: přidej bezpečnostní prefix
        final_prompt = self.secure(prompt)

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


moderator = PromptModerator()

# Simulace uživatelského promptu
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
    print(f"Bezpečný prompt: {result['prompt']}")
else:
    print(f"Odmítnuto: {result['reason']}")

Logování pro odpovědnost

V den, kdy se znovu objeví problematický obrázek, budeš se muset zodpovídat na otázku: kdo si ho vyžádal, kdy a co udělal tvůj systém. Bez logů nemáš odpověď. AuditLogger zapisuje jeden řádek JSON na generování do souboru .jsonl – formátu pouze pro připojování, který podporuje souběžný zápis a lze jej číst řádek po řádku bez načítání všeho do paměti. Každý záznam propojuje ID uživatele se zkráceným promptem, výsledkem generování a případně důvodem odmítnutí. Metoda report pak odvozuje míru přijetí za posledních sto generování a detailně rozepisuje odmítnutí: toto je dashboard, který tě upozorní, pokud si konkrétní účet nahromadí označení.

import json
import os
from datetime import datetime

class AuditLogger:
    """Auditní log pro generování obrázků."""

    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
    ):
        """Zapíše auditní záznam."""
        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 přehled nedávných generování."""
        if not os.path.exists(self.log_file):
            print("Nebyly nalezeny žádné logy.")
            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"Přehled posledních {total} generování:")
        print(f"  Přijato: {ok} ({100*ok/total:.1f}%)")
        print(f"  Odmítnuto: {refused} ({100*refused/total:.1f}%)")

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


logger = AuditLogger()
logger.report()

Autorská práva a ochranné známky

GPT Image umí vytvářet obrázky evokující styl umělce nebo vizuální identitu značky a právě tato schopnost tě vystavuje riziku. Technická moderace tě na tomto poli nechrání: nedetekuje, že plakát vypadá velmi podobně jako u konkurence. Ochrana je tedy smluvní a organizační, ve formě písemné a vymahatelné politiky používání, kterou tvoji uživatelé přijmou a tvůj tým bude uplatňovat. Blok PRODUCTION_RULES poskytuje minimální formulaci, kterou je třeba zobrazit v dokumentaci a připomenout ve svých podmínkách.

# Osvědčené postupy k integraci do vaší politiky používání

PRODUCTION_RULES = """
1. Nepožadujte napodobení stylu žijícího umělce podle jména
2. Nereprodukujte loga nebo registrované ochranné známky
3. Negenerujte obličeje skutečných lidí
4. Přidejte upozornění „Obrázek vygenerovaný AI“, je-li vyžadováno
5. Uchovávejte logy generování alespoň 12 měsíců
6. Umožněte uživatelům hlásit problematický obsah
"""

def usage_warning():
    """Zobrazí pravidla pro produkční používání."""
    print("=" * 60)
    print("PRAVIDLA PRO PRODUKCI — Generování obrázků AI")
    print("=" * 60)
    print(PRODUCTION_RULES)

Soulad s GDPR

Pro evropskou společnost nejsou doby uchovávání a souhlas možnostmi konfigurace, ale povinnostmi, jejichž dodržování musí být prokazatelné. Jejich zaznamenání do explicitního konfiguračního objektu, místo jejich rozptýlení v kódu, ti poskytne jedno místo, které můžeš ukázat během auditu. ComplianceConfig tak nastavuje uchovávání logů na jeden rok, uchovávání obrázků na devadesát dní a činí oznámení o AI a souhlas povinnými. Metoda add_ai_metadata si zaslouží zvláštní pozornost: zapisuje přímo do PNG prostřednictvím PngInfo fakt, že obrázek byl vygenerován, nástroj, který jej vytvořil, a datum. Tato metadata cestují se souborem, včetně mimo tvou platformu, což žádné oznámení zobrazené na webové stránce nedokáže.

class ComplianceConfig:
    """Konfigurace souladu pro generování obrázků."""

    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:
        """Ověří, zda uživatel udělil souhlas s generováním AI."""
        # Implementuj se svým systémem správy souhlasů
        return True

    def add_ai_metadata(self, image_path: str):
        """Přidá metadata označující generování 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"Metadata AI přidána: {image_path}")

Než otevřeš stavidla

Osm ustanovení musí být na místě v den, kdy se tvůj systém stane přístupným, a je upřímnější požadovat je dříve než později. Nejprve moderace ve dvou fázích: prefiltrování promptů a post-kontrola obrázků, jak to dělá secure_pipeline. Dále logování, kompletní, propojující každé generování s jeho promptem, autorem a výsledkem – to je tvůj jediný důkaz v případě sporu a musí být uloženo nezávisle na samotných obrázcích, jinak by vymazání úložiště smazalo i tvou sledovatelnost.

Pak přichází strana uživatele. Rychlostní limit na účet zabraňuje tomu, aby jediný odběratel spotřeboval tvůj měsíční rozpočet během jedné noci, ať už úmyslně, nebo kvůli špatně napsanému skriptu. Informace o generované povaze obrázků se týká jak férovosti, tak stále častěji i regulačních omezení; je zdvojněna technickým označením v metadatech PNG nebo EXIF souboru. Právo na výmaz předpokládá, že dokážeš na jednoduchou žádost najít a smazat všechna data uživatele, což je možné pouze tehdy, pokud tvé auditní záznamy nesou user_id. Nakonec otevři kanál pro hlášení: tvoji uživatelé vždy uvidí, co je problematické, dříve než ty, a odebrání jejich prostředků, jak ti to sdělit, problém nezmizí.

Nyní vše sestav do jediné služby pro generování obrázků: prefiltrování promptů přes Moderation API a seznam slov, bezpečnostní prefix, post-ověření vytvořeného obrázku, auditní log a metadata AI na každém souboru. Otestuj to s pěti různými prompty, z nichž alespoň jeden musí být odmítnut – pouze tak ověříš, že tvá ochranná opatření skutečně fungují, nejen že jsou přítomna v kódu.

Otestuj své znalosti

Vizuální generování přes API: ověř si reflexy před nasazením do produkce.

1. Co umožňují inpainting a outpainting?

Odpověď: Inpainting upravuje specifickou oblast existujícího obrázku (nahrazení, oprava); outpainting rozšiřuje obrázek za jeho původní rámec – dvě cílené úpravy bez nutnosti regenerovat vše.

2. Co dělá dobrý pokročilý vizuální prompt?

Odpověď: Popiš subjekt, kompozici, osvětlení a perspektivu – nejen téma: čím více prompt rámuje scénu jako režisér fotografie, tím více mu obrázek vyhoví.

3. Jak efektivně pracovat iteracemi?

Odpověď: Začni základním generováním a poté požádej o cílené variace (styl, rámování, detail), místo přepisování promptu od nuly – zachovej to, co funguje, a uprav pouze rozdíl.

4. Jaké páky použít k optimalizaci nákladů na generování?

Odpověď: Přizpůsob kvalitu a rozlišení skutečné potřebě (návrhy v nízké, finále ve vysoké), omez iterace lepšími prompty a cacheuj/opakovaně používej validované vizuály.

5. Proč je moderace vizuálního obsahu zásadní?

Odpověď: Protože API i tvé podmínky ukládají limity (zakázaný obsah, skuteční lidé, značky): filtrování promptů a kontrola výstupů chrání tvé uživatele i tvou aplikaci.

Rámuj, iteruj, ovládej náklady a soulad: vizuální produkce je pipeline – ne hra v kostky.