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

Flujos de datos con Code Interpreter

Lección 14 de 20 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Flujos de datos con Code Interpreter
  2. Flujo de trabajo 1: Informe financiero automatizado
  3. Flujo de trabajo 2: Análisis de cohortes
  4. Flujo de trabajo 3: Puntuación y segmentación
  5. Flujo de trabajo 4: Previsión y tendencias
  6. Orquestación de un flujo de trabajo multipaso
  7. Puntos clave

Lección actualizada el 2 de noviembre de 2026 según la documentación de OpenAI: la herramienta Code Interpreter requiere un parámetro container (añadido a todos los ejemplos), las partes de texto de la entrada son de tipo input_text, y la búsqueda web utiliza la herramienta web_search (web_search_preview es ahora una herramienta heredada sin filtros de dominio). Los archivos generados se recuperan mediante las funciones fichiers_generes y telecharger de la Lección 10. Los archivos adjuntos al mensaje se suben con el propósito user_data, que OpenAI recomienda para las entradas del modelo (Entradas de archivo). Fuentes: Code Interpreter · Búsqueda web.

Flujos de datos con Code Interpreter

Las lecciones anteriores han cubierto tareas individuales una por una. El análisis real las encadena: importas, limpias, calculas, visualizas y exportas. Es la cadena, no cada paso aislado, la que consume tiempo cuando se hace manualmente.

Los cuatro flujos de trabajo siguientes son casos reales, deliberadamente variados: informes periódicos, análisis de comportamiento en el tiempo, segmentación y previsión. Léelos menos por el código y más por la estructura del prompt: numerada, explícita sobre los entregables esperados y precisa en cuanto al formato. Esta estructura convierte una solicitud vaga en un informe ejecutable, y puedes aplicarla directamente a tus propios datos.

Flujo de trabajo 1: Informe financiero automatizado

La elaboración de informes periódicos es la mejor candidata para la automatización por una razón sencilla: los archivos cambian, pero la estructura del informe no. Una vez que escribes y validas el prompt para un mes, funciona para los once siguientes. Observa la instrucción final, que solicita una exportación a Excel por sección. Esto hace que el resultado sea directamente compartible, en lugar de dejarte con un texto que necesita reformateo.

from openai import OpenAI

client = OpenAI()

# Subir archivos fuente
files = {}
for name in ["revenus_2025.xlsx", "depenses_2025.xlsx", "budget_previsionnel.xlsx"]:
    with open(name, "rb") as f:
        file_obj = client.files.create(file=f, purpose="user_data")
        files[name] = file_obj.id

content = [
    {"type": "input_text", "text": (
        "Genera un informe financiero completo a partir de estos 3 archivos: "
        "1. RESUMEN: Ingresos totales, margen bruto, beneficio neto "
        "2. ANÁLISIS MENSUAL: Evolución mes a mes con variaciones "
        "3. DESVIACIONES PRESUPUESTARIAS: Comparativa real vs. previsto, desviaciones significativas "
        "4. GRÁFICOS: "
        "   - Evolución de ingresos y gastos (eje dual) "
        "   - Cascada de desviaciones presupuestarias "
        "   - Desglose de gastos por categoría "
        "5. EXPORTACIÓN: Archivo Excel con una pestaña por sección"
    )}
]
for fid in files.values():
    content.append({"type": "input_file", "file_id": fid})

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{"role": "user", "content": content}],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions=(
        "Elabora un informe profesional. "
        "Muestra las cifras con separadores de miles. "
        "Utiliza el formato europeo (coma decimal). "
        "Comenta cada desviación significativa (> 5%)."
    )
)

# Recuperar todos los archivos generados
for ann in fichiers_generes(response):
    telecharger(client, ann, f"sortie_{ann.filename}")
    print(f"Generado: {ann.filename}")

Flujo de trabajo 2: Análisis de cohortes

El análisis de cohortes rastrea grupos formados en la misma fecha de entrada a lo largo del tiempo. Pocos equipos realizan este cálculo regularmente porque su configuración es tediosa. Precisamente por eso merece la pena delegarlo: la lógica es estándar; solo cambian los datos.

with open("utilisateurs.csv", "rb") as f:
    file_obj = client.files.create(file=f, purpose="user_data")

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Realiza un análisis de cohortes sobre estos datos de usuarios: "
                "1. Define las cohortes por mes de registro "
                "2. Calcula la tasa de retención por cohorte (mes 1, 2, ..., 12) "
                "3. Crea un mapa de calor de retención "
                "4. Identifica la cohorte con mejor retención "
                "5. Estima el LTV por cohorte "
                "6. Exporta la tabla de retención como CSV"
            )},
            {"type": "input_file", "file_id": file_obj.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions=(
        "Muestra el código paso a paso. "
        "Visualiza los resultados intermedios. "
        "Para el mapa de calor, usa una paleta verde (oscuro = bueno, claro = bajo). "
        "Anota cada celda con el porcentaje."
    )
)

Flujo de trabajo 3: Puntuación y segmentación

Aquí, el modelo no solo describe los datos; construye una puntuación y forma grupos. Esto requiere una precaución: pide siempre el método además del resultado. Un segmento como «clientes en riesgo» sin los criterios que lo produjeron es inutilizable: nadie puede cuestionarlo, reproducirlo ni corregirlo.

