Data Workflows med Code Interpreter
På denne side
Lektion opdateret 2. november 2026 baseret på OpenAI-dokumentation: Code Interpreter-værktøjet kræver en
container-parameter (tilføjet til alle eksempler), tekstdele af inputtet er af typeninput_text, og websøgning bruger værktøjetweb_search(web_search_previewer nu et forældet værktøj uden domænefiltre). Genererede filer hentes ved hjælp af funktionernefichiers_generesogtelechargerfra lektion 10. Filer, der er vedhæftet beskeden, uploades med formåletuser_data, hvilket OpenAI anbefaler til modelinput (File inputs). Kilder: Code Interpreter · Websøgning.
Data Workflows med Code Interpreter
Tidligere lektioner har dækket individuelle opgaver én ad gangen. Rigtig analyse kæder dem sammen: du importerer, renser, beregner, visualiserer og eksporterer. Det er kæden – ikke hvert isoleret trin – der tager tid, når det gøres manuelt.
De fire workflows nedenfor er virkelige tilfælde, bevidst varierede: periodisk rapportering, adfærdsanalyse over tid, segmentering og prognoser. Læs dem mindre for kodens skyld og mere for prompt-strukturen – nummereret, eksplicit omkring forventede leverancer og præcis omkring format. Denne struktur omdanner en vag anmodning til en handlingsdygtig rapport, og du kan anvende den direkte på dine egne data.
Workflow 1: Automatiseret finansiel rapport
Periodisk rapportering er den bedste kandidat til automatisering af en simpel grund: filerne ændrer sig, men rapportstrukturen gør ikke. Når du først har skrevet og valideret prompten for én måned, virker den for de næste elleve. Bemærk den sidste instruktion, der anmoder om en Excel-eksport pr. sektion. Dette gør resultatet direkte deleligt, i stedet for at efterlade dig med tekst, der skal omformateres.
from openai import OpenAI
client = OpenAI()
# Upload kildefiler
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": (
"Generer en komplet finansiel rapport fra disse 3 filer: "
"1. SAMMENFATNING: Samlede indtægter, bruttomargin, nettoresultat "
"2. MÅNEDLIG ANALYSE: Udvikling måned-over-måned med variationer "
"3. BUDGETAFVIGELSER: Sammenligning af faktisk vs. prognose, signifikante afvigelser "
"4. DIAGRAMMER: "
" - Udvikling i indtægter og udgifter (dobbelt akse) "
" - Vandfaldsdiagram over budgetafvigelser "
" - Fordeling af udgifter efter kategori "
"5. EKSPORT: Excel-fil med ét faneblad pr. sektion"
)}
]
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=(
"Producér en professionel rapport. "
"Vis tal med tusindtalsseparatorer. "
"Brug europæisk format (decimalkomma). "
"Kommentér hver signifikant afvigelse (> 5%)."
)
)
# Hent alle genererede filer
for ann in fichiers_generes(response):
telecharger(client, ann, f"sortie_{ann.filename}")
print(f"Genereret: {ann.filename}")
Workflow 2: Kohorteanalyse
Kohorteanalyse sporer grupper, der er dannet på samme startdato, over tid. Få teams udfører denne beregning regelmæssigt, fordi opsætningen er besværlig. Det er netop derfor, det betaler sig at delegere det: logikken er standard; kun dataene ændrer sig.
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": (
"Udfør en kohorteanalyse på disse brugerdata: "
"1. Definer kohorter efter tilmeldingsmåned "
"2. Beregn fastholdelsesrate pr. kohorte (måned 1, 2, ..., 12) "
"3. Opret et fastholdelses-heatmap "
"4. Identificér den kohorte med den bedste fastholdelse "
"5. Estimer LTV pr. kohorte "
"6. Eksportér fastholdelsestabellen som CSV"
)},
{"type": "input_file", "file_id": file_obj.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
instructions=(
"Vis koden trin for trin. "
"Vis mellemresultater. "
"Brug til heatmapmet en grøn palet (mørk = god, lys = lav). "
"Annotér hver celle med procentdelen."
)
)
Workflow 3: Scoring og segmentering
Her beskriver modellen ikke blot dataene; den bygger en score og danner grupper. Dette kræver en forholdsregel: bed altid om metoden ud over resultatet. Et segment som „kunder i risiko” uden de kriterier, der har produceret det, er ubrugeligt: ingen kan udfordre, reproducere eller korrigere det.
def segmenter_clients(file_path: str) -> dict:
"""Segmenterer kunder ved hjælp af RFM og klyngedannelse."""
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": (
"Udfør RFM-kundesegmentering: "
"1. Beregn Recency, Frequency, Monetary for hver kunde "
"2. Tildel en RFM-score fra 1 til 5 for hver dimension "
"3. Opret segmenter: Champions, Loyal, At Risk, Lost "
"4. Anvend K-Means (k=4 til 8, vælg den bedste k ved hjælp af elbow-metoden) "
"5. Visualisér segmenter i 2D (PCA eller t-SNE) "
"6. Profilér hvert segment: størrelse, gennemsnitlig omsætning, frekvens "
"7. Eksport: CSV med segment pr. kunde + PDF-lignende rapport"
)},
{"type": "input_file", "file_id": file_obj.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
instructions=(
"Brug sklearn til klyngedannelse. "
"Normalisér variabler før klyngedannelse. "
"Vis elbow-plottet for at begrunde valget af k. "
"Opret et radardiagram pr. 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
}
Workflow 4: Prognoser og tendenser
Prognoser er det workflow, hvor forsigtighed er vigtigst. Containeren kan køre en regression eller sæsonbestemt dekomponering, og den vil gøre det, selv når dine data ikke er egnede – tyve datapunkter er nok til at producere en perfekt præsentabel kurve, der er fuldstændig meningsløs. Kræv konfidensintervallet og modellens antagelser: det er dette, der adskiller en projektion fra en ekstrapolation.
response = client.responses.create(
model="gpt-5.6-terra",
input=[{
"role": "user",
"content": [
{"type": "input_text", "text": (
"Baseret på disse månedlige salgsdata: "
"1. Dekomponér tidsserien (trend, sæsonudsving, restled) "
"2. Anvend eksponentiel udglatning (Holt-Winters) "
"3. Prognosticér de næste 6 måneder med et 95% konfidensinterval "
"4. Sammenlign med en simpel lineær regression "
"5. Generér et diagram med historik + prognoser "
"6. Beregn fejlmetrikker (MAE, RMSE, MAPE)"
)},
{"type": "input_file", "file_id": file_obj.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
instructions=(
"Brug statsmodels til dekomponering og prognoser. "
"Farv konfidensintervallet gennemsigtigt blåt. "
"Markér tydeligt adskillelsen mellem historik og prognoser."
)
)
Orkestrering af et flertrins-workflow
Ud over en vis størrelse støder en enkelt prompt på sine grænser: analysen driver af, en melleminstruktion bliver glemt, og du mister overblikket over, hvilket trin du er på. Ved at opdele processen i successive kald, der alle arbejder inden for samme container, hvor filer fra det tidligere trin forbliver tilgængelige, genvinder du det, du mistede – et checkpoint efter hvert trin og muligheden for at genoptage fra det fejlagtige trin i stedet for at starte forfra med det hele.
class WorkflowData:
def __init__(self):
self.client = OpenAI()
# En eksplicit container: filer produceret forbliver tilgængelige fra ét trin til det næste
self.container = self.client.containers.create(name="workflow-data")
self.intermediate_files = []
def step(self, instruction: str, file_ids: list[str] | None = None) -> str:
"""Udfører et workflow-trin i den delte container."""
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}],
)
# Husk genererede filer til download til sidst
self.intermediate_files.extend(fichiers_generes(response))
return response.output_text
def download_results(self, output_folder: str):
"""Downloader genererede filer før containeren udløber."""
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))
# Brug
wf = WorkflowData()
# Trin 1: Import og rensning
with open("donnees_brutes.csv", "rb") as f:
file_obj = client.files.create(file=f, purpose="user_data")
wf.step(
"Rens denne CSV: fjern dubletter, håndter manglende værdier, "
"normalisér typer. Eksportér resultatet.",
[file_obj.id]
)
# Trin 2: Analyse
wf.step("Beregn nøgle-KPI'er og identificér tendenser.")
# Trin 3: Visualisering
wf.step("Opret 4 nøglediagrammer til en lederreportage.")
# Trin 4: Eksport
wf.step("Saml alt i en Excel-fil med faneblade og indlejrede diagrammer.")
wf.download_results("./sortie_workflow/")
Vigtige pointer
- Opdel komplekse workflows i trin med filoverførsel
- Brug detaljerede instruktioner for hvert trin
- Modellen håndterer naturligt statistisk analyse og grundlæggende maskinlæring
- Hent systematisk mellemfiler for sporbarhed
- Kombinér dataanalyse og visualisering i ét kald for komplette rapporter