Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Moderointi ja visuaalisen sisällön turvallisuus

Oppitunti 12 / 12 Päivitetty 3. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Moderointi ja visuaalisen sisällön turvallisuus
  2. Sisäänrakennettu moderointijärjestelmä
  3. Kehotteiden esisuodatus
  4. Tarkista myös generoidut kuvat
  5. Kun käyttäjät kirjoittavat kehotteet
  6. Lokitus vastuullisuuden varmistamiseksi
  7. Tekijänoikeudet ja tavaramerkit
  8. GDPR-yhteensopivuus
  9. Ennen kuin avaat padot
  10. Testaa tietosi

Päivitetty 3. marraskuuta 2026 OpenAI:n Image generation -oppaan perusteella: Moderoinnin kieltäytyminen tunnistetaan ehdolla error.code == "moderation_blocked" ja valinnaisella moderation_details-objektilla, ei sanojen safety tai content_policy esiintymisellä virheilmoituksessa; lisätty moderation-parametri (auto, low). Lähde: Image generation.

2. marraskuuta 2026 päivitys — Kuvamallit. gpt-image-1, jonka pohjalta tämä kurssi alun perin kirjoitettiin, poistettiin käytöstä 23. lokakuuta 2026, ja mallit gpt-image-1.5, gpt-image-1-mini sekä chatgpt-image-latest poistetaan 1. joulukuuta 2026. Esimerkit käyttävät nyt mallia gpt-image-2.5-sunburst, joka on tarkin muokkaustehtäviin; gpt-image-2.5-flare on nopeampi tavanomaiseen generointiin. Molemmat hyväksyvät myös laatuasetukset xhigh ja max. GPT Image -mallit palauttavat kuvan aina base64-muodossa: vanhempien DALL·E-mallien response_format-parametria ei enää hyväksytä, ja se on poistettu koodista. Lähde: Image generation (OpenAI).

Moderointi ja visuaalisen sisällön turvallisuus

Niin kauan kuin generoit kuvia vain itsellesi, moderointi on henkilökohtaisen harkinnan varassa. Kun avaat generoinnin käyttäjillesi, siitä tulee sinua sitova juridinen ja eettinen velvoite. Tämä oppitunti käsittelee OpenAI:n moderointityökaluja, niiden ketjuttamista peräkkäisiksi suodattimiksi sekä toimenpiteitä, jotka suojaavat sekä sovellustasi että sen käyttäjiä.

Sisäänrakennettu moderointijärjestelmä

GPT Image kieltää tietyt sisältötyypit oma-aloitteisesti – kuten väkivallan ja seksuaalisesti eksplisiittisen materiaalin – ja ilmoittaa tästä kieltäytymisestä erityisellä virheellä. Koodisi pystyy siksi erottamaan sisältöpolitiikan mukaisen kieltäytymisen teknisestä viasta, sillä nämä vaativat päinvastaisia reaktioita: edellinen johtaa viestiin käyttäjälle, jälkimmäinen hälytykseen tiimillesi. OpenAI:n dokumentaatio määrittelee käytettävän erottimen: moderoinnin kieltäytyminen saapuu BadRequestError-poikkeuksena, jonka error.code on moderation_blocked (tyyppi image_generation_user_error), ja virheen runko voi sisältää moderation_details-objektin, joka täsmentää vaiheen (input, output tai unknown) sekä yleiset kategoriat (harassment, sexual, violence…). Älä etsi sanoja virheilmoituksesta: sen teksti ei ole sopimus, koodi on. Alla oleva funktio heittää poikkeuksen uudelleen vain, jos kyseessä ei ole moderoinnin kieltäytyminen.

from openai import OpenAI, BadRequestError

client = OpenAI()

