Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Code Interpreter: Suorita koodia rajapinnassa

Oppitunti 10 / 20 Päivitetty 2. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Code Interpreter: Suorita koodia rajapinnassa
  2. Ota Code Interpreter käyttöön
  3. Tarkista suoritettu koodi
  4. Toimita tiedostoja syötteenä
  5. Nouda generoidut tiedostot
  6. Kontti ja ympäristö
  7. Ketjuta useita suorituksia
  8. Yhdistä muihin työkaluihin
  9. Malli: Täysi analyysiputki
  10. Keskeiset asiat

Päivitetty 2. marraskuuta 2026 virallisen Code Interpreter -oppaan ja openai-SDK:n perusteella: työkalu vaatii container-parametrin (puuttui kaikista aiemmista esimerkeistä, jotka olisivat epäonnistuneet), generoidut tiedostot näkyvät container_file_citation-merkinnöissä ja ne ladataan Containers API:n kautta (ei client.files.content), ja kutsujen tulosteet nimetään outputs (ei results). Syöttötekstiosat käyttävät tyyppiä input_text. Viestiin liitetyt tiedostot ladataan käyttämällä tarkoitusta user_data, jota OpenAI suosittelee mallin syötteille (File inputs). Lähteet: Code Interpreter · File inputs.

Code Interpreter: Suorita koodia rajapinnassa

Kielimalli ennustaa tekstiä; se ei laske. Pyydä siltä luvun 1764 neliöjuurta, ja se tuottaa koulutuksensa perusteella todennäköisimmän tuloksen – usein oikein, joskus väärin, ilman mahdollisuutta erottaa näitä toisistaan. Code Interpreter poistaa tämän epävarmuuden antamalla mallille Python-tulkin: se kirjoittaa laskutoimituksen, suorittaa sen ja palauttaa saadun tuloksen, ei arvausta.

Muutos on syvällisempi kuin miltä näyttää. Malli näkee oman koodinsa tulosteen, virheet mukaan lukien, joten se voi korjata itseään ja yrittää uudelleen. Datatiedostossa, jonka tarkkaa rakennetta kukaan ei tunne, tämä silmukka voittaa kaikki etukäteen kirjoitetut ohjeet.

Ota Code Interpreter käyttöön

Otat sen käyttöön lisäämällä työkalun tools-taulukkoon – mitään ei tarvitse asentaa eikä ympäristöä valmistella. Malli päättää, milloin se kirjoittaa koodia: se vastaa faktaa koskeviin kysymyksiin suoraan, mutta siirtyy suorittamiseen laskutoimituksia tai datan käsittelyä varten.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Calculate the Fibonacci sequence up to the 20th term",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

print(response.output_text)

Malli kirjoittaa Python-koodin, suorittaa sen hiekkalaatikossa ja integroi tulokset vastaukseensa.

Tarkista suoritettu koodi

Opettele lukemaan tämä koodi, ainakin kehitysvaiheessa. Se on ainoa tapa erottaa hyvä tulos sellaisesta, joka on oikein vain sattumalta: keskiarvo, joka on laskettu hiljaa ohittaen puuttuvat arvot, on numeerisesti oikein mutta analyyttisesti väärin. Vastaus ei kerro sinulle tätä; koodi kertoo.

Vastaus sisältää generoidun koodin ja sen tulokset:

response = client.responses.create(
    model="gpt-5.6-terra",
    input="What is the square root of 1764? Verify by squaring the result.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    include=["code_interpreter_call.outputs"],  # to receive produced logs and images
)

for item in response.output:
    if item.type == "code_interpreter_call":
        print("--- Executed Code ---")
        print(item.code)
        print("--- Outputs ---")
        for output in item.outputs or []:
            print(output.logs if output.type == "logs" else output.url)

Toimita tiedostoja syötteenä

Työkalu tarjoaa täyden arvonsa työskennellessään tiedostojen kanssa. Lataat tiedoston, viittaat siihen kutsussa, ja malli todella avaa sen – se lukee todelliset sarakkeet, todelliset tyypit ja todelliset poikkeamat sen sijaan, että se päättelisi asioita antamasi kuvauksen perusteella.

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

# Use Code Interpreter with the file
response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Analyze this sales file. "
                 "Give me the total by category and the best-performing month."},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }
    ],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

print(response.output_text)

Nouda generoidut tiedostot

Käänteinen polku toimii myös: koodi tuottaa siivotun CSV-tiedoston, kaavion tai Excel-työkirjan, ja nämä tiedostot palautetaan sinulle. Ne pysyvät kontissa (container), ja vastausviesti viittaa niihin merkinnöissään, joiden tyyppi on container_file_citation, sisältäen kontin tunnisteen, tiedostotunnisteen ja tiedostonimen. Lataat ne sitten Containers API:n kautta. Kaksi pientä funktiota, joita käytetään myöhemmissä oppitunneissa uudelleen, kapseloivat tämän kulun:

def generated_files(response):
    """Files created by Code Interpreter, cited in message annotations."""
    for item in response.output:
        if item.type == "message":
            for part in item.content:
                for ann in getattr(part, "annotations", None) or []:
                    if ann.type == "container_file_citation":
                        yield ann


