Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Moderacija in varnost vizualne vsebine

Lekcija 12 od 12 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Moderacija in varnost vizualne vsebine
  2. Vgrajeni sistem za moderacijo
  3. Predhodno filtriranje pozivov
  4. Preveri tudi generirane slike
  5. Ko uporabniki pišejo pozive
  6. Beleženje za odgovornost
  7. Avtorske pravice in blagovne znamke
  8. Skladnost z GDPR
  9. Preden odpreš zapornice
  10. Preizkusi svoje znanje

Posodobljeno 3. novembra 2026 na podlagi vodnika OpenAI za generiranje slik: Zavrnitev zaradi moderacije se prepozna po error.code == "moderation_blocked" z opcijskim predmetom moderation_details, ne pa po prisotnosti besed safety ali content_policy v sporočilu o napaki; dodan parameter moderation (auto, low). Vir: Generiranje slik.

Posodobitev z dne 2. novembra 2026 — modeli za slike. Model gpt-image-1, na katerem je temeljil ta tečaj, je bil ukinjen 23. oktobra 2026, modeli gpt-image-1.5, gpt-image-1-mini in chatgpt-image-latest pa bodo umaknjeni 1. decembra 2026. Primeri zdaj uporabljajo gpt-image-2.5-sunburst, ki je najbolj natančen za urejanje; gpt-image-2.5-flare je hitrejši za standardno generiranje. Oba sprejemata tudi kakovosti xhigh in max. Modeli GPT Image vedno vrnejo sliko v formatu base64: parameter response_format iz starejših modelov DALL·E ni podprt in je bil iz kode odstranjen. Vir: Generiranje slik (OpenAI).

Moderacija in varnost vizualne vsebine

Dokler slike generiraš zase, je moderacija stvar tvoje osebne presoje. Ko generiranje odpreš uporabnikom, postane pravna in etična odgovornost, ki te zavezuje. Ta lekcija pokriva orodja za moderacijo pri OpenAI, kako jih verižiš v zaporedne filtre in katere ukrepe sprejeti za zaščito tvoje aplikacije ter ljudi, ki jo uporabljajo.

Vgrajeni sistem za moderacijo

GPT Image samodejno zavrne določeno vsebino – nasilje, spolno eksplicitno gradivo in drugo – ter to zavrnitev signalizira s specifično napako. Tvoja koda mora zato razlikovati med zavrnitvijo zaradi pravil o vsebini in tehnično napako, saj zahtevata nasprotni reakciji: prva rezultira v sporočilu uporabniku, druga v opozorilu tvoji ekipi. Dokumentacija OpenAI določa diskriminator: zavrnitev zaradi moderacije prispe kot BadRequestError z error.code, enakim moderation_blocked (tip image_generation_user_error), telo napake pa lahko vsebuje predmet moderation_details, ki določa fazo (input, output ali unknown) in splošne kategorije (harassment, sexual, violence …). Ne išči besed v sporočilu o napaki: njegovo besedilo ni pogodba, koda je. Spodnja funkcija ponovno sproži izjemo le, če ne gre za zavrnitev zaradi moderacije.

from openai import OpenAI, BadRequestError

client = OpenAI()

def generate_with_moderation(prompt: str, output: str) -> dict:
    """Generira sliko ob obravnavi zavrnitev zaradi moderacije."""
    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  # tehnična napaka, kvota, neveljaven zahtevek: obravnavaj drugje
        body = e.body if isinstance(e.body, dict) else {}
        details = body.get("moderation_details") or {}
        return {
            "status": "refused",
            "reason": "Vsebina zavrnjena zaradi varnostne politike",
            "stage": details.get("moderation_stage"),        # input, output ali unknown
            "categories": details.get("categories") or [],  # za tvoje dnevnike
        }


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

OpenAI svetuje uporabo splošnega sporočila za končnega uporabnika in rezerviranje moderation_details za tvoje dnevnike in podporo. Teh napak ni mogoče rešiti s ponovnim poskusom: brez spremembe poziva ali priloženih slik bo isti zahtevek ponovno zavrnjen. Nazadnje notej, da stopnjo strogosti filtriranja določa parameter moderation modelov GPT Image: auto (standardno filtriranje, privzeto) ali low (manj omejujoče).

Predhodno filtriranje pozivov

