Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Code Interpreter: izpildīt kodu API

Nodarbība 10 no 20 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Code Interpreter: izpildīt kodu API
  2. Iespējot Code Interpreter
  3. Pārbaudīt izpildīto kodu
  4. Nodrošināt failus kā ievadi
  5. Iegūt ģenerētos failus
  6. Konteiners un vide
  7. Ķēdēt vairākas izpildes
  8. Kombinēt ar citiem rīkiem
  9. Paraugs: pilna analīzes cauruļvads
  10. Galvenās atziņas

Atjaunināts 2026. gada 2. novembrī, pamatojoties uz oficiālo Code Interpreter rokasgrāmatu un openai SDK: rīkam ir nepieciešams parametrs container (trūkst visos iepriekšējos piemēros, kas citādi neizdotos), ģenerētie faili parādās anotācijās ar tipu container_file_citation un tiek lejupielādēti, izmantojot Containers API (nevis client.files.content), bet izsaukumu rezultāti tiek dēvēti par outputs (nevis results). Ievades teksta daļas izmanto tipu input_text. Faili, kas pievienoti ziņojumam, tiek augšupielādēti ar mērķi user_data, ko OpenAI iesaka modeļa ievadēm (File inputs). Avoti: Code Interpreter · File inputs.

Code Interpreter: izpildīt kodu API

Valodu modelis paredz tekstu; tas neveic aprēķinus. Palūdz tam 1764 kvadrātsakni, un tas ģenerēs visvarbūtīgāko rezultātu, balstoties uz apmācības datiem — bieži vien pareizu, reizēm kļūdainu, bez iespējas atšķirt vienu no otra. Code Interpreter novērš šo nenoteiktību, nodrošinot modelim Python interpretatoru: tas uzraksta aprēķinu, izpilda to un atgriež iegūtu rezultātu, nevis minējumu.

Pārmaiņas ir dziļākas, nekā šķiet. Modelis redz sava koda izvadi, tostarp kļūdas, tāpēc tas var sevi labot un mēģināt vēlreiz. Datu failā, kura precīza struktūra nevienam nav zināma, šis cikls pārspēj jebkuru iepriekš sagatavotu instrukciju.

Iespējot Code Interpreter

Tu to iespējo, pievienojot rīku masīvam tools — nekas nav jāinstalē, nav jānodrošina vide. Modelis pats izlemj, kad rakstīt kodu: tas tieši atbild uz faktoloģiskiem jautājumiem, bet pāriet uz izpildi aprēķinu vai datu manipulāciju gadījumā.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Aprēķini Fibonači secību līdz 20. loceklim",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

print(response.output_text)

Modelis uzraksta Python kodu, izpilda to smilškastē un integrē rezultātus savā atbildē.

Pārbaudīt izpildīto kodu

Pieradini sevi lasīt šo kodu, vismaz izstrādes laikā. Tas ir vienīgais veids, kā atšķirt labu rezultātu no tāda, kas ir pareizs tikai nejaušības dēļ: vidējā vērtība, kas aprēķināta, klusējot ignorējot trūkstošās vērtības, ir skaitliski pareiza, bet analītiski nepatiesa. Atbilde tev to nepateiks; kods pateiks.

Atbilde satur ģenerēto kodu un tā rezultātus:

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Cik ir 1764 kvadrātsakne? Pārbaudi, kāpinot rezultātu kvadrātā.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    include=["code_interpreter_call.outputs"],  # lai saņemtu ģenerētos žurnālus un attēlus
)

for item in response.output:
    if item.type == "code_interpreter_call":
        print("--- Izpildītais kods ---")
        print(item.code)
        print("--- Izvades ---")
        for output in item.outputs or []:
            print(output.logs if output.type == "logs" else output.url)

Nodrošināt failus kā ievadi

Rīks sniedz pilnu vērtību, strādājot ar failiem. Tu augšupielādē failu, norādi to izsaukumā, un modelis to faktiski atver — tas nolasa reālās kolonnas, reālos datu tipus un reālās novirzes, nevis spriež par aprakstu, ko tu, iespējams, esi sniedzis.

# Augšupielādēt failu
with open("sales_2025.csv", "rb") as f:
    file_obj = client.files.create(file=f, purpose="user_data")

# Izmantot Code Interpreter ar failu
response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Analizē šo pārdošanas failu. "
                 "Sniedz kopsummu pa kategorijām un labāko mēnesi."},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }
    ],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

print(response.output_text)

Iegūt ģenerētos failus

Darbojas arī apgrieztais ceļš: kods rada attīrītu CSV, diagrammu vai Excel darbgrāmatu, un šie faili tiek atgriezti tev. Tie paliek konteinerā, un atbildes ziņojums tos citē savās anotācijās ar tipu container_file_citation, iekļaujot konteinera ID, faila ID un faila nosaukumu. Tad tu tos lejupielādē, izmantojot Containers API. Divas nelielas funkcijas, ko atkārtoti izmantosim turpmākajās nodarbībās, ietver šo plūsmu:

