Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Moderatsioon ja visuaalse sisu turvalisus

Õppetund 12 / 12 Värskendatud 3. november 2026 Arendajatele
Sellel lehel
  1. Moderatsioon ja visuaalse sisu turvalisus
  2. Sisseehitatud moderatsioonisüsteem
  3. Vihjete eelfiltreerimine
  4. Kontrolli ka genereeritud pilte
  5. Kui kasutajad kirjutavad vihjeid
  6. Logimine aruandluskohustuse täitmiseks
  7. Autoriõigus ja kaubamärgid
  8. Vastavus GDPR-ile
  9. Enne lüüside avamist
  10. Testi oma teadmisi

Uuendatud 3. novembril 2026 vastavalt OpenAI pildigeneratsiooni juhendile: moderatsiooni tagasilükkamine tuvastatakse koodiga error.code == "moderation_blocked" ja valikulise objektiga moderation_details, mitte sõnade safety või content_policy olemasoluga veateates; lisatud parameeter moderation (auto, low). Allikas: Pildigeneratsioon.

2. novembri 2026 uuendus — Pildimudelid. gpt-image-1, mille põhjal see kursus algselt kirjutati, lõpetati 23. oktoobril 2026 ning mudelid gpt-image-1.5, gpt-image-1-mini ja chatgpt-image-latest retireeritakse 1. detsembril 2026. Näited kasutavad nüüd mudelit gpt-image-2.5-sunburst, mis on redigeerimisel kõige täpsem; gpt-image-2.5-flare on tavapäraseks generatsiooniks kiirem. Mõlemad aktsepteerivad ka kvaliteete xhigh ja max. GPT Image mudelid tagastavad pildi alati base64-koodingus: vanematelt DALL·E mudelitelt pärit parameetrit response_format ei aktsepteerita ja see on koodist eemaldatud. Allikas: Pildigeneratsioon (OpenAI).

Moderatsioon ja visuaalse sisu turvalisus

Seni, kuni genereerid pilte ainult enda jaoks, on moderatsioon isikliku otsustamise küsimus. Kui avad generatsiooni kasutajatele, muutub see juriidiliseks ja eetiliseks vastutuseks, mis sind seob. See tund käsitleb OpenAI moderatsioonitööriistu, viisi, kuidas need järjestikusteks filtriteks aheldada, ning meetmeid, mis kaitsevad nii sinu rakendust kui ka inimesi, kes seda kasutavad.

Sisseehitatud moderatsioonisüsteem

GPT Image keeldub teatud sisust iseseisvalt – vägivald, seksuaalselt eksplitsiitne materjal ja muu – ning annab sellest keeldumisest märku konkreetse veaga. Sinu kood peab seetõttu eristama sisupoliitika põhjal tehtud keeldumist tehnilisest rikkest, sest need nõuavad vastupidist reaktsiooni: esimesel juhul saadad kasutajale teate, teisel juhul teavitad oma meeskonda. OpenAI dokumentatsioon täpsustab kasutatavat eristajat: moderatsiooni tagasilükkamine saabub kui BadRequestError, kus error.code on võrdne väärtusega moderation_blocked (tüüp image_generation_user_error), ja vea keha võib sisaldada objekti moderation_details, mis täpsustab etappi (input, output või unknown) ning üldkategooriaid (harassment, sexual, violence…). Ära otsi sõnu veateatest: selle tekst ei ole leping, kood on. Allpool olev funktsioon viskab erandi uuesti välja ainult siis, kui tegemist ei ole moderatsiooni tagasilükkamisega.

from openai import OpenAI, BadRequestError

client = OpenAI()

def generate_with_moderation(prompt: str, output: str) -> dict:
    """Generates an image while handling moderation refusals."""
    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  # technical failure, quota, invalid request: handle elsewhere
        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 or unknown
            "categories": details.get("categories") or [],  # for your logs
        }


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