Čakanje, da GPT Image zavrne poziv, preden ugotoviš, da je problematičen, je nezadovoljivo: že porabil si klic API-ja in ne izveš nič specifičnega o razlogu. API za moderacijo je brezplačen, hiter in vrača imenovane kategorije. Njegov klic pred generiranjem ti omogoča čisto zavrnitev, pojasnilo uporabniku, kaj je bilo označeno, in hrambo teh informacij za revizijo. Funkcija verify_prompt izvleče seznam sproženih kategorij, generate_safe_image pa preprosto veriži dva koraka: najprej preveri, nato generiraj.

from openai import OpenAI

client = OpenAI()

def verify_prompt(prompt: str) -> dict:
    """Preveri poziv z API-jem za moderacijo pred generiranjem."""
    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": "Ta poziv je označil sistem za moderacijo."
        }

    return {"allowed": True}


def generate_safe_image(prompt: str, output: str):
    """Celoten potek: moderacija + generiranje."""
    # 1. korak: predhodno filtriranje
    check = verify_prompt(prompt)

    if not check["allowed"]:
        print(f"Poziv zavrnjen: {check['message']}")
        print(f"Kategorije: {check['categories']}")
        return None

    # 2. korak: generiranje
    print("Poziv potrjen, generiram...")
    return generate_with_moderation(prompt, output)


# Test z neškodljivim pozivom
generate_safe_image(
    "A mountain landscape with a crystal clear lake",
    "mountain.png"
)

Preveri tudi generirane slike

Nedolžen poziv lahko proizvede sliko, ki to ni. Ovinkarstvo, dvoumnost izraza ali zgolj nesrečna interpretacija modela zadostujeta za nastanek vizualne vsebine, ki je ne bi želel prikazovati pod svojim logotipom. Model omni-moderation-latest sprejema slike kot vhod, kar ti omogoča zaprtje zanke: enaka mehanika kategorij velja za generirano datoteko. Spodnji celotni potek veriži tri faze – preverjanje poziva, generiranje, preverjanje slike – in kar je ključno, v primeru označitve izbriše datoteko z diska, preden vrne sodbo. Problematična slika, ki ostane na strežniku „medtem ko gledamo”, je slika, ki bo sčasoma uhajala.

from openai import OpenAI
import base64

client = OpenAI()

def moderate_generated_image(image_path: str) -> dict:
    """Analizira generirano sliko za odkrivanje problematične vsebine."""
    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):
    """Celoten potek: moderacija poziva + generiranje + moderacija slike."""
    # 1. Preveri poziv
    check_prompt = verify_prompt(prompt)
    if not check_prompt["allowed"]:
        return {"status": "prompt_refused", "details": check_prompt}

    # 2. Generiraj sliko
    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. Preveri generirano sliko
    check_image = moderate_generated_image(output)
    if not check_image["safe"]:
        import os
        os.remove(output)
        return {
            "status": "image_deleted",
            "reason": "Generirana slika je bila označena",
            "categories": check_image["categories"]
        }

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

Ko uporabniki pišejo pozive

Vsebina, ki jo ustvarijo uporabniki, spremeni naravo problema: ne soočaš se več z nerodnostjo, temveč včasih z namernimi poskusi obida zaščit. Razred PromptModerator zastavi štiri obrambe različnih narav, kar je samo načelo resne zaščite. Čiščenje odstrani nadzorne znake, skozi katere potujejo injekcije, in omeji dolžino na petsto znakov, s čimer prekine pozive za poplavo, namenjene utopitvi navodil. Lokalno preverjanje prek seznama prepovedanih besed – pustimo praznega, da ga izpolniš glede na svojo politiko in sektor – prestreže brez stroška tisto, kar že veš. API za moderacijo nato prevzame vse, česar tvoj seznam ni predvidel. Nazadnje varnostna predpona, združena pred končnim pozivom, model izrecno spomni na pričakovani okvir in premakne mejo v tvojo korist pri robnih primerih.

from openai import OpenAI
import re

client = OpenAI()