def generate_with_moderation(prompt: str, output: str) -> dict:
    """Generoi kuvan käsitellen moderoinnin kieltäytymiset."""
    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  # tekninen vika, kiintiö, virheellinen pyyntö: käsittele muualla
        body = e.body if isinstance(e.body, dict) else {}
        details = body.get("moderation_details") or {}
        return {
            "status": "refused",
            "reason": "Sisältö hylätty turvallisuuskäytännön perusteella",
            "stage": details.get("moderation_stage"),        # input, output tai unknown
            "categories": details.get("categories") or [],  # lokiasi varten
        }


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

OpenAI neuvoo pitämään loppukäyttäjälle tarkoitetun viestin yleisenä ja varaamaan moderation_details-tiedot omiin lokeihisi ja tukitiimillesi. Nämä virheet eivät korjaudu uudelleenyrityksellä: ilman kehotteen tai annettujen kuvien muuttamista sama pyyntö hylätään uudelleen. Huomioi lopuksi, että suodatuksen tiukkuus asetetaan GPT Image -mallien moderation-parametrilla: auto (vakiosuodatus, oletus) tai low (vähemmän rajoittava).

Kehotteiden esisuodatus

On epätyydyttävää odottaa, että GPT Image kieltää kehotteen ennen kuin huomaat sen olevan ongelmallinen: olet jo kuluttanut API-kutsun, etkä saa tietää mitään tarkkaa syytä. Moderation API on kuitenkin ilmainen, nopea ja palauttaa nimettyjä kategorioita. Sen kutsuminen ennen generointia mahdollistaa siistin kieltäytymisen, käyttäjälle selittämisen siitä, mikä laukaisi hälytyksen, ja näiden tietojen tallentamisen auditointia varten. verify_prompt-funktio poimii laukaistujen kategorioiden listan, ja generate_safe_image ketjuttaa yksinkertaisesti kaksi vaihetta: tarkista ensin, generoi toiseksi.

from openai import OpenAI

client = OpenAI()

def verify_prompt(prompt: str) -> dict:
    """Tarkistaa kehotteen Moderation API:lla ennen generointia."""
    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": "Tämä kehote merkittiin moderointijärjestelmässä."
        }

    return {"allowed": True}


def generate_safe_image(prompt: str, output: str):
    """Täydellinen putki: moderointi + generointi."""
    # Vaihe 1: esisuodatus
    check = verify_prompt(prompt)

    if not check["allowed"]:
        print(f"Kehote hylätty: {check['message']}")
        print(f"Kategoriat: {check['categories']}")
        return None

    # Vaihe 2: generointi
    print("Kehote hyväksytty, generoidaan...")
    return generate_with_moderation(prompt, output)


# Testaa harmittomalla kehotteella
generate_safe_image(
    "A mountain landscape with a crystal clear lake",
    "mountain.png"
)

Tarkista myös generoidut kuvat

Viaton kehote voi tuottaa kuvan, joka ei ole sitä. Kiertoilmaus, termin monimerkityksellisyys tai pelkkä mallin epäonninen tulkinta riittävät tuottamaan visuaalista sisältöä, jota et haluaisi näytettävän logosi alla. omni-moderation-latest-malli hyväksyy kuvia syötteenä, mikä mahdollistaa silmukan sulkemisen: samat kategoriamekanismit pätevät generoituun tiedostoon. Alla oleva täydellinen putki ketjuttaa kolme vaihetta – kehotteen tarkistus, generointi, kuvatarkistus – ja kriittisesti, merkinnän sattuessa, poistaa tiedoston levyltä ennen tuomion palauttamista. Ongelmallinen kuva, joka jää palvelimelle “odotamme hetken” -tilanteessa, on kuva, joka vuotaa ennemmin tai myöhemmin.

from openai import OpenAI
import base64

client = OpenAI()

def moderate_generated_image(image_path: str) -> dict:
    """Analysoi generoidun kuvan ongelmallisen sisällön havaitsemiseksi."""
    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):
    """Täydellinen putki: kehotteen moderointi + generointi + kuvan moderointi."""
    # 1. Tarkista kehote
    check_prompt = verify_prompt(prompt)
    if not check_prompt["allowed"]:
        return {"status": "prompt_refused", "details": check_prompt}

    # 2. Generoi kuva
    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. Tarkista generoitu kuva
    check_image = moderate_generated_image(output)
    if not check_image["safe"]:
        import os
        os.remove(output)
        return {
            "status": "image_deleted",
            "reason": "Generoitu kuva merkittiin",
            "categories": check_image["categories"]
        }

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

