Przejdź do głównej treści
Polski— Wybierz język
Menu

Moderacja i bezpieczeństwo treści wizualnych

Lekcja 12 z 12 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Moderacja i bezpieczeństwo treści wizualnych
  2. Wbudowany system moderacji
  3. Wstępne filtrowanie promptów
  4. Sprawdzaj również wygenerowane obrazy
  5. Gdy użytkownicy piszą prompty
  6. Logowanie dla rozliczalności
  7. Prawa autorskie i znaki towarowe
  8. Zgodność z RODO
  9. Przed otwarciem śluz
  10. Sprawdź swoją wiedzę

Zaktualizowano 3 listopada 2026 na podstawie przewodnika Image generation od OpenAI: Odmowa moderacji jest identyfikowana przez error.code == "moderation_blocked", z opcjonalnym obiektem moderation_details, a nie przez obecność słów safety lub content_policy w komunikacie błędu; dodano parametr moderation (auto, low). Źródło: Image generation.

Aktualizacja z 2 listopada 2026 — Modele obrazowe. gpt-image-1, na którym pierwotnie napisano ten kurs, został wycofany 23 października 2026, a gpt-image-1.5, gpt-image-1-mini oraz chatgpt-image-latest zostaną wycofane 1 grudnia 2026. Przykłady wykorzystują teraz gpt-image-2.5-sunburst, najbardziej precyzyjny do edycji; gpt-image-2.5-flare jest szybszy do standardowej generacji. Oba akceptują również jakości xhigh i max. Modele GPT Image zawsze zwracają obraz w formacie base64: parametr response_format ze starszych modeli DALL·E nie jest obsługiwany i został usunięty z kodu. Źródło: Image generation (OpenAI).

Moderacja i bezpieczeństwo treści wizualnych

Dopóki generujesz obrazy tylko dla siebie, moderacja jest kwestią osobistego osądu. Gdy jednak udostępniasz generowanie użytkownikom, staje się ona odpowiedzialnością prawną i etyczną, która cię wiąże. Ta lekcja omawia narzędzia moderacyjne OpenAI, sposób ich łączenia w kolejne filtry oraz środki chroniące zarówno twoją aplikację, jak i osoby, które z niej korzystają.

Wbudowany system moderacji

GPT Image samodzielnie odrzuca pewne treści – przemoc, materiały o charakterze seksualnym i inne – sygnalizując tę odmowę konkretnym błędem. Twój kod musi więc rozróżniać odmowę wynikającą z polityki treści od awarii technicznej, ponieważ wymagają one przeciwnych reakcji: pierwsza skutkuje komunikatem dla użytkownika, druga – alertem dla twojego zespołu. Dokumentacja OpenAI precyzuje wyróżnik do użycia: odmowa moderacji przychodzi jako BadRequestError z error.code równym moderation_blocked (typ image_generation_user_error), a treść błędu może zawierać obiekt moderation_details, określający etap (input, output lub unknown) oraz ogólne kategorie (harassment, sexual, violence…). Nie szukaj słów w komunikacie błędu: jego tekst nie jest umową, kod nią jest. Poniższa funkcja ponownie zgłasza wyjątek tylko wtedy, gdy nie jest to odmowa moderacji.

from openai import OpenAI, BadRequestError

client = OpenAI()

def generate_with_moderation(prompt: str, output: str) -> dict:
    """Generuje obraz, obsługując odmowy moderacji."""
    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  # awaria techniczna, limit, nieprawidłowe żądanie: obsłuż gdzie indziej
        body = e.body if isinstance(e.body, dict) else {}
        details = body.get("moderation_details") or {}
        return {
            "status": "refused",
            "reason": "Treść odrzucona przez politykę bezpieczeństwa",
            "stage": details.get("moderation_stage"),        # input, output lub unknown
            "categories": details.get("categories") or [],  # do twoich logów
        }


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

OpenAI zaleca stosowanie ogólnego komunikatu dla użytkownika końcowego, a moderation_details rezerwowanie dla logów i wsparcia. Błędy te nie ustępują przy ponownej próbie: bez modyfikacji promptu lub dostarczonych obrazów to samo żądanie zostanie ponownie odrzucone. Pamiętaj też, że surowość filtrowania ustawia się parametrem moderation modeli GPT Image: auto (standardowe filtrowanie, domyślne) lub low (mniej restrykcyjne).

Wstępne filtrowanie promptów

