Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Moderácia a bezpečnosť vizuálneho obsahu

Lekcia 12 z 12 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Moderácia a bezpečnosť vizuálneho obsahu
  2. Vstavaný systém moderácie
  3. Prefiltrovanie promptov
  4. Kontroluj aj vygenerované obrázky
  5. Keď prompty píšu používatelia
  6. Logovanie pre zodpovednosť
  7. Autorské práva a ochranné známky
  8. Súlad s GDPR
  9. Pred otvorením brán
  10. Otestuj si svoje vedomosti

Aktualizované 3. novembra 2026 na základe príručky Image generation od OpenAI: Odmietnutie moderácie sa identifikuje podľa error.code == "moderation_blocked", s voliteľným objektom moderation_details, nie podľa prítomnosti slov safety alebo content_policy v chybovej správe; pridaný parameter moderation (auto, low). Zdroj: Image generation.

Aktualizácia z 2. novembra 2026 — obrazové modely. Model gpt-image-1, na ktorý bol tento kurz pôvodne napísaný, bol ukončený 23. októbra 2026 a modely gpt-image-1.5, gpt-image-1-mini a chatgpt-image-latest budú vyradené 1. decembra 2026. Príklady teraz používajú gpt-image-2.5-sunburst, ktorý je najpresnejší na úpravy; gpt-image-2.5-flare je rýchlejší pri štandardnej generácii. Oba tiež akceptujú kvality xhigh a max. Modely GPT Image vždy vracajú obrázok v base64: parameter response_format zo starších modelov DALL·E nie je podporovaný a bol z kódu odstránený. Zdroj: Image generation (OpenAI).

Moderácia a bezpečnosť vizuálneho obsahu

Pokiaľ generuješ obrázky len pre seba, moderácia je otázkou osobného úsudku. Akonáhle však sprístupníš generovanie používateľom, stáva sa to právnou a etickou zodpovednosťou, ktorá ťa viaže. Táto lekcia pokrýva nástroje moderácie od OpenAI, spôsob ich reťazenia do postupných filtrov a opatrenia, ktoré chránia tvoju aplikáciu aj ľudí, ktorí ju používajú.

Vstavaný systém moderácie

GPT Image sám odmieta určitý obsah – násilie, sexuálne explicitné materiály a iné – a toto odmietnutie signalizuje špecifickou chybou. Tvoj kód musí preto rozlišovať medzi odmietnutím podľa pravidiel obsahu a technickou chybou, pretože tieto dve situácie si vyžadujú opačné reakcie: prvá vedie k správe pre používateľa, druhá k alertu pre tvoj tím. Dokumentácia OpenAI špecifikuje rozlišovací znak: odmietnutie moderácie prichádza ako BadRequestError s error.code rovným moderation_blocked (typ image_generation_user_error) a telo chyby môže obsahovať objekt moderation_details, ktorý špecifikuje fázu (input, output alebo unknown) a všeobecné kategórie (harassment, sexual, violence…). Nehľadaj slová v chybovej správe: jej text nie je zmluva, kódom je kód. Nižšie uvedená funkcia znovu vyvolá výnimku len vtedy, ak nejde o odmietnutie moderácie.

from openai import OpenAI, BadRequestError

client = OpenAI()

def generate_with_moderation(prompt: str, output: str) -> dict:
    """Generuje obrázok so spracovaním odmietnutí moderácie."""
    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žiadavka: riešiť inde
        body = e.body if isinstance(e.body, dict) else {}
        details = body.get("moderation_details") or {}
        return {
            "status": "refused",
            "reason": "Content refused by safety policy",
            "stage": details.get("moderation_stage"),        # input, output alebo unknown
            "categories": details.get("categories") or [],  # pre tvoje logy
        }


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

OpenAI odporúča ponechať pre koncového používateľa všeobecnú správu a moderation_details si nechať pre svoje logy a podporu. Tieto chyby sa opakovaným pokusom nevyriešia: bez úpravy promptu alebo poskytnutých obrázkov bude tá istá požiadavka opäť odmietnutá. Nakoniec si všimni, že závažnosť filtrovania sa nastavuje parametrom moderation modelov GPT Image: auto (štandardné filtrovanie, predvolené) alebo low (menej restriktívne).

Prefiltrovanie promptov

