Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Moderacija i sigurnost vizualnog sadržaja

Lekcija 12 od 12 Ažurirano 3. studenoga 2026. Programer
Na ovoj stranici
  1. Moderacija i sigurnost vizualnog sadržaja
  2. Ugrađeni sustav moderacije
  3. Prefiltriranje promptova
  4. Provjeri i generirane slike
  5. Kada korisnici pišu promptove
  6. Vođenje zapisa radi odgovornosti
  7. Autorska prava i žigovi
  8. Usklađenost s GDPR-om
  9. Prije otvaranja brana
  10. Testiraj svoje znanje

Ažurirano 3. studenoga 2026. na temelju OpenAI-jevog vodiča Image generation: Odbijanje zbog moderacije identificira se s error.code == "moderation_blocked", uz opcionalni objekt moderation_details, a ne prisutnošću riječi safety ili content_policy u poruci o pogrešci; dodan je parametar moderation (auto, low). Izvor: Image generation.

Ažuriranje 2. studenoga 2026. — Modeli za slike. gpt-image-1, na kojem je ovaj tečaj izvorno napisan, ukinut je 23. listopada 2026., a gpt-image-1.5, gpt-image-1-mini i chatgpt-image-latest bit će povučeni 1. prosinca 2026. Primjeri sada koriste gpt-image-2.5-sunburst, najprecizniji za uređivanje; gpt-image-2.5-flare je brži za standardno generiranje. Oba također prihvaćaju kvalitete xhigh i max. GPT Image modeli uvijek vraćaju sliku u base64 formatu: parametar response_format iz starijih DALL·E modela nije prihvaćen i uklonjen je iz koda. Izvor: Image generation (OpenAI).

Moderacija i sigurnost vizualnog sadržaja

Dok god generiraš slike za sebe, moderacija je stvar osobne procjene. Čim otvoriš generiranje korisnicima, ona postaje pravna i etička odgovornost koja te obvezuje. Ova lekcija pokriva OpenAI-jeve alate za moderaciju, kako ih povezati u uzastopne filtre i mjere koje štite i tvoju aplikaciju i ljude koji je koriste.

Ugrađeni sustav moderacije

GPT Image samostalno odbija određeni sadržaj—nasilje, seksualno eksplicitan materijal, između ostalog—i signalizira to odbijanje specifičnom pogreškom. Tvoj kod stoga mora razlikovati odbijanje zbog politike sadržaja od tehničkog kvara, jer ta dva zahtijevaju suprotne reakcije: prvo rezultira porukom korisniku, drugo upozorenjem tvom timu. OpenAI-jeva dokumentacija specificira diskriminator koji treba koristiti: odbijanje zbog moderacije dolazi kao BadRequestError s error.code jednakim moderation_blocked (tip image_generation_user_error), a tijelo pogreške može sadržavati objekt moderation_details koji specificira fazu (input, output ili unknown) i opće kategorije (harassment, sexual, violence…). Ne traži riječi u poruci o pogrešci: njezin tekst nije ugovor, kod jest. Funkcija u nastavku ponovno podiže iznimku samo ako nije riječ o odbijanju zbog moderacije.

from openai import OpenAI, BadRequestError

client = OpenAI()

