Ir al contenido principal
Español— Elegir un idioma
Menú

Moderación y seguridad de contenido visual

Lección 12 de 12 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Moderación y seguridad de contenido visual
  2. El sistema de moderación integrado
  3. Prefiltrado de prompts
  4. Comprueba también las imágenes generadas
  5. Cuando los usuarios escriben los prompts
  6. Registro para rendición de cuentas
  7. Derechos de autor y marcas registradas
  8. Cumplimiento del RGPD
  9. Antes de abrir las compuertas
  10. Pon a prueba tus conocimientos

Actualizado el 3 de noviembre de 2026 según la guía de Generación de imágenes de OpenAI: un rechazo por moderación se identifica mediante error.code == "moderation_blocked", con un objeto opcional moderation_details, no por la presencia de las palabras safety o content_policy en el mensaje de error; se ha añadido el parámetro moderation (auto, low). Fuente: Generación de imágenes.

Actualización del 2 de noviembre de 2026 — Modelos de imagen. gpt-image-1, sobre el que se escribió originalmente este curso, se discontinuó el 23 de octubre de 2026, y gpt-image-1.5, gpt-image-1-mini y chatgpt-image-latest se retirarán el 1 de diciembre de 2026. Los ejemplos ahora usan gpt-image-2.5-sunburst, el más preciso para edición; gpt-image-2.5-flare es más rápido para generación estándar. Ambos aceptan también las calidades xhigh y max. Los modelos GPT Image devuelven siempre la imagen en base64: el parámetro response_format de los modelos DALL·E anteriores no se acepta y se ha eliminado del código. Fuente: Generación de imágenes (OpenAI).

Moderación y seguridad de contenido visual

Mientras generes imágenes para ti mismo, la moderación es una cuestión de criterio personal. En cuanto abras la generación a usuarios, se convierte en una responsabilidad legal y ética que te vincula. Esta lección cubre las herramientas de moderación de OpenAI, cómo encadenarlas en filtros sucesivos y las medidas que protegen tanto a tu aplicación como a las personas que la utilizan.

El sistema de moderación integrado

GPT Image rechaza por sí solo cierto contenido —violencia, material sexualmente explícito, entre otros— y señala este rechazo con un error específico. Tu código debe, por tanto, distinguir un rechazo por política de contenido de un fallo técnico, porque ambos exigen reacciones opuestas: el primero deriva en un mensaje al usuario, el segundo en una alerta a tu equipo. La documentación de OpenAI especifica el discriminador a usar: un rechazo por moderación llega como un BadRequestError con error.code igual a moderation_blocked (tipo image_generation_user_error), y el cuerpo del error puede contener un objeto moderation_details que especifica la etapa (input, output o unknown) y categorías generales (harassment, sexual, violence…). No busques palabras en el mensaje de error: su texto no es un contrato, el código sí lo es. La función siguiente vuelve a lanzar la excepción solo si no se trata de un rechazo por moderación.

from openai import OpenAI, BadRequestError

client = OpenAI()

def generate_with_moderation(prompt: str, output: str) -> dict:
    """Genera una imagen gestionando los rechazos por moderación."""
    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  # fallo técnico, cuota, solicitud inválida: gestionar 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 o unknown
            "categories": details.get("categories") or [],  # para tus registros
        }


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

OpenAI aconseja mantener un mensaje genérico para el usuario final y reservar moderation_details para tus registros y soporte. Estos errores no se resuelven reintentando: sin modificar el prompt o las imágenes proporcionadas, la misma solicitud será rechazada de nuevo. Observa finalmente que la severidad del filtrado se establece mediante el parámetro moderation de los modelos GPT Image: auto (filtrado estándar, por defecto) o low (menos restrictivo).

Prefiltrado de prompts

Esperar a que GPT Image rechace un prompt para descubrir que era problemático es insatisfactorio: ya has consumido la llamada a la API y no aprendes nada específico sobre el motivo. La API de Moderación, en cambio, es gratuita, rápida y devuelve categorías nombradas. Llamarla antes de la generación te permite rechazar limpiamente, explicar al usuario qué se ha marcado y conservar esta información para tu auditoría. La función verify_prompt extrae la lista de categorías activadas, y generate_safe_image simplemente encadena los dos pasos: comprobar primero, generar después.

from openai import OpenAI

client = OpenAI()

def verify_prompt(prompt: str) -> dict:
    """Comprueba un prompt con la API de Moderación antes de la generación."""
    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):
    """Pipeline completo: moderación + generación."""
    # Paso 1: prefiltrado
    check = verify_prompt(prompt)

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

    # Paso 2: generación
    print("Prompt validated, generating...")
    return generate_with_moderation(prompt, output)


# Prueba con un prompt inofensivo
generate_safe_image(
    "A mountain landscape with a crystal clear lake",
    "mountain.png"
)