OpenAI soovitab hoida lõppkasutaja jaoks üldist teadet ja reserveerida moderation_details oma logide ja tugiteenuse jaoks. Need vead ei lahene uuesti proovides: ilma vihjet või pakutud pilte muutmata lükatakse sama päring uuesti tagasi. Pane tähele ka seda, et filtreerimise ranguse määrab GPT Image mudelite parameeter moderation: auto (standardne filtreerimine, vaikimisi) või low (vähem piirav).

Vihjete eelfiltreerimine

Ootamine, kuni GPT Image vihje tagasi lükkab, enne kui avastad selle problemaatiliseks olemist, on ebapiisav: oled juba API päringu ära tarbinud ja ei saa teada konkreetset põhjust. Moderatsiooni API on aga tasuta, kiire ja tagastab nimetatud kategooriad. Selle kutsumine enne generatsiooni võimaldab sul puhtalt keelduda, selgitada kasutajale, mis märgistati, ja säilitada see teave auditeerimiseks. Funktsioon verify_prompt ekstraheerib käivitatud kategooriate loendi ja generate_safe_image lihtsalt aheldab kaks sammu: kõigepealt kontroll, seejärel generatsioon.

from openai import OpenAI

client = OpenAI()

def verify_prompt(prompt: str) -> dict:
    """Checks a prompt with the Moderation API before generation."""
    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):
    """Complete pipeline: moderation + generation."""
    # Step 1: pre-filtering
    check = verify_prompt(prompt)

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

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


# Test with a harmless prompt
generate_safe_image(
    "A mountain landscape with a crystal clear lake",
    "mountain.png"
)

Kontrolli ka genereeritud pilte

Süütu vihje võib anda tulemuseks pildi, mis seda pole. Ümberütlemine, termini mitmetimõistetavus või lihtsalt ebaõnnestunud mudeli tõlgendus võib piisata visuaalse sisu loomiseks, mida sa ei tahaks oma logo all näidata. Mudel omni-moderation-latest aktsepteerib sisendina pilte, võimaldades sul ahela sulgeda: samad kategooria mehhanismid kehtivad genereeritud faili kohta. Allpool olev täielik torustik aheldab kolm faasi – vihje kontroll, generatsioon, pildi kontroll – ja mis on kriitiline: lipu korral kustutatakse fail kettalt enne otsuse tagastamist. Probleemne pilt, mis jääb serverisse „seniks, kuni vaatame“, on pilt, mis lõpuks lekib.

from openai import OpenAI
import base64

client = OpenAI()

def moderate_generated_image(image_path: str) -> dict:
    """Analyzes a generated image to detect problematic content."""
    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):
    """Complete pipeline: prompt moderation + generation + image moderation."""
    # 1. Check the prompt
    check_prompt = verify_prompt(prompt)
    if not check_prompt["allowed"]:
        return {"status": "prompt_refused", "details": check_prompt}

    # 2. Generate the image
    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. Check the generated image
    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}

Kui kasutajad kirjutavad vihjeid

Kasutaja loodud sisu muudab probleemi olemust: sa ei tegele enam kohmakusega, vaid mõnikord tahtlike katsetega süsteemist mööda hiilida. Klass PromptModerator virnastab nelja erinevat laadi kaitset, mis on tõsise kaitse printsiip ise. Puhastamine eemaldab juhtmärgid, mille kaudu injektsioonid liiguvad, ja piirab pikkuse viiesaja märgiga, lõigates ära üleujutusvihjed, mis on mõeldud juhiste uputamiseks. Kohalik kontroll keelatud sõnade nimekirja abil – jäetud tühjaks, et täita vastavalt sinu poliitikale ja sektorile – püüab nullkuluga kinni selle, mida juba tead. Seejärel võtab Moderatsiooni API üle kõik, mida sinu nimekiri ei ennustanud. Lõpuks tuletab turvalisuse prefiks, liidetud enne lõplikku vihjet, mudelile sõnaselgelt meelde oodatavat raamistikku, nihutades piiri äärmusjuhtudel sinu kasuks.

from openai import OpenAI
import re

client = OpenAI()