def generate_with_moderation(prompt: str, output: str) -> dict:
    """Generira sliku uz rukovanje odbijanjima zbog 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čki kvar, kvota, nevažeći zahtjev: riješi drugdje
        body = e.body if isinstance(e.body, dict) else {}
        details = body.get("moderation_details") or {}
        return {
            "status": "refused",
            "reason": "Sadržaj odbijen zbog sigurnosne politike",
            "stage": details.get("moderation_stage"),        # input, output ili unknown
            "categories": details.get("categories") or [],  # za tvoje zapise
        }


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

OpenAI savjetuje da zadržiš generičku poruku za krajnjeg korisnika, a moderation_details rezerviraš za svoje zapise i podršku. Ove se pogreške ne rješavaju ponovnim pokušajem: bez modificiranja prompta ili priloženih slika, isti će zahtjev ponovno biti odbijen. Napokon, ozbiljnost filtriranja postavlja se parametrom moderation GPT Image modela: auto (standardno filtriranje, zadano) ili low (manje restriktivno).

Prefiltriranje promptova

Čekati da GPT Image odbije prompt prije nego što otkriješ da je problematičan nije zadovoljavajuće: već si potrošio API poziv, a ne saznaješ ništa specifično o razlogu. Moderation API je, međutim, besplatan, brz i vraća imenovane kategorije. Pozivanje prije generiranja omogućuje ti da čisto odbiješ zahtjev, objasniš korisniku što je označeno i zadržiš te informacije za svoju reviziju. Funkcija verify_prompt izvlači popis okinutih kategorija, a generate_safe_image jednostavno povezuje dva koraka: prvo provjeri, zatim generiraj.

from openai import OpenAI

client = OpenAI()

def verify_prompt(prompt: str) -> dict:
    """Provjerava prompt putem Moderation API-ja prije generiranja."""
    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": "Ovaj je prompt označen od strane sustava za moderaciju."
        }

    return {"allowed": True}


def generate_safe_image(prompt: str, output: str):
    """Kompletan pipeline: moderacija + generiranje."""
    # Korak 1: predfiltriranje
    check = verify_prompt(prompt)

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

    # Korak 2: generiranje
    print("Prompt validiran, generiram...")
    return generate_with_moderation(prompt, output)


# Test s bezopasnim promptom
generate_safe_image(
    "A mountain landscape with a crystal clear lake",
    "mountain.png"
)

Provjeri i generirane slike

Neduzan prompt može rezultirati slikom koja to nije. Zaobilazan način izražavanja, dvosmislenost pojma ili jednostavno nesretno tumačenje modela dovoljni su za proizvodnju vizualnog sadržaja koji ne bi želio/la prikazivati pod svojim logotipom. Model omni-moderation-latest prihvaća slike kao ulaz, što ti omogućuje da zatvoriš krug: ista mehanika kategorija primjenjuje se na generiranu datoteku. Kompletan pipeline u nastavku povezuje tri faze—provjera prompta, generiranje, provjera slike—i ključno, u slučaju označavanja, briše datoteku s diska prije vraćanja presude. Problematična slika ostavljena na poslužitelju „dok gledamo“ slika je koja će na kraju curiti.

from openai import OpenAI
import base64

client = OpenAI()

def moderate_generated_image(image_path: str) -> dict:
    """Analizira generiranu sliku radi otkrivanja problematičnog sadržaja."""
    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):
    """Kompletan pipeline: moderacija prompta + generiranje + moderacija slike."""
    # 1. Provjeri prompt
    check_prompt = verify_prompt(prompt)
    if not check_prompt["allowed"]:
        return {"status": "prompt_refused", "details": check_prompt}

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

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

Kada korisnici pišu promptove

Sadržaj koji generiraju korisnici mijenja prirodu problema: više se ne suočavaš s nespretnošću, već ponekad s namjernim pokušajima zaobilaženja zaštite. Klasa PromptModerator slaže četiri obrane različite prirode, što je sam princip ozbiljne zaštite. Čišćenje uklanja kontrolne znakove kroz koje prolaze injekcije i ograničava duljinu na petsto znakova, prekidajući flood promptove dizajnirane da utope instrukcije. Lokalna provjera putem popisa zabranjenih riječi—ostavljenog praznim, da se popuni prema tvojoj politici i sektoru—presreće nultim troškom ono što već znaš. Moderation API zatim preuzima sve što tvoj popis nije predvidio. Napokon, sigurnosni prefiks konkateniran prije konačnog prompta eksplicitno podsjeća model na očekivani okvir, pomičući granicu u tvoju korist za rubne slučajeve.

from openai import OpenAI
import re

client = OpenAI()

class PromptModerator:
    """Višeslojni filtar za korisničke promptove."""

    def __init__(self):
        self.forbidden_words = []  # Popuni prema svojoj politici
        self.security_prefix = (
            "Sigurna i prikladna slika za sve publike. "
            "Bez nasilnog, seksualnog ili diskriminatornog sadržaja. "
        )

    def clean(self, prompt: str) -> str:
        """Čisti i normalizira korisnički prompt."""
        # Ukloni potencijalne injekcije
        prompt = prompt.strip()
        # Ograniči duljinu
        prompt = prompt[:500]
        # Ukloni kontrolne znakove
        prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
        return prompt

    def check_words(self, prompt: str) -> bool:
        """Provjerava odsutnost zabranjenih riječi."""
        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 sigurnosni prefiks promptu."""
        return f"{self.security_prefix}{prompt}"

    def pipeline(self, raw_prompt: str) -> dict:
        """Kompletan pipeline moderacije za korisnički prompt."""
        # Korak 1: čišćenje
        prompt = self.clean(raw_prompt)

        # Korak 2: lokalna provjera
        if not self.check_words(prompt):
            return {"allowed": False, "reason": "Detektirana zabranjena riječ"}

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

        # Korak 4: dodaj sigurnosni prefiks
        final_prompt = self.secure(prompt)

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