Kun käyttäjät kirjoittavat kehotteet

Käyttäjien tuottama sisältö muuttaa ongelman luonnetta: et kohtaa enää kömpelyyttä, vaan ajoittain tahallisia kiertoyrityksiä. PromptModerator-luokka pinoo neljä erityyppistä puolustuskerrosta, mikä on vakavan suojauksen periaate. Puhdistus poistaa ohjausmerkit, joiden kautta injektioita kulkeutuu, ja rajoittaa pituuden viiteensataan merkkiin, katkaisten tulvaan tarkoitetut kehotteet, jotka on suunniteltu hukuttamaan ohjeet. Paikallinen tarkistus kiellettyjen sanojen listan avulla – jätetty tyhjäksi, täytettävä käytäntösi ja alasi mukaan – sieppaa nollakustannuksella sen, mitä jo tiedät. Moderation API ottaa sitten vastuun kaikesta, mitä listasi ei ennakoine. Lopuksi turvallisuuseteinen, joka liitetään ennen lopullista kehotetta, muistuttaa mallia eksplisiittisesti odotetusta kehyksestä, siirtäen rajaa eduksesi reunatapauksissa.

from openai import OpenAI
import re

client = OpenAI()

class PromptModerator:
    """Monikerroksinen suodatin käyttäjän kehotteille."""

    def __init__(self):
        self.forbidden_words = []  # Täytä käytäntösi mukaan
        self.security_prefix = (
            "Safe and appropriate image for all audiences. "
            "No violent, sexual, or discriminatory content. "
        )

    def clean(self, prompt: str) -> str:
        """Puhdistaa ja normalisoi käyttäjän kehotteen."""
        # Poista mahdolliset injektioit
        prompt = prompt.strip()
        # Rajoita pituutta
        prompt = prompt[:500]
        # Poista ohjausmerkit
        prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
        return prompt

    def check_words(self, prompt: str) -> bool:
        """Tarkistaa kiellettyjen sanojen puuttumisen."""
        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:
        """Lisää kehotteeseen turvallisuuseteisen."""
        return f"{self.security_prefix}{prompt}"

    def pipeline(self, raw_prompt: str) -> dict:
        """Täydellinen moderointiputki käyttäjän kehotteelle."""
        # Vaihe 1: puhdistus
        prompt = self.clean(raw_prompt)

        # Vaihe 2: paikallinen tarkistus
        if not self.check_words(prompt):
            return {"allowed": False, "reason": "Kielletty sana havaittu"}

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

        # Vaihe 4: lisää turvallisuuseteinen
        final_prompt = self.secure(prompt)

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


moderator = PromptModerator()

# Simuloi käyttäjän kehotetta
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
    print(f"Turvallinen kehote: {result['prompt']}")
else:
    print(f"Hylätty: {result['reason']}")

Lokitus vastuullisuuden varmistamiseksi

Päivänä, jona ongelmallinen kuva nousee uudelleen esiin, sinulta kysytään: kuka sen pyysi, milloin, ja mitä järjestelmäsi teki. Ilman lokeja sinulla ei ole vastausta. AuditLogger kirjoittaa yhden JSON-rivin per generointi .jsonl-tiedostoon – vain liitettävä formaatti, joka tukee samanaikaista kirjoitusta ja voidaan lukea rivi kerrallaan lataamatta kaikkea muistiin. Jokainen merkintä linkittää käyttäjätunnuksen typistettyyn kehotteeseen, generoinnin lopputulokseen ja tarvittaessa kieltäytymisen syyhyn. report-metodi johtaa sitten hyväksymisprosentin viimeisimmän sadan generoinnin ajalta ja erittelee kieltäytymiset: tämä on kojelauta, joka hälyttää, jos tietty tili kerää merkintöjä.