def segmenter_clients(file_path: str) -> dict:
    """Segmenta clientes usando RFM y clustering."""
    with open(file_path, "rb") as f:
        file_obj = client.files.create(file=f, purpose="user_data")

    response = client.responses.create(
        model="gpt-5.6-terra",
        input=[{
            "role": "user",
            "content": [
                {"type": "input_text", "text": (
                    "Realiza una segmentación de clientes RFM: "
                    "1. Calcula Recencia, Frecuencia y Valor Monetario para cada cliente "
                    "2. Asigna una puntuación RFM de 1 a 5 para cada dimensión "
                    "3. Crea segmentos: Campeones, Leales, En Riesgo, Perdidos "
                    "4. Aplica K-Means (k=4 a 8, elige la mejor k usando el método del codo) "
                    "5. Visualiza los segmentos en 2D (PCA o t-SNE) "
                    "6. Perfila cada segmento: tamaño, ingreso medio, frecuencia "
                    "7. Exportación: CSV con segmento por cliente + informe tipo PDF"
                )},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }],
        tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
        instructions=(
            "Usa sklearn para el clustering. "
            "Normaliza las variables antes del clustering. "
            "Muestra el gráfico del codo para justificar la elección de k. "
            "Crea un gráfico de radar por segmento."
        )
    )

    output_files = []
    for ann in fichiers_generes(response):
        telecharger(client, ann, ann.filename)
        output_files.append(ann.filename)

    return {
        "analysis": response.output_text,
        "files": output_files
    }

Flujo de trabajo 4: Previsión y tendencias

La previsión es el flujo de trabajo donde la precaución importa más. El contenedor puede ejecutar una regresión o una descomposición estacional, y lo hará incluso cuando tus datos no sean adecuados: veinte puntos de datos son suficientes para producir una curva perfectamente presentable que carece totalmente de sentido. Exige el intervalo de confianza y los supuestos del modelo: esto es lo que distingue una proyección de una extrapolación.

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Basándote en estos datos de ventas mensuales: "
                "1. Descompón la serie temporal (tendencia, estacionalidad, residuo) "
                "2. Aplica suavizado exponencial (Holt-Winters) "
                "3. Prevé los próximos 6 meses con un intervalo de confianza del 95% "
                "4. Compara con una regresión lineal simple "
                "5. Genera un gráfico con histórico + previsiones "
                "6. Calcula métricas de error (MAE, RMSE, MAPE)"
            )},
            {"type": "input_file", "file_id": file_obj.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions=(
        "Usa statsmodels para la descomposición y la previsión. "
        "Colorea el intervalo de confianza en azul transparente. "
        "Marca claramente la separación entre histórico y previsiones."
    )
)

Orquestación de un flujo de trabajo multipaso

Más allá de cierto tamaño, un único prompt toca sus límites: el análisis se desvía, se olvida una instrucción intermedia y pierdes la noción del paso en el que estás. Dividir el proceso en llamadas sucesivas, todas trabajando dentro del mismo contenedor donde los archivos del paso anterior siguen disponibles, restaura lo perdido: un punto de control después de cada paso y la capacidad de reanudar desde el paso fallido en lugar de reiniciar todo.

class WorkflowData:
    def __init__(self):
        self.client = OpenAI()
        # Un contenedor explícito: los archivos producidos permanecen disponibles de un paso al siguiente
        self.container = self.client.containers.create(name="workflow-data")
        self.intermediate_files = []

    def step(self, instruction: str, file_ids: list[str] | None = None) -> str:
        """Ejecuta un paso del flujo de trabajo en el contenedor compartido."""
        content = [{"type": "input_text", "text": instruction}]
        for fid in file_ids or []:
            content.append({"type": "input_file", "file_id": fid})

        response = self.client.responses.create(
            model="gpt-5.6-terra",
            input=[{"role": "user", "content": content}],
            tools=[{"type": "code_interpreter", "container": self.container.id}],
        )

        # Memorizar archivos generados para descargarlos al final
        self.intermediate_files.extend(fichiers_generes(response))
        return response.output_text

    def download_results(self, output_folder: str):
        """Descarga los archivos generados antes de que expire el contenedor."""
        import os
        os.makedirs(output_folder, exist_ok=True)
        for ann in self.intermediate_files:
            telecharger(self.client, ann, os.path.join(output_folder, ann.filename))

# Uso
wf = WorkflowData()

# Paso 1: Importar y limpiar
with open("donnees_brutes.csv", "rb") as f:
    file_obj = client.files.create(file=f, purpose="user_data")

wf.step(
    "Limpia este CSV: elimina duplicados, gestiona valores faltantes, "
    "normaliza tipos. Exporta el resultado.",
    [file_obj.id]
)

# Paso 2: Análisis
wf.step("Calcula los KPI clave e identifica tendencias.")

# Paso 3: Visualización
wf.step("Crea 4 gráficos clave para un informe ejecutivo.")

# Paso 4: Exportación
wf.step("Compila todo en un archivo Excel con pestañas y gráficos incrustados.")

wf.download_results("./sortie_workflow/")

Puntos clave

  • Divide flujos de trabajo complejos en pasos con paso de archivos
  • Usa instrucciones detalladas para cada paso
  • El modelo gestiona nativamente el análisis estadístico y el aprendizaje automático básico
  • Recupera sistemáticamente los archivos intermedios para la trazabilidad
  • Combina análisis de datos y visualización en una única llamada para informes completos