moderator = PromptModerator()

# Simuliraj korisnički prompt
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
    print(f"Siguran prompt: {result['prompt']}")
else:
    print(f"Odbijeno: {result['reason']}")

Vođenje zapisa radi odgovornosti

Dan kada se problematična slika ponovno pojavi, pitanje koje će ti biti postavljeno je: tko ju je zatražio, kada i što je tvoj sustav učinio. Bez zapisa nemaš odgovor. AuditLogger piše jedan JSON redak po generiranju u .jsonl datoteku—format samo za dodavanje koji podržava istovremeno pisanje i može se čitati redak po redak bez učitavanja svega u memoriju. Svaki unos povezuje ID korisnika sa skraćenim promptom, ishodom generiranja i, ako je primjenjivo, razlogom odbijanja. Metoda report zatim izvodi stopu prihvaćanja tijekom posljednjih stotinu generiranja i detaljno opisuje odbijanja: ovo je nadzorna ploča koja će te upozoriti ako određeni račun akumulira oznake.

import json
import os
from datetime import datetime

class AuditLogger:
    """Revizijski zapis za generiranja slika."""

    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
    ):
        """Bilježi revizijski unos."""
        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):
        """Generira izvješće o nedavnim generiranjima."""
        if not os.path.exists(self.log_file):
            print("Nisu pronađeni zapisi.")
            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"Izvješće o posljednjih {total} generiranja:")
        print(f"  Prihvaćeno: {ok} ({100*ok/total:.1f}%)")
        print(f"  Odbijeno   : {refused} ({100*refused/total:.1f}%)")

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


logger = AuditLogger()
logger.report()

Autorska prava i žigovi

GPT Image zna proizvesti slike koje evociraju stil umjetnika ili vizualni identitet brenda, a ta je sposobnost upravo ono što te izlaže riziku. Tehnička moderacija te ne štiti na ovom terenu: ne detektira da poster jako podsjeća na konkurentov. Zaštita je stoga ugovorna i organizacijska, u obliku pisane, provedive politike korištenja koju tvoji korisnici prihvaćaju, a tvoj tim primjenjuje. Blok PRODUCTION_RULES daje minimalnu formulaciju, koju trebaš prikazati u svojoj dokumentaciji, kao i podsjetiti u svojim uvjetima.

# Najbolje prakse za integraciju u tvoju politiku korištenja

PRODUCTION_RULES = """
1. Ne traži imitaciju stila živućeg umjetnika po imenu
2. Ne reproduciraj logotipe ili registrirane žigove
3. Ne generiraj lica stvarnih ljudi
4. Dodaj obavijest „Slika generirana umjetnom inteligencijom“ kada je potrebno
5. Zadrži zapise o generiranju najmanje 12 mjeseci
6. Omogući korisnicima prijavu problematičnog sadržaja
"""

def usage_warning():
    """Prikazuje pravila korištenja u proizvodnji."""
    print("=" * 60)
    print("PRAVILA PROIZVODNJE — Generiranje slika AI-jem")
    print("=" * 60)
    print(PRODUCTION_RULES)

Usklađenost s GDPR-om

Za europsku tvrtku, razdoblja zadržavanja i pristanak nisu opcije konfiguracije, već obveze čije se poštovanje mora moći dokazati. Njihovo bilježenje u eksplicitnom konfiguracijskom objektu, umjesto raspršivanja kroz kod, daje ti jedno mjesto koje možeš pokazati tijekom revizije. ComplianceConfig tako postavlja zadržavanje zapisa na jednu godinu, zadržavanje slika na devedeset dana i čini obavijest o AI-ju i pristanak obaveznima. Metoda add_ai_metadata zaslužuje posebnu pozornost: ona upisuje u samu PNG datoteku, putem PngInfo, činjenicu da je slika generirana, alat koji ju je proizveo i datum. Ti metapodaci putuju s datotekom, uključujući izvan tvoje platforme, što nijedna obavijest prikazana na web stranici ne čini.