Comprueba también las imágenes generadas

Un prompt inocente puede dar lugar a una imagen que no lo sea. Una formulación retorcida, la ambigüedad de un término o simplemente una interpretación desafortunada del modelo bastan para producir contenido visual que no querrías mostrar bajo tu logotipo. El modelo omni-moderation-latest acepta imágenes como entrada, lo que te permite cerrar el ciclo: la misma mecánica de categorías se aplica al archivo generado. El pipeline completo siguiente encadena las tres fases —comprobación del prompt, generación, comprobación de la imagen— y, crucialmente, en caso de marcaje, elimina el archivo del disco antes de devolver su veredicto. Una imagen problemática dejada en el servidor «mientras miramos» es una imagen que posiblemente se filtrará.

from openai import OpenAI
import base64

client = OpenAI()

def moderate_generated_image(image_path: str) -> dict:
    """Analiza una imagen generada para detectar contenido problemático."""
    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):
    """Pipeline completo: moderación de prompt + generación + moderación de imagen."""
    # 1. Comprobar el prompt
    check_prompt = verify_prompt(prompt)
    if not check_prompt["allowed"]:
        return {"status": "prompt_refused", "details": check_prompt}

    # 2. Generar la imagen
    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. Comprobar la imagen generada
    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}

Cuando los usuarios escriben los prompts

El contenido generado por usuarios cambia la naturaleza del problema: ya no te enfrentas a torpezas, sino, a veces, a intentos deliberados de elusión. La clase PromptModerator apila cuatro defensas de distinta naturaleza, que es el propio principio de una protección seria. La limpieza elimina caracteres de control a través de los cuales transitan inyecciones y limita la longitud a quinientos caracteres, cortando de raíz prompts de inundación diseñados para ahogar instrucciones. La verificación local mediante una lista de palabras prohibidas —dejada vacía, para que la rellenes según tu política y sector— intercepta a coste cero lo que ya conoces. La API de Moderación se hace cargo entonces de todo lo que tu lista no anticipó. Finalmente, el prefijo de seguridad concatenado antes del prompt final recuerda explícitamente al modelo el marco esperado, desplazando el límite a tu favor en casos límite.

from openai import OpenAI
import re

client = OpenAI()

class PromptModerator:
    """Filtro multicapa para prompts de usuario."""

    def __init__(self):
        self.forbidden_words = []  # Rellenar según tu política
        self.security_prefix = (
            "Safe and appropriate image for all audiences. "
            "No violent, sexual, or discriminatory content. "
        )

    def clean(self, prompt: str) -> str:
        """Limpia y normaliza un prompt de usuario."""
        # Eliminar posibles inyecciones
        prompt = prompt.strip()
        # Limitar longitud
        prompt = prompt[:500]
        # Eliminar caracteres de control
        prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
        return prompt

    def check_words(self, prompt: str) -> bool:
        """Comprueba la ausencia de palabras prohibidas."""
        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:
        """Añade un prefijo de seguridad al prompt."""
        return f"{self.security_prefix}{prompt}"

    def pipeline(self, raw_prompt: str) -> dict:
        """Pipeline de moderación completo para un prompt de usuario."""
        # Paso 1: limpieza
        prompt = self.clean(raw_prompt)

        # Paso 2: verificación local
        if not self.check_words(prompt):
            return {"allowed": False, "reason": "Forbidden word detected"}

        # Paso 3: moderación por API
        check = verify_prompt(prompt)
        if not check["allowed"]:
            return {"allowed": False, "reason": check["message"]}

        # Paso 4: añadir prefijo de seguridad
        final_prompt = self.secure(prompt)

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


moderator = PromptModerator()

# Simular un prompt de usuario
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']}")

Registro para rendición de cuentas

El día que resurja una imagen problemática, la pregunta que te harán será: quién la solicitó, cuándo y qué hizo tu sistema. Sin registros, no tienes respuesta. AuditLogger escribe una línea JSON por generación en un archivo .jsonl —un formato de solo anexado que soporta escritura concurrente y puede leerse línea a línea sin cargar todo en memoria—. Cada entrada vincula un ID de usuario a un prompt truncado, el resultado de la generación y, si corresponde, el motivo del rechazo. El método report deriva entonces la tasa de aceptación de las últimas cien generaciones y detalla los rechazos: este es el panel que te alertará si una cuenta concreta acumula marcajes.

import json
import os
from datetime import datetime

class AuditLogger:
    """Registro de auditoría para generaciones de imágenes."""

    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
    ):
        """Registra una entrada de auditoría."""
        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):
        """Genera un informe de generaciones recientes."""
        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()

Derechos de autor y marcas registradas