Czekanie, aż GPT Image odrzuci prompt, zanim odkryjesz, że był problematyczny, jest niewystarczające: zużyłeś już wywołanie API i nie dowiadujesz się niczego konkretnego o przyczynie. API Moderacji jest jednak darmowe, szybkie i zwraca nazwane kategorie. Wywołanie go przed generacją pozwala czysto odmówić, wyjaśnić użytkownikowi, co zostało oflagowane, i zachować te informacje do audytu. Funkcja verify_prompt ekstrahuje listę uruchomionych kategorii, a generate_safe_image po prostu łączy dwa kroki: najpierw sprawdź, potem generuj.

from openai import OpenAI

client = OpenAI()

def verify_prompt(prompt: str) -> dict:
    """Sprawdza prompt za pomocą API Moderacji przed generacją."""
    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": "Ten prompt został oflagowany przez system moderacji."
        }

    return {"allowed": True}


def generate_safe_image(prompt: str, output: str):
    """Pełny potok: moderacja + generacja."""
    # Krok 1: wstępne filtrowanie
    check = verify_prompt(prompt)

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

    # Krok 2: generacja
    print("Prompt zweryfikowany, generowanie...")
    return generate_with_moderation(prompt, output)


# Test z nieszkodliwym promptem
generate_safe_image(
    "A mountain landscape with a crystal clear lake",
    "mountain.png"
)

Sprawdzaj również wygenerowane obrazy

Niewinny prompt może dać obraz, który już niewinny nie jest. Okrężne sformułowanie, niejednoznaczność terminu lub po prostu pechowa interpretacja modelu wystarczą, by wyprodukować treści wizualne, których nie chciałbyś wyświetlać pod swoim logo. Model omni-moderation-latest akceptuje obrazy jako dane wejściowe, pozwalając domknąć pętlę: te same mechanizmy kategorii dotyczą wygenerowanego pliku. Poniższy kompletny potok łączy trzy fazy – sprawdzenie promptu, generację, sprawdzenie obrazu – i co kluczowe, w przypadku oflagowania usuwa plik z dysku przed zwróceniem werdyktu. Problematiczny obraz pozostawiony na serwerze „na czas sprawdzenia“ to obraz, który w końcu wycieknie.

from openai import OpenAI
import base64

client = OpenAI()

def moderate_generated_image(image_path: str) -> dict:
    """Analizuje wygenerowany obraz w celu wykrycia problematycznych treści."""
    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):
    """Pełny potok: moderacja promptu + generacja + moderacja obrazu."""
    # 1. Sprawdź prompt
    check_prompt = verify_prompt(prompt)
    if not check_prompt["allowed"]:
        return {"status": "prompt_refused", "details": check_prompt}

    # 2. Wygeneruj obraz
    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. Sprawdź wygenerowany obraz
    check_image = moderate_generated_image(output)
    if not check_image["safe"]:
        import os
        os.remove(output)
        return {
            "status": "image_deleted",
            "reason": "Wygenerowany obraz został oflagowany",
            "categories": check_image["categories"]
        }

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

Gdy użytkownicy piszą prompty

Treści tworzone przez użytkowników zmieniają naturę problemu: nie masz już do czynienia z niezgrabnością, lecz czasem z celowymi próbami obejścia zabezpieczeń. Klasa PromptModerator stackuje cztery warstwy obrony o różnym charakterze, co jest samą zasadą poważnej ochrony. Czyszczenie usuwa znaki kontrolne, przez które przechodzą iniekcje, i ogranicza długość do pięciuset znaków, ucinaąc prompty powodziowe mające na celu zatopienie instrukcji. Lokalna weryfikacja poprzez listę słów zakazanych – pozostawiona pusta, do wypełnienia zgodnie z twoją polityką i sektorem – перехwytuje za darmo to, co już wiesz. API Moderacji przejmuje potem wszystko, czego twoja lista nie przewidziała. Na koniec prefiks bezpieczeństwa doklejony przed finalny prompt wyraźnie przypomina modelowi oczekiwane ramy, przesuwając granicę na twoją korzyść w przypadkach brzegowych.

from openai import OpenAI
import re

client = OpenAI()