class ComplianceConfig:
    """Konfiguracija usklađenosti za generiranje slika."""

    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:
        """Provjerava je li korisnik dao pristanak za AI generiranje."""
        # Implementiraj sa svojim sustavom upravljanja pristankom
        return True

    def add_ai_metadata(self, image_path: str):
        """Dodaje metapodatke koji označavaju AI generiranje."""
        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 metapodaci dodani: {image_path}")

Prije otvaranja brana

Osam odredbi mora biti na mjestu dan kada tvoj sustav postane dostupan, a iskrenije ih je zatražiti prije nego poslije. Prvo moderacija, u svoje dvije faze: predfiltriranje promptova i post-provjera slika, kako to čini secure_pipeline. Zatim vođenje zapisa, kompletno, povezujući svako generiranje s njegovim promptom, autorom i ishodom—ovo je tvoj jedini dokaz u slučaju spora i mora se spremiti neovisno o samim slikama, inače bi brisanje pohrane odnijelo i tvoju sljedivost.

Zatim dolazi strana korisnika. Ograničenje stope (rate limit) po računu sprječava da jedan pretplatnik potroši tvoj mjesečni budžet u jednoj noći, namjerno ili putem loše napisane skripte. Informacija o generiranoj prirodi slika odnosi se i na pravednost i, sve više, na regulatorna ograničenja; udvostručena je tehničkim označavanjem u PNG ili EXIF metapodacima datoteke. Pravo na brisanje pretpostavlja da možeš pronaći i izbrisati sve podatke korisnika na jednostavan zahtjev, što je moguće samo ako tvoji revizijski unosi nose user_id. Napokon, otvori kanal za prijavu: tvoji će korisnici uvijek prije tebe vidjeti što je problematično, a oduzimanje sredstava da ti to kažu ne čini problem nestalim.

Sada sastavi sve u jednu uslugu generiranja slika: predfiltriranje promptova putem Moderation API-ja i popisa riječi, sigurnosni prefiks, post-provjera proizvedene slike, revizijski zapis i AI metapodaci na svakoj datoteci. Testiraj to s pet različitih promptova, od kojih barem jedan mora biti odbijen—ovo je jedini način da provjeriš rade li tvoje zaštitne ograde zapravo, a ne da su samo prisutne u kodu.

Testiraj svoje znanje

Vizualno generiranje putem API-ja: validiraj reflekse prije proizvodnje.

1. Što omogućuju inpainting i outpainting?

Odgovor: Inpainting modificira specifično područje postojeće slike (zamjena, ispravak); outpainting proširuje sliku izvan njezinog izvornog okvira—dva ciljana uređivanja bez ponovnog generiranja svega.

2. Što čini dobar napredni vizualni prompt?

Odgovor: Opiši subjekt, kompoziciju, osvjetljenje i perspektivu—ne samo temu: što više prompt okviruje scenu poput direktora fotografije, to će se slika više pokoravati.

3. Kako učinkovito raditi iteracijama?

Odgovor: Započni s baznim generiranjem, zatim zatraži ciljane varijacije (stil, okvir, detalj) umjesto prepisivanja prompta od nule—zadrži ono što funkcionira, samo prilagodi razliku.

4. Koje poluge koristiti za optimizaciju troškova generiranja?

Odgovor: Prilagodi kvalitetu i rezoluciju stvarnoj potrebi (nacrti u niskoj, finalni u visokoj), ograniči iteracije boljim promptovima i keširaj/ponovno koristi validirane vizuale.

5. Zašto je moderacija vizualnog sadržaja bitna?

Odgovor: Zato što API i tvoji uvjeti nameću ograničenja (zabranjeni sadržaj, stvarne osobe, brendovi): filtriranje promptova i kontrola izlaza štiti tvoje korisnike i tvoju aplikaciju.

Okvir, iteracija, mastery troškova i usklađenosti: vizualna proizvodnja je pipeline—nije bacanje kockice.