Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Moderavimas ir vaizdinio turinio saugumas

Paskaita 12 iš 12 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Moderavimas ir vaizdinio turinio saugumas
  2. Integruota moderavimo sistema
  3. Užuominų išankstinis filtravimas
  4. Tikrink ir sugeneruotus vaizdus
  5. Kai užuominas rašo naudotojai
  6. Žurnalų vedimas atsakomybei užtikrinti
  7. Autorių teisės ir prekių ženklai
  8. Atitiktis BDAR (GDPR)
  9. Prieš atveriant vartus
  10. Patikrink savo žinias

Atnaujinta 2026 m. lapkričio 3 d. pagal OpenAI Vaizdų generavimo gidą: Moderavimo atsisakymas nustatomas pagal error.code == "moderation_blocked" su neprivalomu moderation_details objektu, o ne pagal žodžių safety arba content_policy buvimą klaidos pranešime; pridėtas moderation parametras (auto, low). Šaltinis: Vaizdų generavimas.

2026 m. lapkričio 2 d. atnaujinimas — Vaizdų modeliai. gpt-image-1, kuriuo remiantis iš pradžių buvo rašomas šis kursas, buvo nutrauktas 2026 m. spalio 23 d., o gpt-image-1.5, gpt-image-1-mini ir chatgpt-image-latest bus pašalinti 2026 m. gruodžio 1 d. Pavyzdžiuose dabar naudojamas gpt-image-2.5-sunburst, tiksliausias redagavimui; gpt-image-2.5-flare yra greitesnis standartiniam generavimui. Abu taip pat priima xhigh ir max kokybes. GPT Image modeliai visada grąžina vaizdą base64 formatu: senesnių DALL·E modelių parametras response_format nėra priimamas ir buvo pašalintas iš kodo. Šaltinis: Vaizdų generavimas (OpenAI).

Moderavimas ir vaizdinio turinio saugumas

Kol generuoji vaizdus tik sau, moderavimas yra asmeninio sprendimo reikalas. Kai atveri generavimą naudotojams, tai tampa teisine ir etine atsakomybe, kuri tave įpareigoja. Šioje pamokoje aptarsime OpenAI moderavimo įrankius, kaip juos sujungti į nuoseklius filtrus ir kokios priemonės apsaugo tiek tavo programą, tiek žmones, kurie ja naudojasi.

Integruota moderavimo sistema

GPT Image pats atmeta tam tikrą turinį – smurtą, seksualinio pobūdžio medžiagą ir kita – ir apie šį atmetimą praneša specifine klaida. Todėl tavo kodas turi atskirti turinio politikos atsisakymą nuo techninio gedimo, nes šie du atvejai reikalauja priešingų veiksmų: pirmuoju atveju naudotojui siunčiamas pranešimas, antruoju – įspėjimas tavo komandai. OpenAI dokumentacijoje nurodytas diskriminatorius: moderavimo atsisakymas ateina kaip BadRequestError, kurio error.code lygus moderation_blocked (tipas image_generation_user_error), o klaidos kūne gali būti moderation_details objektas, nurodantis etapą (input, output arba unknown) ir bendras kategorijas (harassment, sexual, violence…). Neieškok žodžių klaidos pranešimo tekste: jo tekstas nėra sutartis, kodas yra. Toliau pateikta funkcija išmeta išimtį iš naujo tik tada, jei tai nėra moderavimo atsisakymas.

from openai import OpenAI, BadRequestError

client = OpenAI()

def generate_with_moderation(prompt: str, output: str) -> dict:
    """Generuoja vaizdą, tvarkydamas moderavimo atsisakymus."""
    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  # techninis gedimas, kvota, neteisinga užklausa: tvarkyti kitur
        body = e.body if isinstance(e.body, dict) else {}
        details = body.get("moderation_details") or {}
        return {
            "status": "refused",
            "reason": "Turinys atmestas dėl saugumo politikos",
            "stage": details.get("moderation_stage"),        # input, output arba unknown
            "categories": details.get("categories") or [],  # tavo žurnalams
        }


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

OpenAI pataria galutiniam naudotojui palikti bendrą pranešimą, o moderation_details skirti tik tavo žurnalams ir pagalbai. Šios klaidos neišsprendžiamos kartojant bandymą: nepakeitus užuominos ar pateiktų vaizdų, tas pats prašymas vėl bus atmestas. Galiausiai atkreipk dėmesį, kad filtravimo griežtumą nustato GPT Image modelių parametras moderation: auto (standartinis filtravimas, numatytasis) arba low (mažiau ribojantis).

Užuominų išankstinis filtravimas