class PromptModerator:
    """Multi-layer filter for user prompts."""

    def __init__(self):
        self.forbidden_words = []  # Fill according to your policy
        self.security_prefix = (
            "Safe and appropriate image for all audiences. "
            "No violent, sexual, or discriminatory content. "
        )

    def clean(self, prompt: str) -> str:
        """Cleans and normalizes a user prompt."""
        # Remove potential injections
        prompt = prompt.strip()
        # Limit length
        prompt = prompt[:500]
        # Remove control characters
        prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
        return prompt

    def check_words(self, prompt: str) -> bool:
        """Checks for absence of forbidden words."""
        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:
        """Adds a security prefix to the prompt."""
        return f"{self.security_prefix}{prompt}"

    def pipeline(self, raw_prompt: str) -> dict:
        """Complete moderation pipeline for a user prompt."""
        # Step 1: cleaning
        prompt = self.clean(raw_prompt)

        # Step 2: local verification
        if not self.check_words(prompt):
            return {"allowed": False, "reason": "Forbidden word detected"}

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

        # Step 4: add security prefix
        final_prompt = self.secure(prompt)

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


moderator = PromptModerator()

# Simulate a user prompt
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']}")

Logimine aruandluskohustuse täitmiseks

Päeval, mil probleemne pilt uuesti pinnale tõuseb, on küsimus, mida sinult küsitakse: kes selle tellis, millal ja mida sinu süsteem tegi. Ilma logideta pole sul vastust. AuditLogger kirjutab ühe JSON-realise kirje generatsiooni kohta faili .jsonl – see on ainult lisamisrežiimis vorming, mis toetab samaaegset kirjutamist ja mida saab rida-realt lugeda ilma kõike mällu laadimata. Iga kirje seob kasutaja ID lühendatud vihjega, generatsiooni tulemusega ja vajadusel tagasilükkamise põhjusega. Meetod report tuletab seejärel vastuvõtmismäära viimase saja generatsiooni põhjal ja detailselt tagasilükkamised: see on armatuurlaud, mis hoiatab sind, kui konkreetne konto kogub lippe.

import json
import os
from datetime import datetime

class AuditLogger:
    """Audit log for image generations."""

    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
    ):
        """Logs an audit entry."""
        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):
        """Generates a report of recent generations."""
        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()

Autoriõigus ja kaubamärgid

GPT Image oskab luua pilte, mis äratavad esile kunstniku stiili või brändi visuaalse identiteedi, ja just see võimekus sind ohustab. Tehniline moderatsioon sind selles osas ei kaitse: see ei tuvasta, et plakat näeb välja väga sarnane konkurendi omale. Kaitse on seetõttu lepinguline ja organisatsiooniline, väljendudes kirjalikus ja jõustatavas kasutamispoliitikas, mida sinu kasutajad aktsepteerivad ja sinu meeskond rakendab. Plokk PRODUCTION_RULES annab minimaalse sõnastuse, mis tuleb kuvada sinu dokumentatsioonis ning meenutada tingimustes.

# Best practices to integrate into your usage policy

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():
    """Displays production usage rules."""
    print("=" * 60)
    print("PRODUCTION RULES — AI Image Generation")
    print("=" * 60)
    print(PRODUCTION_RULES)

Vastavus GDPR-ile

Euroopa ettevõtte jaoks ei ole säilitustähtajad ja nõusolekud konfiguratsioonivalikud, vaid kohustused, mille täitmist tuleb tõendada. Nende salvestamine selgesse konfiguratsiooniobjekti, mitte koodi laiali pillutamine, annab sulle auditi ajal ühe koha, mida näidata. ComplianceConfig seab seega logide säilitusajaks ühe aasta, piltide säilitusajaks üheksakümmend päeva ja teeb AI-teatise ning nõusoleku kohustuslikuks. Meetod add_ai_metadata väärib erilist tähelepanu: see kirjutab otse PNG-faili, kasutades PngInfo, fakti, et pilt on genereeritud, tööriista, mis selle lõi, ja kuupäeva. Need metaandmed reisivad failiga kaasas, ka väljaspool sinu platvormi, mida ükski veebilehel kuvatav teade ei tee.