def generated_files(response):
    """Faili, ko izveidojis Code Interpreter, citēti ziņojuma anotācijās."""
    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):
    """Lejupielādē failu no konteinera un atgriež tā lokālo ceļu."""
    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

Faili, ko nodrošini kā ievadi (input_file), tiek automātiski nokopēti konteinerā: tev nav jāaugšupielādē nekas cits.

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Izveido diagrammu par pārdošanu pa mēnešiem "
                 "un eksportē attīrītos datus kā CSV."},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }
    ],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

# Iegūt ģenerētos failus
for ann in generated_files(response):
    print(f"Ģenerētais fails: {ann.filename}")
    download(client, ann, ann.filename)

Konteiners un vide

Zinot konteinera noteikumus, tu ietaupīsi laiku, debuggojot to, kas nevar strādāt. Saskaņā ar OpenAI dokumentāciju:

  • tā ir pilnībā izolēta virtuālā mašīna (smilškaste), kurā modelis izpilda Python;
  • rīkam ir nepieciešams parametrs container: {"type": "auto"} izveido konteineru (vai atkārtoti izmanto iepriekšējā izsaukuma konteineru, ja tas ir kontekstā), savukārt ID, kas iegūts, izmantojot client.containers.create(...), piespiež izmantot konkrētu konteineru;
  • atmiņa tiek iestatīta ar memory_limit: 1g (noklusējums), 4g, 16g vai 64g, augstākiem līmeņiem piemērojot integrēto rīku tarifus;
  • konteiners beidzas pēc 20 minūtēm neaktivitātes; tā dati tiek zaudēti, tāpēc lejupielādē visus failus, ko vēlies saglabāt, kamēr tas ir aktīvs.

Nerēķinies uz tīkla piekļuvi no koda: nodrošini datus kā ievadi vai deleģē pētniecību rīkam Web Search.

# Piemērs: modelis var tieši izmantot pandas
response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Ielādē šo CSV, izmantojot pandas, "
                 "aprēķini aprakstošo statistiku un identificē novirzes."},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }
    ],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

Ķēdēt vairākas izpildes

Secīgas izpildes dalās vienā sesijā: mainīgie, DataFrame un importi no pirmā bloka paliek pieejami nākamajā, tieši tāpat kā piezīmju grāmatiņā. Modelis to izmanto dabiski — tas ielādē, pārbauda, tad apstrādā — padarot iespējamu daudzsoloņu analīzi, katrā posmā nepārlādējot visu no jauna.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="1. Ģenerē 1000 nejaušus punktus no normālā sadalījuma. "
          "2. Aprēķini vidējo vērtību un standartnovirzi. "
          "3. Izveido histogrammu. "
          "4. Veic Šapiro-Vilka normalitātes testu.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

# Modelis secīgi izpilda 4 koda blokus
# Katram blokam ir piekļuve iepriekšējo bloku mainīgajiem

Kombinēt ar citiem rīkiem

Visnoderīgākā kombinācija apvieno datu avotu ar spēju to apstrādāt: File Search atrod attiecīgo fragmentu tavos dokumentos, Web Search iegūst tirgus datus, un Code Interpreter salīdzina abus tabulā vai diagrammā. Neviens no šiem rīkiem nevar paveikt citu darbu.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Meklē tīmeklī Francijas IKP datus par pēdējiem 10 gadiem, "
          "tad izveido tendenču diagrammu ar lineāro regresiju.",
    tools=[
        {"type": "web_search"},
        {"type": "code_interpreter", "container": {"type": "auto"}}
    ]
)

Paraugs: pilna analīzes cauruļvads

Pēdējais piemērs apvieno visu iepriekš minēto reālistiskā gadījumā: ievades fails, daudzsoloņu analīze un izejas rezultāti. Pievērs īpašu uzmanību prasījuma formātam — numurētam, ar skaidri definētu sagaidāmo izvadi — jo tieši tas, daudz vairāk nekā pievienotais Python kods, nosaka rezultāta kvalitāti.

def analyze_data(file_path: str, questions: list[str]) -> dict:
    """Datu analīzes cauruļvads ar Code Interpreter."""
    # Augšupielāde
    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="Raksti tīru, komentētu Python kodu. "
                        "Parādi starprezultātus."
        )

        results[question] = response.output_text

    return results

# Lietošana
results = analyze_data("sales.csv", [
    "Sniedz aprakstošo statistiku katrai skaitliskajai kolonnai",
    "Kuri ir 5 visvairāk pārdotie produkti?",
    "Vai pārdošanā ir sezonalitāte?"
])

Galvenās atziņas

  • Code Interpreter izpilda Python izolētā konteinerā; parametrs container ir obligāts ({"type": "auto"} vai ID)
  • Faili, kas nodrošināti kā input_file, tiek automātiski nokopēti konteinerā
  • Ģenerētie faili tiek citēti kā container_file_citation un lejupielādēti, izmantojot client.containers.files.content.retrieve
  • Konteiners beidzas pēc 20 minūtēm neaktivitātes: lejupielādē to, ko vēlies saglabāt
  • Kombinē ar Web Search un File Search bagātinātai analīzei