Fluxuri de lucru cu date folosind Code Interpreter
Pe această pagină
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 tipulinput_text, iar căutarea web utilizează instrumentulweb_search(web_search_previeweste acum un instrument legacy fără filtre de domeniu). Fișierele generate sunt recuperate folosind funcțiilefichiers_generesșitelechargerdin Lecția 10. Fișierele atașate mesajului sunt încărcate cu scopuluser_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