Salt la conținutul principal
Română— Alege o limbă
Meniu

Fluxuri de lucru cu date folosind Code Interpreter

Lecția 14 din 20 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Fluxuri de lucru cu date folosind Code Interpreter
  2. Fluxul de lucru 1: Raport financiar automatizat
  3. Fluxul de lucru 2: Analiza de cohortă
  4. Fluxul de lucru 3: Scorificare și segmentare
  5. Fluxul de lucru 4: Previziuni și tendințe
  6. Orchestarea unui flux de lucru în mai mulți pași
  7. Puncte cheie

Lecție actualizată la 2 noiembrie 2026 pe baza documentației OpenAI: instrumentul Code Interpreter necesită un parametru container (adăugat în toate exemplele), părțile textuale ale intrării sunt de tipul input_text, iar căutarea web utilizează instrumentul web_search (web_search_preview este acum un instrument legacy fără filtre de domeniu). Fișierele generate sunt recuperate folosind funcțiile fichiers_generes și telecharger din Lecția 10. Fișierele atașate mesajului sunt încărcate cu scopul user_data, ceea ce OpenAI recomandă pentru intrările modelului (File inputs). Surse: Code Interpreter · Web search.

Fluxuri de lucru cu date folosind Code Interpreter

Lecțiile anterioare au acoperit sarcini individuale, una câte una. Analiza reală le înlănțuie: importați, curățați, calculați, vizualizați și exportați. Lanțul – nu fiecare pas izolat – este cel care consumă timp atunci când este realizat manual.

Cele patru fluxuri de lucru de mai jos sunt cazuri din lumea reală, deliberat variate: raportare periodică, analiză comportamentală în timp, segmentare și previziuni. Citiți-le mai puțin pentru cod și mai mult pentru structura promptului – numerotată, explicită privind livrabilele așteptate și precisă în privința formatului. Această structură transformă o cerere vagă într-un raport executabil, pe care îl puteți aplica direct propriilor dumneavoastră date.

Fluxul de lucru 1: Raport financiar automatizat

Raportarea periodică este cel mai bun candidat pentru automatizare dintr-un motiv simplu: fișierele se schimbă, dar structura raportului rămâne aceeași. Odată ce scrieți și validați promptul pentru o lună, acesta funcționează pentru următoarele unsprezece. Observați instrucțiunea finală, care solicită un export Excel pe secțiune. Acest lucru face rezultatul direct partajabil, în loc să vă lase cu un text care necesită reformatare.

from openai import OpenAI

client = OpenAI()

# Încărcarea fișierelor sursă
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%)."
    )
)

# Recuperarea tuturor fișierelor generate
for ann in fichiers_generes(response):
    telecharger(client, ann, f"sortie_{ann.filename}")
    print(f"Generated: {ann.filename}")

Fluxul de lucru 2: Analiza de cohortă

Analiza de cohortă urmărește grupuri formate la aceeași dată de intrare în timp. Puține echipe efectuează acest calcul în mod regulat deoarece configurarea sa este anevoioasă. Tocmai de aceea merită să o delegați: logica este standard; doar datele se schimbă.

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."
    )
)

Fluxul de lucru 3: Scorificare și segmentare

Aici, modelul nu doar descrie datele; construiește un scor și formează grupuri. Acest lucru necesită o precauție: cereți întotdeauna metoda, pe lângă rezultat. Un segment precum „clienți în risc“ fără criteriile care l-au produs este inutilizabil: nimeni nu îl poate contesta, reproduce sau corecta.

def segmenter_clients(file_path: str) -> dict:
    """Segmentează clienții folosind RFM și 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
    }

Fluxul de lucru 4: Previziuni și tendințe

Previziunile reprezintă fluxul de lucru unde prudența contează cel mai mult. Containerul poate rula o regresie sau o descompunere sezonieră și o va face chiar și atunci când datele dumneavoastră nu sunt potrivite – douăzeci de puncte de date sunt suficiente pentru a produce o curbă perfect prezentabilă, dar complet lipsită de sens. Cereți intervalul de încredere și ipotezele modelului: aceasta este ceea ce distinge o proiecție de o extrapolare.

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."
    )
)

Orchestarea unui flux de lucru în mai mulți pași

Dincolo de o anumită dimensiune, un singur prompt își atinge limitele: analiza deviază, o instrucțiune intermediară este uitată și pierdeți șirul pasului la care vă aflați. Divizarea procesului în apeluri succesive, toate lucrând în același container unde fișierele din pasul anterior rămân disponibile, restabilește ceea ce ați pierdut – un punct de control după fiecare pas și capacitatea de a relua de la pasul eronat în loc să reporniți totul.

class WorkflowData:
    def __init__(self):
        self.client = OpenAI()
        # Un container explicit: fișierele produse rămân disponibile de la un pas la altul
        self.container = self.client.containers.create(name="workflow-data")
        self.intermediate_files = []

    def step(self, instruction: str, file_ids: list[str] | None = None) -> str:
        """Execută un pas al fluxului de lucru în containerul partajat."""
        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}],
        )

        # Memorează fișierele generate pentru descărcare la final
        self.intermediate_files.extend(fichiers_generes(response))
        return response.output_text

    def download_results(self, output_folder: str):
        """Descarcă fișierele generate înainte ca containerul să expire."""
        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))

# Utilizare
wf = WorkflowData()

# Pasul 1: Import și curățare
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]
)

# Pasul 2: Analiză
wf.step("Calculate key KPIs and identify trends.")

# Pasul 3: Vizualizare
wf.step("Create 4 key charts for an executive report.")

# Pasul 4: Export
wf.step("Compile everything into an Excel file with tabs and embedded charts.")

wf.download_results("./sortie_workflow/")

Puncte cheie

  • Descompuneți fluxurile de lucru complexe în pași cu transmitere de fișiere
  • Folosiți instrucțiuni detaliate pentru fiecare pas
  • Modelul gestionează nativ analiza statistică și învățarea automată de bază
  • Recuperați sistematic fișierele intermediare pentru trasabilitate
  • Combinați analiza datelor și vizualizarea într-un singur apel pentru rapoarte complete