import json
import os
from datetime import datetime

class AuditLogger:
    """Audit-loki kuvageneroinneille."""

    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
    ):
        """Kirjoittaa audit-merkinnän."""
        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):
        """Generoi raportin viimeisimmistä generoinneista."""
        if not os.path.exists(self.log_file):
            print("Lokeja ei löytynyt.")
            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"Raportti viimeisistä {total} generoinnista:")
        print(f"  Hyväksytty: {ok} ({100*ok/total:.1f}%)")
        print(f"  Hylätty   : {refused} ({100*refused/total:.1f}%)")

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


logger = AuditLogger()
logger.report()

Tekijänoikeudet ja tavaramerkit

GPT Image osaa tuottaa kuvia, jotka herättävät mielikuvan taiteilijan tyylistä tai brändin visuaalisesta identiteetistä, ja juuri tämä kyky altistaa sinut. Tekninen moderointi ei suojaa sinua tällä rintamalla: se ei havaitse, että juliste näyttää hyvin paljon kilpailijan vastaavalta. Suojaus on siten sopimuksellista ja organisaatorista, kirjallisen ja valvottavan käyttöpolitiikan muodossa, jonka käyttäjäsi hyväksyvät ja tiimisi noudattaa. PRODUCTION_RULES-lohko antaa minimimuotoilun, joka tulee näyttää dokumentaatiossasi ja muistaa käyttöehdoissasi.

# Parhaita käytäntöjä integroitavaksi käyttöpolitiikkaasi

PRODUCTION_RULES = """
1. Älä pyydä elävän taiteilijan tyylin jäljittämistä nimeltä
2. Älä toista logoja tai rekisteröityjä tavaramerkkejä
3. Älä generoi oikeiden ihmisten kasvoja
4. Lisää "AI-generoitu kuva" -ilmoitus, kun se vaaditaan
5. Säilytä generointilokeja vähintään 12 kuukautta
6. Salli käyttäjien ilmoittaa ongelmallisesta sisällöstä
"""

def usage_warning():
    """Näyttää tuotannon käyttö säännöt."""
    print("=" * 60)
    print("TUOTANTOSÄÄNNÖT — AI-kuvagenerointi")
    print("=" * 60)
    print(PRODUCTION_RULES)

GDPR-yhteensopivuus

Eurooppalaiselle yritykselle säilytysajat ja suostumus eivät ole konfiguraatiovaihtoehtoja, vaan velvoitteita, joiden noudattaminen on osoitettava. Niiden kirjaaminen eksplisiittiseen konfiguraatio-objektiin hajauttamisen sijaan antaa sinulle yhden paikan näyttää se auditoinnin aikana. ComplianceConfig asettaa siten lokien säilytysajaksi yhden vuoden, kuvien säilytysajaksi yhdeksänkymmentä päivää ja tekee AI-ilmoituksesta ja suostumuksesta pakollisia. add_ai_metadata-metodi ansaitsee erityishuomion: se kirjoittaa PNG-tiedostoon itsessään PngInfo-luokan avulla tiedon, että kuva on generoitu, työkalun, joka sen tuotti, ja päivämäärän. Nämä metadata matkustavat tiedoston mukana, myös alustasi ulkopuolelle, mitä mikään verkkosivulla näytettävä ilmoitus ei tee.

class ComplianceConfig:
    """Kuvageneroinnin vaatimustenmukaisuuskonfiguraatio."""

    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:
        """Varmistaa, että käyttäjä on antanut suostumuksensa AI-generoinnille."""
        # Toteuta suostumuksenhallintajärjestelmäsi kanssa
        return True

    def add_ai_metadata(self, image_path: str):
        """Lisää metadataa, joka ilmoittaa AI-generoinnista."""
        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 lisätty: {image_path}")

Ennen kuin avaat padot