class PromptModerator:
    """Večslojni filter za uporabniške pozive."""

    def __init__(self):
        self.forbidden_words = []  # Izpolni glede na svojo politiko
        self.security_prefix = (
            "Safe and appropriate image for all audiences. "
            "No violent, sexual, or discriminatory content. "
        )

    def clean(self, prompt: str) -> str:
        """Očisti in normalizira uporabniški poziv."""
        # Odstrani potencialne injekcije
        prompt = prompt.strip()
        # Omeji dolžino
        prompt = prompt[:500]
        # Odstrani nadzorne znake
        prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
        return prompt

    def check_words(self, prompt: str) -> bool:
        """Preveri odsotnost prepovedanih besed."""
        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:
        """Doda varnostno predpono pozivu."""
        return f"{self.security_prefix}{prompt}"

    def pipeline(self, raw_prompt: str) -> dict:
        """Celoten potek moderacije za uporabniški poziv."""
        # 1. korak: čiščenje
        prompt = self.clean(raw_prompt)

        # 2. korak: lokalno preverjanje
        if not self.check_words(prompt):
            return {"allowed": False, "reason": "Zaznana prepovedana beseda"}

        # 3. korak: moderacija prek API-ja
        check = verify_prompt(prompt)
        if not check["allowed"]:
            return {"allowed": False, "reason": check["message"]}

        # 4. korak: dodaj varnostno predpono
        final_prompt = self.secure(prompt)

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


moderator = PromptModerator()

# Simuliraj uporabniški poziv
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
    print(f"Varen poziv: {result['prompt']}")
else:
    print(f"Zavrnjeno: {result['reason']}")

Beleženje za odgovornost

Ko se problematična slika ponovno pojavi, bo vprašanje, ki ti ga bodo zastavili: kdo jo je zahteval, kdaj in kaj je storil tvoj sistem. Brez dnevnikov nimaš odgovora. AuditLogger zapiše eno vrstico JSON na generiranje v datoteko .jsonl – format samo za dodajanje, ki podpira sočasno pisanje in ga je mogoče brati vrstico za vrstico brez nalaganja vsega v pomnilnik. Vsak vnos poveže ID uporabnika s skrajšanim pozivom, izidom generiranja in po potrebi razlogom za zavrnitev. Metoda report nato izpelje stopnjo sprejetosti zadnjih sto generiranj in podrobnosti zavrnitev: to je nadzorna plošča, ki te bo opozorila, če določen račun kopiči označitve.

import json
import os
from datetime import datetime

class AuditLogger:
    """Revizijski dnevnik za generiranje slik."""

    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
    ):
        """Zapiše revizijski vnos."""
        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):
        """Ustvari poročilo o nedavnih generiranjih."""
        if not os.path.exists(self.log_file):
            print("Dnevnikov ni mogoče najti.")
            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"Poročilo o zadnjih {total} generiranjih:")
        print(f"  Sprejeto: {ok} ({100*ok/total:.1f}%)")
        print(f"  Zavrnjeno : {refused} ({100*refused/total:.1f}%)")

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


logger = AuditLogger()
logger.report()

Avtorske pravice in blagovne znamke

GPT Image zna proizvesti slike, ki evocirajo slog umetnika ali vizualno identiteto blagovne znamke, in prav ta sposobnost te izpostavlja. Tehnična moderacija te na tem področju ne ščiti: ne zazna, da plakat zelo spominja na konkurenčnega. Zaščita je zato pogodbeno-organizacijska, v obliki pisne, izvršljive politike uporabe, ki jo sprejmejo tvoji uporabniki in jo uporablja tvoja ekipa. Blok PRODUCTION_RULES podaja minimalno formulacijo, ki naj bo prikazana v tvoji dokumentaciji in opomnjena v tvojih pogojih.

# Najboljše prakse za vključitev v tvojo politiko uporabe

PRODUCTION_RULES = """
1. Ne zahtevaj posnemanja sloga živečega umetnika po imenu
2. Ne reproduciraj logotipov ali registriranih blagovnih znamk
3. Ne generiraj obrazov realnih ljudi
4. Dodaj opombo „slika, generirana z AI", kadar je zahtevano
5. Hrani dnevnike generiranja vsaj 12 mesecev
6. Omogoči uporabnikom poročanje o problematični vsebini
"""

def usage_warning():
    """Prikaže pravila uporabe v proizvodnji."""
    print("=" * 60)
    print("PRAVILA PROIZVODNJE — Generiranje slik z AI")
    print("=" * 60)
    print(PRODUCTION_RULES)

Skladnost z GDPR