GPT Image sabe producir imágenes que evocan el estilo de un artista o la identidad visual de una marca, y esta capacidad es exactamente lo que te expone. La moderación técnica no te protege en este terreno: no detecta que un póster se parezca mucho al de un competidor. La protección es, por tanto, contractual y organizativa, tomando la forma de una política de uso escrita y ejecutable que tus usuarios aceptan y tu equipo aplica. El bloque PRODUCTION_RULES da la formulación mínima, para mostrar en tu documentación así como recordar en tus condiciones.

# Mejores prácticas para integrar en tu política de uso

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():
    """Muestra las reglas de uso en producción."""
    print("=" * 60)
    print("PRODUCTION RULES — AI Image Generation")
    print("=" * 60)
    print(PRODUCTION_RULES)

Cumplimiento del RGPD

Para una empresa europea, los plazos de retención y el consentimiento no son opciones de configuración, sino obligaciones cuyo respeto debe ser demostrable. Registrarlas en un objeto de configuración explícito, en lugar de dispersarlas por el código, te da un único lugar que mostrar durante una auditoría. ComplianceConfig fija así la retención de registros en un año, la de imágenes en noventa días, y hace obligatorio el aviso de IA y el consentimiento. El método add_ai_metadata merece atención especial: escribe en el propio PNG, vía PngInfo, el hecho de que la imagen es generada, la herramienta que la produjo y la fecha. Estos metadatos viajan con el archivo, incluso fuera de tu plataforma, algo que ningún aviso mostrado en una página web logra.

class ComplianceConfig:
    """Configuración de cumplimiento para generación de imágenes."""

    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:
        """Verifica que el usuario ha consentido la generación con IA."""
        # Implementar con tu sistema de gestión de consentimiento
        return True

    def add_ai_metadata(self, image_path: str):
        """Añade metadatos indicando generación con IA."""
        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}")

Antes de abrir las compuertas

Ocho disposiciones deben estar en su lugar el día que tu sistema sea accesible, y es más honesto exigirlas antes que después. Moderación primero, en sus dos fases: prefiltrado de prompts y postverificación de imágenes, como hace secure_pipeline. Registro después, completo, asociando cada generación a su prompt, autor y resultado —esta es tu única prueba en caso de disputa, y debe guardarse independientemente de las propias imágenes, de lo contrario una purga de almacenamiento se llevaría consigo tu trazabilidad—.

Luego viene la parte del usuario. Un límite de tasa por cuenta evita que un único suscriptor consuma tu presupuesto mensual en una noche, voluntariamente o mediante un script mal escrito. La información sobre la naturaleza generada de las imágenes atañe tanto a la equidad como, cada vez más, a la restricción regulatoria; se duplica con un marcado técnico en los metadatos PNG o EXIF del archivo. El derecho al borrado asume que puedes encontrar y eliminar todos los datos de un usuario bajo simple solicitud, lo cual solo es posible si tus entradas de auditoría llevan un user_id. Finalmente, abre un canal de reporte: tus usuarios verán siempre lo problemático antes que tú, y quitarles los medios para decírtelo no hace desaparecer el problema.

Ahora ensambla todo en un único servicio de generación de imágenes: prefiltrado de prompts vía API de Moderación y lista de palabras, prefijo de seguridad, postverificación de la imagen producida, registro de auditoría y metadatos de IA en cada archivo. Pruébalo con cinco prompts variados, al menos uno de los cuales debe ser rechazado —esta es la única forma de verificar que tus barreras de seguridad funcionan realmente y no solo están presentes en el código—.

Pon a prueba tus conocimientos

Generación visual vía API: valida reflejos antes de la producción.

1. ¿Qué permiten el inpainting y el outpainting?

Respuesta: El inpainting modifica un área específica de una imagen existente (reemplazar, corregir); el outpainting extiende la imagen más allá de su marco original —dos ediciones dirigidas sin regenerarlo todo—.

2. ¿Qué hace bueno a un prompt visual avanzado?

Respuesta: Describe sujeto, composición, iluminación y perspectiva, no solo el tema: cuanto más enmarque el prompt la escena como un director de fotografía, más obedecerá la imagen.

3. ¿Cómo trabajar eficazmente por iteraciones?

Respuesta: Empieza con una generación base, luego solicita variaciones dirigidas (estilo, encuadre, detalle) en lugar de reescribir el prompt desde cero —mantén lo que funciona, ajusta solo la diferencia—.

4. ¿Qué palancas usar para optimizar costes de generación?

Respuesta: Adapta calidad y resolución a la necesidad real (borradores en baja, finales en alta), limita iteraciones con mejores prompts y almacena en caché/reutiliza visuales validados.

5. ¿Por qué es esencial la moderación de contenido visual?

Respuesta: Porque la API y tus condiciones imponen límites (contenido prohibido, personas reales, marcas): filtrar prompts y controlar salidas protege a tus usuarios y a tu aplicación.

Enmarca, itera, domina costes y cumplimiento: la producción visual es un pipeline, no un tiro al azar.