Čakať, kým GPT Image odmietne prompt, až keď zistíš, že bol problematický, je neuspokojivé: už si spotreboval volanie API a nič konkrétne sa nedozvieš o dôvode. Moderation API je však bezplatné, rýchle a vracia pomenované kategórie. Jeho zavolanie pred generovaním ti umožní čisté odmietnutie, vysvetlenie používateľovi, čo bolo označené, a uchovanie týchto informácií pre tvoj audit. Funkcia verify_prompt extrahuje zoznam spustených kategórií a generate_safe_image jednoducho reťazí tieto dva kroky: najprv skontroluj, potom generuj.

from openai import OpenAI

client = OpenAI()

def verify_prompt(prompt: str) -> dict:
    """Skontroluje prompt pomocou Moderation API pred generovaní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": "This prompt was flagged by the moderation system."
        }

    return {"allowed": True}


def generate_safe_image(prompt: str, output: str):
    """Kompletný pipeline: moderácia + generovanie."""
    # Krok 1: prefiltrovanie
    check = verify_prompt(prompt)

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

    # Krok 2: generovanie
    print("Prompt validated, generating...")
    return generate_with_moderation(prompt, output)


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

Kontroluj aj vygenerované obrázky

Nevinný prompt môže viesť k obrázku, ktorý už neviný nie je. Okolikaté formulácie, nejednoznačnosť termínu alebo jednoducho nešťastná interpretácia modelu stačia na vytvorenie vizuálneho obsahu, ktorý by si nechcel zobrazovať pod svojím logom. Model omni-moderation-latest akceptuje ako vstup aj obrázky, čo ti umožňuje uzavrieť kruh: na vygenerovaný súbor platia rovnaké mechanizmy kategórií. Nižšie uvedený kompletný pipeline reťazí tri fázy – kontrola promptu, generovanie, kontrola obrázka – a čo je kľúčové, v prípade označenia súbor pred vrátením verdiktu z disku odstráni. Problematický obrázok ponechaný na serveri „kým sa pozrieme“ je obrázok, ktorý nakoniec unikne.

from openai import OpenAI
import base64

client = OpenAI()

def moderate_generated_image(image_path: str) -> dict:
    """Analyzuje vygenerovaný obrázok na detekciu problematického obsahu."""
    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: moderácia promptu + generovanie + moderácia obrázka."""
    # 1. Skontroluj prompt
    check_prompt = verify_prompt(prompt)
    if not check_prompt["allowed"]:
        return {"status": "prompt_refused", "details": check_prompt}

    # 2. Vygeneruj obrázok
    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. Skontroluj vygenerovaný obrázok
    check_image = moderate_generated_image(output)
    if not check_image["safe"]:
        import os
        os.remove(output)
        return {
            "status": "image_deleted",
            "reason": "Generated image was flagged",
            "categories": check_image["categories"]
        }

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

Keď prompty píšu používatelia

Obsah generovaný používateľmi mení povahu problému: už nestojíš proti nešikovnosti, ale občas aj proti úmyselným pokusom o obídenie systému. Trieda PromptModerator vrství štyri obrany rôznej povahy, čo je samotný princíp serióznej ochrany. Čistenie odstraňuje riadiace znaky, ktorými prechádzajú injekcie, a obmedzuje dĺžku na päťsto znakov, čím sa prereže cesta floodovacím promptom určeným na utopenie inštrukcií. Lokálna kontrola cez zoznam zakázaných slov – ponechaný prázdny, aby si ho doplnil podľa svojej politiky a sektora – zachytí za nulových nákladov to, čo už vieš. Moderation API potom preberá všetko, čo tvoj zoznam neočakával. Nakoniec bezpečnostný prefix pripojený pred finálny prompt explicitne pripomína modelu očakávaný rámec a posúva hranicu v tvoj prospech pri hraničných prípadoch.

from openai import OpenAI
import re

client = OpenAI()