Laukti, kol GPT Image atmes užuominą, ir tik tada sužinoti, kad ji buvo problematiška, yra nepatenkinama: jau sunaudojai API kvietimą ir nieko konkrečiai nesužinojai apie priežastį. Tačiau Moderavimo API yra nemokamas, greitas ir grąžina įvardytas kategorijas. Iškvietus jį prieš generavimą, gali švariai atmesti užuominą, paaiškinti naudotojui, kas buvo pažymėta, ir išsaugoti šią informaciją auditui. Funkcija verify_prompt ištraukia suaktyvintų kategorijų sąrašą, o generate_safe_image tiesiog sujungia du žingsnius: pirmiausia patikrina, paskui generuoja.

from openai import OpenAI

client = OpenAI()

def verify_prompt(prompt: str) -> dict:
    """Patikrina užuominą naudojant Moderavimo API prieš generavimą."""
    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": "Ši užuomina buvo pažymėta moderavimo sistemos."
        }

    return {"allowed": True}


def generate_safe_image(prompt: str, output: str):
    """Pilnas procesas: moderavimas + generavimas."""
    # 1 žingsnis: išankstinis filtravimas
    check = verify_prompt(prompt)

    if not check["allowed"]:
        print(f"Užuomina atmesta: {check['message']}")
        print(f"Kategorijos: {check['categories']}")
        return None

    # 2 žingsnis: generavimas
    print("Užuomina patvirtinta, generuojama...")
    return generate_with_moderation(prompt, output)


# Testavimas su nekenksminga užuomina
generate_safe_image(
    "A mountain landscape with a crystal clear lake",
    "mountain.png"
)

Tikrink ir sugeneruotus vaizdus

Nekalta užuomina gali sukurti vaizdą, kuris toks nėra. Užuolankus formulavimas, termino dviprasmybė arba tiesiog nepavykusi modelio interpretacija pakanka, kad atsirastų vaizdinis turinys, kurio nenorėtum matyti po savo logotipu. Modelis omni-moderation-latest kaip įvestį priima vaizdus, todėl gali užbaigti ciklą: tos pačios kategorijų taisyklės taikomos ir sugeneruotam failui. Toliau pateiktame pilname procese sujungti trys etapai – užuominos tikrinimas, generavimas, vaizdo tikrinimas – ir, svarbiausia, pažymėjus problemą, failas ištrinamas iš disko prieš grąžinant verdiktą. Probleminis vaizdas, paliktas serveryje „kol pasižiūrėsime“, yra vaizdas, kuris anksčiau ar vėliau nutekės.

from openai import OpenAI
import base64

client = OpenAI()

def moderate_generated_image(image_path: str) -> dict:
    """Analizuoja sugeneruotą vaizdą, aptinkant problematišką turinį."""
    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):
    """Pilnas procesas: užuominos moderavimas + generavimas + vaizdo moderavimas."""
    # 1. Patikrink užuominą
    check_prompt = verify_prompt(prompt)
    if not check_prompt["allowed"]:
        return {"status": "prompt_refused", "details": check_prompt}

    # 2. Sugeneruok vaizdą
    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. Patikrink sugeneruotą vaizdą
    check_image = moderate_generated_image(output)
    if not check_image["safe"]:
        import os
        os.remove(output)
        return {
            "status": "image_deleted",
            "reason": "Sugeneruotas vaizdas buvo pažymėtas",
            "categories": check_image["categories"]
        }

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

Kai užuominas rašo naudotojai

Naudotojų kuriamas turinys keičia problemos pobūdį: susiduri nebe su netyčiniais nusižengimais, o kartais ir su tyčiniais bandymais apeiti taisykles. Klasė PromptModerator sujungia keturias skirtingo pobūdžio gynybos linijas – tai ir yra rimtos apsaugos principas. Valymas pašalina valdymo simbolius, kuriais keliauja injekcijos, ir apriboja ilgį iki penkių šimtų simbolių, taip sustabdydamas „potvynio“ užuominas, skirtas nuskandinti instrukcijas. Vietinis tikrinimas pagal draudžiamų žodžių sąrašą (paliktas tuščias, kad jį užpildytum pagal savo politiką ir sektorių) nuliniu kaštu perima tai, ką jau žinai. Tada Moderavimo API perima viską, ko tavo sąrašas nenumatė. Galiausiai saugumo priešdėlis, pridėtas prieš galutinę užuominą, aiškiai primena modeliui numatytas ribas, palenkdamas pusiausvyrą tavo naudai ribiniais atvejais.

from openai import OpenAI
import re

client = OpenAI()