Za evropsko podjetje obdobja hrambe in soglasja niso možnosti konfiguracije, temveč obveznosti, katerih spoštovanje mora biti dokazljivo. Njihov zapis v eksplicitnem konfiguracijskem predmetu namesto razpršenosti po kodi ti da eno samo mesto za pokaz med revizijo. ComplianceConfig tako nastavi hrambo dnevnikov na eno leto, hrambo slik na devetdeset dni in naredi opombo o AI ter soglasje obvezna. Metoda add_ai_metadata si zasluži posebno pozornost: v sam PNG zapisuje prek PngInfo dejstvo, da je slika generirana, orodje, ki jo je proizvedlo, in datum. Ti metapodatki potujejo z datoteko, tudi zunaj tvoje platforme, česar nobena opomba, prikazana na spletni strani, ne more.

class ComplianceConfig:
    """Konfiguracija skladnosti za generiranje slik."""

    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:
        """Preveri, ali je uporabnik dal soglasje za generiranje z AI."""
        # Implementiraj s svojim sistemom upravljanja soglasij
        return True

    def add_ai_metadata(self, image_path: str):
        """Doda metapodatke, ki kažejo na generiranje z 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"Metapodatki AI dodani: {image_path}")

Preden odpreš zapornice

Osem določb mora biti vzpostavljenih dan, ko tvoj sistem postane dostopen, in bolj pošteno jih je zahtevati prej kot kasneje. Najprej moderacija v dveh fazah: predhodno filtriranje pozivov in naknadno preverjanje slik, kot to počne secure_pipeline. Nato beleženje, popolno, ki povezuje vsako generiranje s pozivom, avtorjem in izidom – to je tvoj edini dokaz v primeru spora in mora biti shranjeno neodvisno od samih slik, sicer bi brisanje shrambe odneslo tudi tvojo sledljivost.

Nato pride uporabniška stran. Omejitev hitrosti na račun prepreči, da bi en sam naročnik porabil tvoj mesečni proračun v eni noči, namerno ali zaradi slabo napisane skripte. Informacija o generirani naravi slik se nanaša tako na poštenost kot na vse bolj regulativno omejitev; podvojena je s tehničnim označevanjem v metapodatkih PNG ali EXIF datoteke. Pravica do izbrisa predpostavlja, da lahko na preprosto zahtevo najdeš in izbrišeš vse podatke uporabnika, kar je mogoče le, če tvoji revizijski vnosi nosijo user_id. Nazadnje odpri kanal za poročanje: tvoji uporabniki bodo vedno prej videli, kaj je problematično, kot ti, in odvzem njihovega sredstva, da ti to povedo, problema ne odpravi.

Zdaj sestavi vse v eno storitev za generiranje slik: predhodno filtriranje pozivov prek API-ja za moderacijo in seznama besed, varnostna predpona, naknadno preverjanje proizvedene slike, revizijski dnevnik in metapodatki AI na vsaki datoteki. Preizkusi jo s petimi različnimi pozivi, od katerih mora biti vsaj eden zavrnjen – le tako lahko preveriš, ali tvoji varnostni ograji dejansko delujejo in niso le prisotni v kodi.

Preizkusi svoje znanje

Vizualno generiranje prek API-ja: potrdi reflekse pred proizvodnjo.

1. Kaj omogočata inpainting in outpainting?

Odgovor: Inpainting spremeni določeno področje obstoječe slike (zamenjava, popravilo); outpainting razširi sliko onkraj njenega prvotnega okvirja – dve ciljni urejanji brez ponovnega generiranja vsega.

2. Kaj naredi dober napreden vizualni poziv?

Odgovor: Opiši subjekt, kompozicijo, osvetlitev in perspektivo – ne le teme: bolj ko poziv okvirja sceno kot direktor fotografije, bolj slika uboga.

3. Kako učinkovito delati z iteracijami?

Odgovor: Začni z osnovnim generiranjem, nato zahtevaj ciljne variacije (slog, okvir, podrobnost) namesto prepisovanja poziva od začetka – obdrži tisto, kar deluje, prilagodi le vrzel.

4. Katere vzvode uporabiti za optimizacijo stroškov generiranja?

Odgovor: Prilagodi kakovost in ločljivost realni potrebi (osnutki v nizki, končni izdelki v visoki), omeji iteracije z boljšimi pozivi ter predpomni/ponovno uporabi potrjene vizuale.

5. Zakaj je moderacija vizualne vsebine bistvena?

Odgovor: Ker API in tvoji pogoji nalagajo omejitve (prepovedana vsebina, realni ljudje, blagovne znamke): filtriranje pozivov in nadzor izhodov ščiti tvoje uporabnike in tvojo aplikacijo.

Okvirjaj, iteriraj, obvladuj stroške in skladnost: vizualna proizvodnja je potek – ni met kocke.