class PromptModerator:
    """Vrstvový filter pre používateľské prompty."""

    def __init__(self):
        self.forbidden_words = []  # Dopln podľa svojej politiky
        self.security_prefix = (
            "Safe and appropriate image for all audiences. "
            "No violent, sexual, or discriminatory content. "
        )

    def clean(self, prompt: str) -> str:
        """Čistí a normalizuje používateľský prompt."""
        # Odstránenie potenciálnych injekcií
        prompt = prompt.strip()
        # Obmedzenie dĺžky
        prompt = prompt[:500]
        # Odstránenie riadiacich znakov
        prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
        return prompt

    def check_words(self, prompt: str) -> bool:
        """Skontroluje absenciu 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:
        """Pridá bezpečnostný prefix k promptu."""
        return f"{self.security_prefix}{prompt}"

    def pipeline(self, raw_prompt: str) -> dict:
        """Kompletný pipeline moderácie pre používateľský prompt."""
        # Krok 1: čistenie
        prompt = self.clean(raw_prompt)

        # Krok 2: lokálna kontrola
        if not self.check_words(prompt):
            return {"allowed": False, "reason": "Forbidden word detected"}

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

        # Krok 4: pridanie bezpečnostného prefixu
        final_prompt = self.secure(prompt)

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


moderator = PromptModerator()

# Simulácia používateľského promptu
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
    print(f"Secure prompt: {result['prompt']}")
else:
    print(f"Refused: {result['reason']}")

Logovanie pre zodpovednosť

V deň, keď sa problematický obrázok znovu objaví, otázkou, ktorú dostaneš, bude: kto si ho vyžiadal, kedy a čo urobil tvoj systém. Bez logov nemáš odpoveď. AuditLogger zapisuje jeden riadok JSON na generovanie do súboru .jsonl – formát len na pripájanie, ktorý podporuje súbežný zápis a dá sa čítať riadok po riadku bez načítania všetkého do pamäte. Každý záznam spája ID používateľa so skrátaným promptom, výsledkom generovania a prípadne dôvodom odmietnutia. Metóda report následne odvodí mieru akceptácie za posledných sto generovaní a detailne rozpisuje odmietnutia: toto je dashboard, ktorý ťa upozorní, ak sa u konkrétneho účtu hromadia označenia.

import json
import os
from datetime import datetime

class AuditLogger:
    """Auditný log pre generovanie obrázkov."""

    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 report o nedávnych generovaniach."""
        if not os.path.exists(self.log_file):
            print("No logs found.")
            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"Report of last {total} generations:")
        print(f"  Accepted: {ok} ({100*ok/total:.1f}%)")
        print(f"  Refused   : {refused} ({100*refused/total:.1f}%)")

        if refused > 0:
            print(f"\nRefusal details:")
            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 vie vytvoriť obrázky, ktoré evokujú štýl umelca alebo vizuálnu identitu značky, a práve táto schopnosť ťa vystavuje riziku. Technická moderácia ťa na tomto poli neochráni: nezistí, že plagát vyzerá veľmi podobne ako u konkurencie. Ochrana je preto zmluvná a organizačná, vo forme písomnej a vynútiteľnej politiky používania, ktorú tvoji používatelia akceptujú a tvoj tím uplatňuje. Blok PRODUCTION_RULES poskytuje minimálnu formuláciu, ktorú máš zobraziť vo svojej dokumentácii a pripomínať vo svojich podmienkach.

# Najlepšie postupy na integráciu do tvojej politiky používania

PRODUCTION_RULES = """
1. Do not request imitation of a living artist's style by name
2. Do not reproduce logos or registered trademarks
3. Do not generate faces of real people
4. Add an "AI-generated image" notice when required
5. Retain generation logs for at least 12 months
6. Allow users to report problematic content
"""

def usage_warning():
    """Zobrazí pravidlá používania v produkcii."""
    print("=" * 60)
    print("PRODUCTION RULES — AI Image Generation")
    print("=" * 60)
    print(PRODUCTION_RULES)

Súlad s GDPR

Pre európsku spoločnosť nie sú lehoty uchovávania a súhlas možnosti konfigurácie, ale povinnosti, ktorých dodržiavanie musí byť preukázateľné. Ich zaznamenanie do explicitného konfiguračného objektu, namiesto rozptýlenia po kóde, ti dáva jedno miesto, ktoré môžeš ukázať počas auditu. ComplianceConfig teda nastavuje uchovávanie logov na jeden rok, uchovávanie obrázkov na deväťdesiat dní a robí oznámenie o AI a súhlas povinným. Metóda add_ai_metadata si zasluhuje osobitnú pozornosť: priamo do PNG zapisuje cez PngInfo fakt, že obrázok je generovaný, nástroj, ktorý ho vytvoril, a dátum. Tieto metadáta cestujú so súborom, aj mimo tvoju platformu, čo žiadne oznámenie zobrazené na webovej stránke nedokáže.

