Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Flux de travail de données avec Code Interpreter

Aula 14 de 20 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Fluxos de trabalho de dados com Code Interpreter
  2. Fluxo de trabalho 1: Relatório financeiro automatizado
  3. Fluxo de trabalho 2: Análise de coortes
  4. Fluxo de trabalho 3: Pontuação e segmentação
  5. Fluxo de trabalho 4: Previsão e tendências
  6. Orquestração de um fluxo de trabalho em várias etapas
  7. Pontos-chave

Lição atualizada em 2 de novembro de 2026 com base na documentação da OpenAI: a ferramenta Code Interpreter requer um parâmetro container (adicionado a todos os exemplos), as partes de texto da entrada são do tipo input_text e a pesquisa na web utiliza a ferramenta web_search (web_search_preview é agora uma ferramenta legada sem filtros de domínio). Os ficheiros gerados são recuperados através das funções fichiers_generes e telecharger da Lição 10. Os ficheiros anexados à mensagem são carregados com o propósito user_data, que a OpenAI recomenda para entradas do modelo (File inputs). Fontes: Code Interpreter · Web search.

Fluxos de trabalho de dados com Code Interpreter

As lições anteriores abordaram tarefas individuais uma a uma. A análise real encadeia-as: importa, limpa, calcula, visualiza e exporta. É a cadeia — e não cada passo isolado — que consome tempo quando feita manualmente.

Os quatro fluxos de trabalho abaixo são casos reais, deliberadamente variados: relatórios periódicos, análise comportamental ao longo do tempo, segmentação e previsão. Leia-os menos pelo código e mais pela estrutura do prompt — numerada, explícita quanto aos resultados esperados e precisa quanto ao formato. Esta estrutura transforma um pedido vago num relatório acionável, que pode aplicar diretamente aos seus próprios dados.

Fluxo de trabalho 1: Relatório financeiro automatizado

O relatório periódico é o melhor candidato para automação por uma razão simples: os ficheiros mudam, mas a estrutura do relatório não. Assim que escrever e validar o prompt para um mês, este funcionará para os onze seguintes. Note a instrução final, que solicita uma exportação Excel por secção. Isto torna o resultado diretamente partilhável, em vez de o deixar com texto que necessita de reformatação.

from openai import OpenAI

client = OpenAI()

# Carregar ficheiros de origem
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": (
        "Generate a complete financial report from these 3 files: "
        "1. SUMMARY: Total revenue, gross margin, net income "
        "2. MONTHLY ANALYSIS: Month-over-month evolution with variations "
        "3. BUDGET VARIANCES: Actual vs. forecast comparison, significant variances "
        "4. CHARTS: "
        "   - Revenue and expenses evolution (dual axis) "
        "   - Budget variance waterfall "
        "   - Expense breakdown by category "
        "5. EXPORT: Excel file with one tab per section"
    )}
]
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=(
        "Produce a professional report. "
        "Display figures with thousands separators. "
        "Use European format (decimal comma). "
        "Comment on each significant variance (> 5%)."
    )
)

# Recuperar todos os ficheiros gerados
for ann in fichiers_generes(response):
    telecharger(client, ann, f"sortie_{ann.filename}")
    print(f"Generated: {ann.filename}")

Fluxo de trabalho 2: Análise de coortes

A análise de coortes acompanha grupos formados na mesma data de entrada ao longo do tempo. Poucas equipas realizam este cálculo regularmente porque a sua configuração é tediosa. É precisamente por isso que vale a pena delegá-lo: a lógica é padrão; apenas os dados mudam.

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": (
                "Perform a cohort analysis on this user data: "
                "1. Define cohorts by signup month "
                "2. Calculate retention rate per cohort (month 1, 2, ..., 12) "
                "3. Create a retention heatmap "
                "4. Identify the cohort with the best retention "
                "5. Estimate LTV per cohort "
                "6. Export the retention table as CSV"
            )},
            {"type": "input_file", "file_id": file_obj.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions=(
        "Show the code step by step. "
        "Display intermediate results. "
        "For the heatmap, use a green palette (dark = good, light = low). "
        "Annotate each cell with the percentage."
    )
)

Fluxo de trabalho 3: Pontuação e segmentação