class PromptModerator:
    """Wielowarstwowy filtr dla promptów użytkownika."""

    def __init__(self):
        self.forbidden_words = []  # Wypełnij zgodnie z twoją polityką
        self.security_prefix = (
            "Bezpieczny i odpowiedni obraz dla wszystkich odbiorców. "
            "Brak treści przemocy, seksualnych lub dyskryminujących. "
        )

    def clean(self, prompt: str) -> str:
        """Czyści i normalizuje prompt użytkownika."""
        # Usuń potencjalne iniekcje
        prompt = prompt.strip()
        # Ogranicz długość
        prompt = prompt[:500]
        # Usuń znaki kontrolne
        prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
        return prompt

    def check_words(self, prompt: str) -> bool:
        """Sprawdza brak słów zakazanych."""
        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 prefiks bezpieczeństwa do promptu."""
        return f"{self.security_prefix}{prompt}"

    def pipeline(self, raw_prompt: str) -> dict:
        """Kompletny potok moderacji dla promptu użytkownika."""
        # Krok 1: czyszczenie
        prompt = self.clean(raw_prompt)

        # Krok 2: weryfikacja lokalna
        if not self.check_words(prompt):
            return {"allowed": False, "reason": "Wykryto słowo zakazane"}

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

        # Krok 4: dodaj prefiks bezpieczeństwa
        final_prompt = self.secure(prompt)

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


moderator = PromptModerator()

# Symuluj prompt użytkownika
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
    print(f"Bezpieczny prompt: {result['prompt']}")
else:
    print(f"Odrzucono: {result['reason']}")

Logowanie dla rozliczalności

Dnia, gdy problematyczny obraz wypłynie na jaw, pytanie, które ci zadadzą, brzmi: kto go zażądał, kiedy i co zrobił twój system. Bez logów nie masz odpowiedzi. AuditLogger zapisuje jedną linię JSON na generację do pliku .jsonl – formatu tylko do dopisywania, który obsługuje zapis współbieżny i może być czytany linia po linii bez ładowania wszystkiego do pamięci. Każde wejście łączy ID użytkownika ze skróconym promptem, wynikiem generacji i, w razie potrzeby, przyczyną odmowy. Metoda report wyprowadza następnie wskaźnik akceptacji dla ostatnich stu generacji i szczegółowo opisuje odmowy: to jest dashboard, który cię ostrzeże, jeśli konkretne konto nagromadzi oflagowania.

import json
import os
from datetime import datetime

class AuditLogger:
    """Log audytowy dla generacji obrazów."""

    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
    ):
        """Loguje wpis audytowy."""
        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):
        """Generuje raport ostatnich generacji."""
        if not os.path.exists(self.log_file):
            print("Nie znaleziono logów.")
            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"Raport ostatnich {total} generacji:")
        print(f"  Zaakceptowano: {ok} ({100*ok/total:.1f}%)")
        print(f"  Odrzucono   : {refused} ({100*refused/total:.1f}%)")

        if refused > 0:
            print(f"\nSzczegóły odmów:")
            for e in recent:
                if e["result"] != "ok":
                    print(f"  [{e['timestamp'][:10]}] {e['user_id']} : {e['refusal_reason']}")


logger = AuditLogger()
logger.report()

Prawa autorskie i znaki towarowe

GPT Image potrafi tworzyć obrazy przywołujące styl artysty lub tożsamość wizualną marki i ta zdolność jest właśnie tym, co cię naraża. Moderacja techniczna nie chroni cię na tym polu: nie wykryje, że plakat wygląda bardzo podobnie do konkurencji. Ochrona jest więc kontraktowa i organizacyjna, przybierając formę pisemnej, egzekwowalnej polityki użytkowania, którą akceptują twoi użytkownicy, a stosuje zespół. Blok PRODUCTION_RULES daje minimalne sformułowanie, do wyświetlenia w dokumentacji oraz przypomnienia w regulaminie.

# Najlepsze praktyki do integracji z twoją polityką użytkowania

PRODUCTION_RULES = """
1. Nie żądaj naśladowania stylu żyjącego artysty z nazwiska
2. Nie reprodukuj logotypów ani zastrzeżonych znaków towarowych
3. Nie generuj twarzy rzeczywistych osób
4. Dodaj informację „Obraz wygenerowany przez AI“, gdy wymagane
5. Przechowuj logi generacji przez co najmniej 12 miesięcy
6. Pozwól użytkownikom zgłaszać problematyczne treści
"""

def usage_warning():
    """Wyświetla zasady użytkowania produkcyjnego."""
    print("=" * 60)
    print("ZASADY PRODUKCYJNE — Generacja obrazów AI")
    print("=" * 60)
    print(PRODUCTION_RULES)

Zgodność z RODO

Dla firmy europejskiej okresy przechowywania i zgody nie są opcjami konfiguracji, lecz obowiązkami, których przestrzeganie musi być wykazalne. Zapisanie ich w jawnym obiekcie konfiguracji, zamiast rozpraszania po kodzie, daje ci jedno miejsce do pokazania podczas audytu. ComplianceConfig ustawia zatem przechowywanie logów na jeden rok, obrazów na dziewięćdziesiąt dni i czyni informację o AI oraz zgodę obowiązkowymi. Metoda add_ai_metadata zasługuje na szczególną uwagę: zapisuje w samym pliku PNG, poprzez PngInfo, fakt, że obraz jest wygenerowany, narzędzie, które go stworzyło, oraz datę. Te metadane podróżują z plikiem, także poza twoją platformę, czego nie robi żadna informacja wyświetlana na stronie internetowej.

class ComplianceConfig:
    """Konfiguracja zgodności dla generacji obrazów."""

    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:
        """Weryfikuje, czy użytkownik wyraził zgodę na generację AI."""
        # Zaimplementuj ze swoim systemem zarządzania zgodami
        return True

    def add_ai_metadata(self, image_path: str):
        """Dodaje metadane wskazujące na generację 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"Dodano metadane AI: {image_path}")