class ComplianceConfig:
    """Konfigurácia súladu pre generovanie obrázkov."""

    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:
        """Overí, či používateľ udelil súhlas s generovaním AI."""
        # Implementuj so svojím systémom správy súhlasov
        return True

    def add_ai_metadata(self, image_path: str):
        """Pridá metadáta označujúce generovanie 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"AI metadata added: {image_path}")

Pred otvorením brán

Osem ustanovení musí byť pripravených v deň, keď sa tvoj systém stane dostupným, a je úprimnejšie pýtať si ich skôr než neskôr. Najprv moderácia v dvoch fázach: prefiltrovanie promptov a následné overenie obrázkov, ako to robí secure_pipeline. Ďalej logovanie, kompletné, spájajúce každé generovanie s jeho promptom, autorom a výsledkom – toto je tvoj jediný dôkaz v prípade sporu a musí byť uložené nezávisle od samotných obrázkov, inak by vyčistenie úložiska zmazalo aj tvoju sledovateľnosť.

Potom prichádza strana používateľa. Limit sadzieb na účet zabraňuje tomu, aby jeden odberateľ spotreboval tvoj mesačný rozpočet za jednu noc, či už úmyselne alebo cez zle napísaný skript. Informácia o generovanej povahe obrázkov sa týka jednak férovosti a čoraz častejšie aj regulačných obmedzení; je zdvojená technickým označením v metadátach PNG alebo EXIF súboru. Právo na vymazanie predpokladá, že dokážeš na jednoduchú žiadosť nájsť a vymazať všetky údaje používateľa, čo je možné len vtedy, ak tvoje auditné záznamy nesú user_id. Nakoniec otvor kanál na nahlasovanie: tvoji používatelia vždy uvidia problematický obsah skôr ako ty a odobratie ich prostriedkov, aby ti to povedali, problém nezmizne.

Teraz poskladaj všetko do jednej služby generovania obrázkov: prefiltrovanie promptov cez Moderation API a zoznam slov, bezpečnostný prefix, následné overenie vytvoreného obrázka, auditný log a AI metadáta na každom súbore. Otestuj to s piatimi rôznymi promptmi, z ktorých aspoň jeden musí byť odmietnutý – toto je jediný spôsob, ako overiť, či tvoje ochranné mechanizmy skutočne fungujú, nielen že sú prítomné v kóde.

Otestuj si svoje vedomosti

Vizuálne generovanie cez API: over si reflexy pred nasadením do produkcie.

1. Čo umožňujú inpainting a outpainting?

Odpoveď: Inpainting upravuje konkrétnu oblasť existujúceho obrázka (nahradenie, oprava); outpainting rozširuje obrázok za jeho pôvodný rámec – dve cielené úpravy bez potreby regenerovať všetko.

2. Čo robí dobrý pokročilý vizuálny prompt?

Odpoveď: Opíš subjekt, kompozíciu, osvetlenie a perspektívu – nielen tému: čím viac prompt rámkuje scénu ako režisér fotografie, tým viac mu obrázok vyhovuje.

3. Ako efektívne pracovať iteratívne?

Odpoveď: Začni základným generovaním a potom požaduj cielené variácie (štýl, rámec, detail) namiesto prepisovania promptu od nuly – zachovaj to, čo funguje, a uprav len rozdiel.

4. Aké páky využiť na optimalizáciu nákladov generovania?

Odpoveď: Prispôsob kvalitu a rozlíšenie skutočnej potrebe (návrhy v nízkej, finále vo vysokej), obmedz iterácie lepšími promptmi a cacheuj/opätovne používaj overené vizuály.

5. Prečo je moderácia vizuálneho obsahu nevyhnutná?

Odpoveď: Pretože API a tvoje podmienky ukladajú obmedzenia (zakázaný obsah, reálni ľudia, značky): filtrovanie promptov a kontrola výstupov chráni tvojich používateľov aj tvoju aplikáciu.

Rámec, iterácie, majstrovstvo nad nákladmi a súladom: vizuálna produkcia je pipeline – nie hod kockou.