class PromptModerator:
    """Daugiasluoksnis naudotojų užuominų filtras."""

    def __init__(self):
        self.forbidden_words = []  # Užpildyk pagal savo politiką
        self.security_prefix = (
            "Saugus ir tinkamas vaizdas visoms auditorijoms. "
            "Jokio smurto, seksualinio ar diskriminacinio turinio. "
        )

    def clean(self, prompt: str) -> str:
        """Išvalo ir normalizuoja naudotojo užuominą."""
        # Pašalink potencialias injekcijas
        prompt = prompt.strip()
        # Apribok ilgį
        prompt = prompt[:500]
        # Pašalink valdymo simbolius
        prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
        return prompt

    def check_words(self, prompt: str) -> bool:
        """Patikrina, ar nėra draudžiamų žodž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:
        """Prideda saugumo priešdėlį prie užuominos."""
        return f"{self.security_prefix}{prompt}"

    def pipeline(self, raw_prompt: str) -> dict:
        """Pilnas naudotojo užuominos moderavimo procesas."""
        # 1 žingsnis: valymas
        prompt = self.clean(raw_prompt)

        # 2 žingsnis: vietinis tikrinimas
        if not self.check_words(prompt):
            return {"allowed": False, "reason": "Aptiktas draudžiamas žodis"}

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

        # 4 žingsnis: pridėk saugumo priešdėlį
        final_prompt = self.secure(prompt)

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


moderator = PromptModerator()

# Simuliuok naudotojo užuominą
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
    print(f"Saugi užuomina: {result['prompt']}")
else:
    print(f"Atmesta: {result['reason']}")

Žurnalų vedimas atsakomybei užtikrinti

Tą dieną, kai iškils problematiškas vaizdas, tau bus задаtas klausimas: kas jo paprašė, kada ir ką tavo sistema darė. Be žurnalų neturėsi atsakymo. AuditLogger į .jsonl failą rašo vieną JSON eilutę kiekvienam generavimui – tai tik papildomas formatas, palaikantis lygiagretų rašymą ir leidžiantis skaityti eilutę po eilutės neįkeliant visko į atmintį. Kiekvienas įrašas susieja naudotojo ID su sutrumpinta užuomina, generavimo rezultatu ir, jei taikoma, atsisakymo priežastimi. Metodas report tada apskaičiuoja priėmimo rodiklį per paskutinius šimtą generavimų ir išsamiai aprašo atsisakymus: tai yra skydelis, kuris tave įspės, jei tam tikra paskyra kaupia žymas.

import json
import os
from datetime import datetime

class AuditLogger:
    """Vaizdų generavimo audito žurnalas."""

    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
    ):
        """Įrašo audito įrašą."""
        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):
        """Generuoja paskutinių generavimų ataskaitą."""
        if not os.path.exists(self.log_file):
            print("Žurnalų nerasta.")
            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"Paskutinių {total} generavimų ataskaita:")
        print(f"  Priimta: {ok} ({100*ok/total:.1f}%)")
        print(f"  Atmesta : {refused} ({100*refused/total:.1f}%)")

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


logger = AuditLogger()
logger.report()

Autorių teisės ir prekių ženklai

GPT Image moka kurti vaizdus, kurie primena menininko stilių arba prekės ženklo vizualinį identitetą, ir būtent ši galimybė tave eksponuoja. Techninis moderavimas šiuo klausimu tavęs neapsaugo: jis nepastebi, kad plakatas labai panašus į konkurento. Todėl apsauga yra sutartinė ir organizacinė – tai rašytinė, vykdytina naudojimo politika, kurią priima tavo naudotojai ir taiko tavo komanda. Blokas PRODUCTION_RULES pateikia minimalią formuluotę, kurią turi rodyti savo dokumentacijoje ir priminti savo sąlygose.

# Geriausios praktikos, integruotinos į naudojimo politiką

PRODUCTION_RULES = """
1. Neprašyk imituoti gyvo menininko stiliaus pagal vardą
2. Neatkartok logotipų arba registruotų prekių ženklų
3. Negeneruok realių žmonių veidų
4. Prireikus pridėk pastabą „AI sugeneruotas vaizdas“
5. Saugok generavimo žurnalus bent 12 mėnesių
6. Leisk naudotojams pranešti apie problematišką turinį
"""

def usage_warning():
    """Rodo gamybos naudojimo taisykles."""
    print("=" * 60)
    print("GAMYBOS TAISYKLĖS — DI dirbtinių vaizdų generavimas")
    print("=" * 60)
    print(PRODUCTION_RULES)

Atitiktis BDAR (GDPR)

Europos įmonei saugojimo terminai ir sutikimas nėra konfigūracijos parinktys, o įpareigojimai, kurių laikymasis turi būti įrodomas. Įrašius juos į aiškų konfigūracijos objektą, o ne išbarščius per kodą, turėsi vieną vietą, kurią galėsi parodyti audito metu. ComplianceConfig nustato žurnalų saugojimą vieneriems metams, vaizdų – devyniasdešimčiai dienų, ir daro privalomais DI pastabą bei sutikimą. Ypatingo dėmesio nusipelno metodas add_ai_metadata: jis įrašo tiesiai į PNG failą, naudodamas PngInfo, faktą, kad vaizdas sugeneruotas, įrankį, kuris jį sukūrė, ir datą. Šie metaduomenys keliauja kartu su failu, net ir už tavo platformos ribų – to negali padaryti joks pranešimas, rodomas tinklalapyje.

class ComplianceConfig:
    """Vaizdų generavimo atitikties konfigūracija."""

    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:
        """Patikrina, ar naudotojas davė sutikimą DI generavimui."""
        # Įgyvendink su savo sutikimų valdymo sistema
        return True

    def add_ai_metadata(self, image_path: str):
        """Prideda metaduomenis, nurodančius DI generavimą."""
        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"DI metaduomenys pridėti: {image_path}")

Prieš atveriant vartus

Aštuonios nuostatos turi būti įgyvendintos tą dieną, kai tavo sistema tampa prieinama, ir sąžiningiau jų paprašyti prieš, o ne po. Pirmiausia – moderavimas dviem etapais: užuominų išankstinis filtravimas ir sugeneruotų vaizdų patikrinimas po to, kaip tai daro secure_pipeline. Toliau – išsamus žurnalų vedimas, siejantis kiekvieną generavimą su jo užuomina, autoriumi ir rezultatu; tai vienintelis tavo įrodymas ginčo atveju, ir jis turi būti saugomas nepriklausomai nuo pačių vaizdų, kitaip saugyklos išvalymas ištrintų ir tavo atsekamumą.

Tada eina naudotojų pusė. Paskyros užklausų dažnio ribojimas neleidžia vienam prenumeratoriui per vieną naktį sunaudoti tavo mėnesinio biudžeto – tyčia arba dėl blogai parašyto scenarijaus. Informacija apie sugeneruotą vaizdų pobūdį susijusi tiek su sąžiningumu, tiek, vis labiau, su reguliavimo reikalavimais; ji papildoma techniniu žymėjimu failo PNG arba EXIF metaduomenyse. Teisė būti pamirštam reiškia, kad paprasto prašymo pagrindu gali rasti ir ištrinti visus naudotojo duomenis, o tai įmanoma tik tada, jei tavo audito įrašuose yra user_id. Galiausiai atverk pranešimų kanalą: tavo naudotojai visada pastebės tai, kas problematiška, anksčiau nei tu, o atimti iš jų galimybę tau apie tai pranešti neišsprendžia problemos.

Dabar sujunk visa tai į vieną vaizdų generavimo servisą: užuominų išankstinis filtravimas naudojant Moderavimo API ir žodžių sąrašą, saugumo priešdėlis, sugeneruoto vaizdo patikrinimas po to, audito žurnalas ir DI metaduomenys kiekviename faile. Ištestuok jį su penkiomis įvairiomis užuominomis, iš kurių bent viena turi būti atmesta – tai vienintelis būdas patikrinti, ar tavo apsaugos mechanizmai iš tikrųjų veikia, o ne tik yra kode.

Patikrink savo žinias

Vaizdų generavimas per API: patvirtink refleksus prieš gamybą.

1. Ką leidžia daryti inpainting ir outpainting?

Atsakymas: Inpainting modifikuoja konkrečią esamo vaizdo sritį (pakeičia, taiso); outpainting pratęsia vaizdą už jo originalių rėmų – du tiksliniai redagavimai negeneruojant visko iš naujo.

2. Kas sudaro gerą pažangią vaizdinę užuominą?

Atsakymas: Aprašyk objektą, kompoziciją, apšvietimą ir perspektyvą – ne tik temą: kuo labiau užuomina kadruoja sceną kaip operatorius, tuo labiau vaizdas paklūsta.

3. Kaip efektyviai dirbti iteracijomis?

Atsakymas: Pradėk nuo bazinio generavimo, tada prašyk tikslinių variacijų (stilius, kadras, detalės), o ne rašyk užuominą iš naujo – palik tai, kas veikia, ir koreguok tik skirtumus.

4. Kokius svertus naudoti generavimo išlaidoms optimizuoti?

Atsakymas: Pritaikyk kokybę ir skiriamąją gebą realiam poreikiui (juodraščiai – žema, galutiniai – aukšta), apribok iteracijas geresnėmis užuominomis ir talpykloje saugok bei pakartotinai naudok patvirtintus vaizdus.

5. Kodėl vaizdinio turinio moderavimas yra esminis?

Atsakymas: Nes API ir tavo sąlygos nustato ribas (draudžiamas turinys, realūs žmonės, prekių ženklai): užuominų filtravimas ir išvesties kontrolė apsaugo tavo naudotojus ir tavo programą.

Kadruok, kartok, valdyk išlaidas ir atitiktį: vaizdų gamyba yra procesas, o ne atsitiktinumas.