Przed otwarciem śluz

Osiem postanowień musi być na miejscu w dniu, gdy twój system stanie się dostępny, i uczciwiej jest poprosić o nie przed, a nie po. Najpierw moderacja w dwóch fazach: wstępne filtrowanie promptów i poweryfikacja obrazów, tak jak robi to secure_pipeline. Następnie logowanie, kompletne, łączące każdą generację z jej promptem, autorem i wynikiem – to twój jedyny dowód w razie sporu i musi być zapisane niezależnie od samych obrazów, inaczej czyszczenie magazynu zabierze wraz z sobą twoją możliwość śledzenia.

Potem strona użytkownika. Limit stawek na konto zapobiega sytuacji, w której jeden subskrybent zużywa twój miesięczny budżet w jedną noc, celowo lub przez źle napisany skrypt. Informacja o wygenerowanym charakterze obrazów dotyczy zarówno uczciwości, jak i, coraz częściej, ograniczeń regulacyjnych; jest podwojona przez techniczne znakowanie w metadanych PNG lub EXIF pliku. Prawo do usunięcia zakłada, że potrafisz znaleźć i usunąć wszystkie dane użytkownika na proste żądanie, co jest możliwe tylko wtedy, gdy twoje wpisy audytowe niosą user_id. Na koniec otwórz kanał zgłoszeń: twoi użytkownicy zawsze zobaczą to, co problematyczne, zanim ty to zrobisz, a odebranie im means do powiedzenia ci o tym nie sprawi, że problem zniknie.

Teraz złóż całość w jedną usługę generacji obrazów: wstępne filtrowanie promptów przez API Moderacji i listę słów, prefiks bezpieczeństwa, poweryfikacja wyprodukowanego obrazu, log audytowy i metadane AI na każdym pliku. Przetestuj to pięcioma różnymi promptami, z których co najmniej jeden musi zostać odrzucony – to jedyny sposób, by zweryfikować, że twoje guardraile faktycznie działają, a nie tylko są obecne w kodzie.

Sprawdź swoją wiedzę

Generacja wizualna przez API: zweryfikuj odruchy przed produkcją.

1. Co pozwalają robić inpainting i outpainting?

Odpowiedź: Inpainting modyfikuje konkretny obszar istniejącego obrazu (zamiana, korekta); outpainting rozszerza obraz poza jego oryginalną ramę – dwie celowane edycje bez regenerowania wszystkiego.

2. Co czyni dobry zaawansowany prompt wizualny?

Odpowiedź: Opisz temat, kompozycję, oświetlenie i perspektywę – nie tylko temat: im bardziej prompt kadruje scenę jak operator filmowy, tym bardziej obraz słucha.

3. Jak skutecznie pracować iteracyjnie?

Odpowiedź: Zacznij od bazowej generacji, a potem żądaj celowanych wariacji (styl, kadrowanie, detal), zamiast przepisywać prompt od zera – zachowaj to, co działa, tylko dostroj lukę.

4. Jakie dźwignie optymalizują koszty generacji?

Odpowiedź: Dostosuj jakość i rozdzielczość do rzeczywistej potrzeby (szkice w niskiej, finały w wysokiej), ogranicz iteracje lepszymi promptami i buforuj/powtarzaj zwalidowane wizualizacje.

5. Dlaczego moderacja treści wizualnych jest kluczowa?

Odpowiedź: Ponieważ API i twój regulamin nakładają limity (treści zakazane, rzeczywiste osoby, marki): filtrowanie promptów i kontrola wyjść chroni twoich użytkowników i twoją aplikację.

Kadruj, iteruj, opanuj koszty i zgodność: produkcja wizualna to potok – nie rzut kostką.