Kahdeksan määräyksen on oltava voimassa päivänä, jona järjestelmäsi muuttuu käytettäväksi, ja on rehellisempää kysyä niitä ennen kuin jälkeen. Ensinnäkin moderointi sen kahdessa vaiheessa: kehotteiden esisuodatus ja kuvien jälkitarkistus, kuten secure_pipeline tekee. Seuraavaksi lokitus, täydellisenä, yhdistäen jokaisen generoinnin sen kehotteeseen, tekijään ja lopputulokseen – tämä on ainoa todisteesi riitatilanteessa, ja se on tallennettava erillään itse kuvista, muuten tallennustilan tyhjennys veisi mukanaan myös jäljitettävyytesi.

Sitten tulee käyttäjäpuoli. Tilikohtainen nopeusrajoitus estää yhtä tilaajaa kuluttamasta kuukausibudjettiasi yhdessä yössä, tahallaan tai huonosti kirjoitetun skriptin kautta. Tieto kuvien generoidusta luonteesta liittyy sekä reiluuteen että kasvaviin sääntelyvaatimuksiin; sitä tukee tekninen merkintä tiedoston PNG- tai EXIF-metatietoihin. Oikeus tietojen poistoon edellyttää, että pystyt löytämään ja poistamaan kaikki käyttäjän tiedot yksinkertaisesta pyynnöstä, mikä on mahdollista vain, jos audit-merkintäsi sisältävät user_id:n. Lopuksi, avaa ilmoituskanava: käyttäjäsi näkevät aina ongelmallisen sisällön ennen sinua, eikä heidän mahdollisuutensa kertoa sinulle poista ongelmaa.

Kokoa nyt kaikki yhdeksi kuvagenerointipalveluksi: kehotteiden esisuodatus Moderation API:n ja sanalistan avulla, turvallisuuseteinen, tuotetun kuvan jälkitarkistus, audit-loki ja AI-metadata jokaisessa tiedostossa. Testaa sitä viidellä erilaisella kehotteella, joista vähintään yhden on tultava hylätyksi – tämä on ainoa tapa varmistaa, että turvakaiteesi todella toimivat eivätkä ole vain koodissa läsnä.

Testaa tietosi

Visuaalinen generointi API:n kautta: validoi refleksit ennen tuotantoa.

1. Mitä inpainting ja outpainting mahdollistavat?

Vastaus: Inpainting muokkaa tiettyä aluetta olemassa olevassa kuvassa (korvaa, korjaa); outpainting laajentaa kuvaa sen alkuperäisen kehyksen ulkopuolelle – kaksi kohdennettua muokkausta ilman kaikkeen uudelleengenerointia.

2. Mikä tekee hyvästä edistyneestä visuaalisesta kehotteesta?

Vastaus: Kuvaile kohde, sommittelu, valaistus ja perspektiivi – älä vain teemaa: mitä enemmän kehote kehystää kohtauksen kuin kuvausjohtaja, sitä tarkemmin kuva tottelee.

3. Miten työskennellä tehokkaasti iteratiivisesti?

Vastaus: Aloita perusgeneroinnilla, pyydä sitten kohdennettuja variaatioita (tyyli, kehys, yksityiskohta) kehotteen alusta uudelleenkirjoittamisen sijaan – säilytä toimiva, hienosäädä vain erot.

4. Mitä vipuja generointikustannusten optimointiin?

Vastaus: Sovita laatu ja resoluutio todelliseen tarpeeseen (luonnokset matalalla, lopulliset korkealla), rajoita iteraatioita paremmilla kehotteilla ja välimuistita/uudelleenkäytä validoituja visuaaleja.

5. Miksi visuaalisen sisällön moderointi on välttämätöntä?

Vastaus: Koska API ja käyttöehtosi asettavat rajoituksia (kielletty sisältö, oikeat ihmiset, brändit): kehotteiden suodatus ja tulosteiden valvonta suojelevat käyttäjiäsi ja sovellustasi.

Kehystä, iteroida, hallitse kustannuksia ja vaatimustenmukaisuutta: visuaalinen tuotanto on putki – ei arpapeliä.