def download(client, ann, path):
    """Downloads a file from the container and returns its local path."""
    content = client.containers.files.content.retrieve(ann.file_id, container_id=ann.container_id)
    with open(path, "wb") as out:
        out.write(content.read())
    return path

Syötteenä toimittamasi tiedostot (input_file) kopioidaan automaattisesti konttiin: sinun ei tarvitse ladata mitään muuta.

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Create a chart of sales by month "
                 "and export the cleaned data as a CSV."},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }
    ],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

# Retrieve generated files
for ann in generated_files(response):
    print(f"Generated file: {ann.filename}")
    download(client, ann, ann.filename)

Kontti ja ympäristö

Kontin sääntöjen tunteminen säästää aikaa vianetsinnässä sen suhteen, mikä ei voi toimia. OpenAI:n dokumentaation mukaan:

  • se on täysin eristetty virtuaalikone (hiekkalaatikko), jossa malli suorittaa Pythonia;
  • työkalu vaatii container-parametrin: {"type": "auto"} luo kontin (tai käyttää uudelleen edellisestä kutsusta kontekstissa olevaa konttia), kun taas client.containers.create(...)-kutsulla saatu tunnus pakottaa käyttämään tiettyä konttia;
  • muisti asetetaan parametrilla memory_limit: 1g (oletus), 4g, 16g tai 64g, ja korkeammat tasot laskutetaan integroitujen työkalujen hinnoilla;
  • kontti vanhenee 20 minuutin toimettomuuden jälkeen; sen tiedot menetetään tämän jälkeen, joten lataa kaikki säilytettävät tiedostot sen ollessa aktiivinen.

Älä luota koodin verkkoyhteyksiin: toimita data syötteenä tai delegoi tutkimus Web Search -työkalulle.

# Example: the model can use pandas directly
response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Load this CSV with pandas, "
                 "calculate descriptive statistics, and identify outliers."},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }
    ],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

Ketjuta useita suorituksia

Peräkkäiset suoritukset jakavat saman istunnon: muuttujat, DataFrame-objektit ja tuonnit ensimmäisestä lohkosta ovat saatavilla seuraavassa, aivan kuten muistikirjassa. Malli hyödyntää tätä luontevasti – se lataa, tarkistaa ja käsittelee – mikä mahdollistaa monivaiheisen analyysin ilman kaiken uudelleenlataamista jokaisessa vaiheessa.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="1. Generate 1000 random points from a normal distribution. "
          "2. Calculate the mean and standard deviation. "
          "3. Create a histogram. "
          "4. Perform a Shapiro-Wilk normality test.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

# The model executes 4 code blocks sequentially
# Each block has access to variables from previous ones

Yhdistä muihin työkaluihin

Hyödyllisin yhdistelmä parittaa datalähteen kykyyn käsitellä sitä: File Search löytää relevantin kohdan dokumenteistasi, Web Search tuo markkinadataa, ja Code Interpreter vertaa näitä kahta taulukossa tai kaaviossa. Mikään näistä työkaluista ei voi tehdä muiden tehtäviä.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Search the web for French GDP data from the last 10 years, "
          "then create a trend chart with a linear regression.",
    tools=[
        {"type": "web_search"},
        {"type": "code_interpreter", "container": {"type": "auto"}}
    ]
)

Malli: Täysi analyysiputki

Viimeinen esimerkki ketjuttaa kaiken edellä mainitun realistiseksi tapaukseksi: syöttötiedosto, monivaiheinen analyysi ja tulosteena toimitettavat tiedostot. Kiinnitä erityistä huomiota kehotteen muotoiluun – numeroitu, selkeä odotetun tulosteen suhteen – sillä se määrää tuloksen laadun paljon enemmän kuin mukana oleva Python-koodi.

def analyze_data(file_path: str, questions: list[str]) -> dict:
    """Data analysis pipeline with Code Interpreter."""
    # Upload
    with open(file_path, "rb") as f:
        file_obj = client.files.create(file=f, purpose="user_data")

    results = {}

    for question in questions:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=[
                {
                    "role": "user",
                    "content": [
                        {"type": "input_text", "text": question},
                        {"type": "input_file", "file_id": file_obj.id}
                    ]
                }
            ],
            tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
            instructions="Write clean, commented Python code. "
                        "Display intermediate results."
        )

        results[question] = response.output_text

    return results

# Usage
results = analyze_data("sales.csv", [
    "Give descriptive statistics for each numeric column",
    "What are the top 5 best-selling products?",
    "Is there seasonality in sales?"
])

Keskeiset asiat

  • Code Interpreter suorittaa Pythonia eristetyssä kontissa; container-parametri on pakollinen ({"type": "auto"} tai tunnus)
  • Syötteenä input_file-muodossa toimitetut tiedostot kopioidaan automaattisesti konttiin
  • Generoidut tiedostot merkitään tyypillä container_file_citation ja ne ladataan komennolla client.containers.files.content.retrieve
  • Kontti vanhenee 20 minuutin toimettomuuden jälkeen: lataa kaikki säilytettävä
  • Yhdistä Web Searchiin ja File Searchiin rikastetun analyysin tekemiseksi