class ComplianceConfig:
    """Compliance configuration for image generation."""

    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:
        """Verifies that the user has consented to AI generation."""
        # Implement with your consent management system
        return True

    def add_ai_metadata(self, image_path: str):
        """Adds metadata indicating AI generation."""
        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}")

Enne lüüside avamist

Kaheksa sätet peavad olema paigas päeval, mil sinu süsteem muutub ligipääsetavaks, ja ausam on neid küsida enne kui pärast. Esiteks moderatsioon oma kahes faasis: vihjete eelfiltreerimine ja piltide järelkontroll, nagu secure_pipeline teeb. Seejärel logimine, täielik, seostades iga generatsiooni selle vihje, autori ja tulemusega – see on sinu ainus tõend vaidluse korral ja see tuleb salvestada sõltumatult piltidest endist, vastasel juhul viib salvestusruumi puhastamine kaasa ka sinu jälgitavuse.

Siis tuleb kasutaja pool. Määra piirang kontole, et vältida olukorda, kus üks tellija tarbib sinu kuu eelarvet ühe ööga, kas tahtlikult või halvasti kirjutatud skripti tõttu. Teave piltide genereeritud olemuse kohta puudutab nii ausust kui ka üha enam regulatiivset nõuet; seda toetab tehniline märgistus faili PNG või EXIF metaandmetes. Kustutamisõigus eeldab, et suudad lihtsal taotlusel leida ja kustutada kõik kasutaja andmed, mis on võimalik ainult siis, kui sinu auditi kirjed kannavad user_id. Lõpuks ava raportikanal: sinu kasutajad näevad alati problemaatilist sisu enne sind ja nende võimaluse ära võtmine sulle sellest teada anda ei pane probleemi kaduma.

Nüüd pane kogu see kokku üheks pildigeneratsiooni teenuseks: vihjete eelfiltreerimine Moderatsiooni API ja sõnaloendi kaudu, turvalisuse prefiks, loodud pildi järelkontroll, auditi logi ja AI-metaandmed igal failil. Testi seda viie erineva vihjega, millest vähemalt üks peab tagasi lükatama – see on ainus viis kontrollida, kas sinu kaitseraudteed tegelikult töötavad, mitte lihtsalt koodis ei eksisteeri.

Testi oma teadmisi

Visuaalne generatsioon API kaudu: valideeri refleksid enne tootmist.

1. Mida võimaldavad inpainting ja outpainting?

Vastus: Inpainting muudab olemasoleva pildi kindlat piirkonda (asendamine, parandamine); outpainting laiendab pilti väljapoole selle algset raami – kaks sihipärast redigeerimist ilma kõike uuesti genereerimata.

2. Mis teeb täiustatud visuaalsest vihjest hea?

Vastus: Kirjelda subjekti, kompositsiooni, valgustust ja perspektiivi – mitte ainult teemat: mida rohkem raamib vihje stseeni nagu filmioperaator, seda kuulekam on pilt.

3. Kuidas iteratsioonidega tõhusalt töötada?

Vastus: Alusta baasgeneratsioonist ja seejärel taotle sihipäraseid variatsioone (stiil, kaader, detail), mitte ära kirjuta vihjet nullist – säilita see, mis toimib, ja kohanda vaid puudujääki.

4. Millid hoovad generatsioonikulude optimeerimiseks?

Vastus: Kohanda kvaliteet ja eraldusvõime tegelikule vajadusele (mustandid madalas, lõplikud kõrges), piira iteratsioone paremate vihjetega ja vahemällu salvesta/kasuta uuesti valideeritud visuaale.

5. Miks on visuaalse sisu moderatsioon hädavajalik?

Vastus: Sest API ja sinu tingimused kehtestavad piirangud (keelatud sisu, reaalsed inimesed, brändid): vihjete filtreerimine ja väljundite kontrollimine kaitseb sinu kasutajaid ja rakendust.

Raami, iteratsiooni, valda kulusid ja vastavust: visuaalne tootmine on torustik – mitte täringu veeretamine.