Aqui, o modelo não se limita a descrever os dados; constrói uma pontuação e forma grupos. Isto requer uma precaução: peça sempre o método além do resultado. Um segmento como «clientes em risco» sem os critérios que o produziram é inutilizável: ninguém o pode contestar, reproduzir ou corrigir.

def segmenter_clients(file_path: str) -> dict:
    """Segmenta clientes usando RFM e 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": (
                    "Perform RFM customer segmentation: "
                    "1. Calculate Recency, Frequency, Monetary for each customer "
                    "2. Assign an RFM score from 1 to 5 for each dimension "
                    "3. Create segments: Champions, Loyal, At Risk, Lost "
                    "4. Apply K-Means (k=4 to 8, choose the best k using elbow method) "
                    "5. Visualize segments in 2D (PCA or t-SNE) "
                    "6. Profile each segment: size, average revenue, frequency "
                    "7. Export: CSV with segment per customer + PDF-like report"
                )},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }],
        tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
        instructions=(
            "Use sklearn for clustering. "
            "Normalize variables before clustering. "
            "Display the elbow plot to justify the choice of k. "
            "Create a radar chart per segment."
        )
    )

    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
    }

Fluxo de trabalho 4: Previsão e tendências

A previsão é o fluxo de trabalho onde a cautela é mais importante. O contentor pode executar uma regressão ou uma decomposição sazonal, e fá-lo-á mesmo quando os seus dados não forem adequados — vinte pontos de dados são suficientes para produzir uma curva perfeitamente apresentável que é completamente sem sentido. Exija o intervalo de confiança e as premissas do modelo: é isto que distingue uma projeção de uma extrapolação.

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Based on this monthly sales data: "
                "1. Decompose the time series (trend, seasonality, residual) "
                "2. Apply exponential smoothing (Holt-Winters) "
                "3. Forecast the next 6 months with a 95% confidence interval "
                "4. Compare with a simple linear regression "
                "5. Generate a chart with history + forecasts "
                "6. Calculate error metrics (MAE, RMSE, MAPE)"
            )},
            {"type": "input_file", "file_id": file_obj.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions=(
        "Use statsmodels for decomposition and forecasting. "
        "Color the confidence interval in transparent blue. "
        "Clearly mark the separation between history and forecasts."
    )
)

Orquestração de um fluxo de trabalho em várias etapas

Além de um certo tamanho, um único prompt atinge os seus limites: a análise desvia-se, uma instrução intermédia é esquecida e perde-se a noção da etapa em que se encontra. Dividir o processo em chamadas sucessivas, todas a trabalhar no mesmo contentor onde os ficheiros da etapa anterior permanecem disponíveis, restaura o que perdeu — um ponto de verificação após cada etapa e a capacidade de retomar a partir da etapa defeituosa em vez de reiniciar tudo.

class WorkflowData:
    def __init__(self):
        self.client = OpenAI()
        # Um contentor explícito: os ficheiros produzidos permanecem disponíveis de uma etapa para a outra
        self.container = self.client.containers.create(name="workflow-data")
        self.intermediate_files = []

    def step(self, instruction: str, file_ids: list[str] | None = None) -> str:
        """Executa uma etapa do fluxo de trabalho no contentor partilhado."""
        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 ficheiros gerados para descarregar no final
        self.intermediate_files.extend(fichiers_generes(response))
        return response.output_text

    def download_results(self, output_folder: str):
        """Descarrega os ficheiros gerados antes da expiração do contentor."""
        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))

# Utilização
wf = WorkflowData()

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

wf.step(
    "Clean this CSV: remove duplicates, handle missing values, "
    "normalize types. Export the result.",
    [file_obj.id]
)

# Etapa 2: Análise
wf.step("Calculate key KPIs and identify trends.")

# Etapa 3: Visualização
wf.step("Create 4 key charts for an executive report.")

# Etapa 4: Exportação
wf.step("Compile everything into an Excel file with tabs and embedded charts.")

wf.download_results("./sortie_workflow/")

Pontos-chave

  • Divida fluxos de trabalho complexos em etapas com passagem de ficheiros
  • Utilize instruções detalhadas para cada etapa
  • O modelo gere nativamente análise estatística e aprendizagem automática básica
  • Recupere sistematicamente ficheiros intermédios para rastreabilidade
  • Combine análise de dados e visualização numa única chamada para relatórios completos