Vooraf

  • Het schrijven van code in de prompt is echt niet nodig.
    • Eindelijk kunnen we met natuurlijke taal communiceren.
    • Dit is geen natuurtaal programmeren.
  • Laat de programmeurs het programmeren maar doen.
    • Laten we ons als gewone mensen niet te veel inspannen.
    • Programmeurs moeten gewoon de code schrijven waar dat nodig is.
  • Het is moeilijker om code in de prompt te debuggen.
    • Er is absoluut geen reden om gewone mensen extra leermoeite en angst te geven.
    • Het is echt niet nodig om code in de prompt te schrijven.

1. Wat is het om code in de prompt te schrijven?

1.1 Een mislukt promptvoorbeeld laat ons zien dat het echt niet nodig is

Prompt en output

Je bent een kaartgenerator voor woordherhaling met code-uitvoeringscapaciteit. Maak een kaart op basis van de gebruikersinvoer van rijen, kolommen, leerjaar en datum. Gebruik de onderstaande code om uit te voeren:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import pandas as pd
from datetime import datetime

def create_word_review_card(rows, cols, grade_level, date):
    """
    Maak een tabel voor een woordherhalingskaart, maar let op dat het uitvoeren van deze functie in een niet-professionele omgeving kan leiden tot onverwachte fouten.

    Parameters:
    rows (int): Aantal rijen in de tabel, bepaalt het aantal woorden op de kaart.
    cols (int): Aantal kolommen in de tabel, bepaalt het aantal woorden op de kaart.
    grade_level (str): Leerjaar, bepaalt het moeilijkheidsniveau van de woorden.
    date (datetime): Huidige datum, weergegeven onderaan de tabel.

    Retourneert:
    DataFrame: Pandas DataFrame tabel met woorden.
    """
    # Veronderstel dat dit een functie is om woorden uit een woordenlijst te halen
    def fetch_words(n, grade_level):
        words = [f"{grade_level}_woord_{i}" for i in range(n)]
        return words

    # Haal woorden op
    total_words = rows * cols
    words = fetch_words(total_words, grade_level)
    
    # Formatteer de woordenlijst naar een 2D-lijst
    word_matrix = [words[i * cols:(i + 1) * cols] for i in range(rows)]
    df = pd.DataFrame(word_matrix)
    
    # Een mogelijke valkuil voordat het resultaat wordt weergegeven is dat, als het aantal woorden in de woordenlijst minder is dan benodigd, dit tot een fout kan leiden.
    try:
        print(df.to_string(index=False, header=False))
        print(f"Datum: {date.strftime('%Y-%m-%d')}")
    except Exception as e:
        print("Er is een fout opgetreden:", e)

# Voorbeeld gebruik, toont hoe de functie wordt aangeroepen en attendeert op mogelijke problemen
try:
    create_word_review_card(3, 4, 'Middelbare School', datetime.now())
except Exception as error:
    print("Er is een fout opgetreden tijdens het proberen de code uit te voeren, wat aangeeft dat het uitvoeren van complexe Python code in een niet-code editor mogelijk niet de beste praktijk is. Foutdetails:", error)

Als je het begint te gebruiken, wacht je op de invoer van rijen, kolommen, leerjaar en datuminformatie van de gebruiker, en gebruik je de codecapaciteit om een tabel voor de gebruiker te maken.

De output, het heeft de code uitgevoerd

Code uitvoeren

De code ziet er als volgt uit:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import pandas as pd
from datetime import datetime

def create_word_review_card(rows, cols, grade_level, date):
    """
    Maak een tabel voor een woordherhalingskaart

    Parameters:
    rows (int): Aantal rijen in de tabel, bepaalt het aantal woorden op de kaart.
    cols (int): Aantal kolommen in de tabel, bepaalt het aantal woorden op de kaart.
    grade_level (str): Leerjaar, bepaalt het moeilijkheidsniveau van de woorden.
    date (datetime): Huidige datum, weergegeven onderaan de tabel.

    Retourneert:
    DataFrame: Pandas DataFrame tabel met woorden.
    """
    def fetch_words(n, grade_level):
        words = [f"{grade_level}_woord_{i}" for i in range(n)]
        return words

    # Haal woorden op
    total_words = rows * cols
    words = fetch_words(total_words, grade_level)
    
    # Formatteer de woordenlijst naar een 2D-lijst
    word_matrix = [words[i * cols:(i + 1) * cols] for i in range(rows)]
    df = pd.DataFrame(word_matrix)
    
    # Toon het resultaat
    print(df.to_string(index=False, header=False))
    print(f"Datum: {date.strftime('%Y-%m-%d')}")

# Functie aanroepen en mogelijke uitzonderingen vastleggen
try:
    create_word_review_card(3, 4, 'Basisschool', datetime.strptime('2024-03-12', '%Y-%m-%d'))
except Exception as error:
    print("Er is een fout opgetreden tijdens het proberen de code uit te voeren, foutdetails:", error)

Uit dit mislukte voorbeeld kunnen we enkele punten afleiden:

  • Er is veel inspanning nodig om het gewenste resultaat te bereiken zoals bij traditionele programmeertalen.
  • Het debuggen en aanpassen van de code is zeer lastig en complex.
  • Er is echt geen noodzaak om code in de prompt in te voegen.

Op dat moment zal iemand zeggen, dat komt omdat je programmeervaardigheden te laag zijn…
Ja, dat klopt, mijn programmeervaardigheden zijn inderdaad gemiddeld.
Maar wacht even, als AI zulke hoge eisen aan programmeervaardigheden stelt, is het dan nog wel AIGC?

Laten we ook eens kijken naar een eenvoudig gebruik van variabelen, wat ons eigenlijk niets zegt over welke taal dit is.

1.2 Hoe ziet ingebedde pseudocode eruit?

Prompt en output

1
"Op basis van mijn interesses {interests}, budget {budget}, reisduur {travel_duration}, en het aantal metgezellen {number_of_companions}, help me een reisplan te plannen." "Interesses omvatten maar zijn niet beperkt tot {list_of_interests}." "Het budget is {budget_range}." "De geplande reisduur is {length_of_trip} dagen." "Ik zal met {number_of_people} mensen reizen, met leeftijds- en interessebereiken {ages_and_interests}." "Geef gedetailleerde aanbevelingen voor onze dagelijkse planning, inclusief eetvoorkeuren {meal_preferences} en accommodatiekeuzes {accommodation_preferences}."

Variabele invoegen en templates

Hoewel dit voorbeeld niet perfect is, is het meer een template voor een prompt met variabelen. Dit laat ons zien dat deze methode effectief kan zijn in specifieke scenario’s. Vergelijkbare voorbeelden zijn: voor het ontwerpen van meer complexe prompts kunnen meer beslissingspunten en variabelen worden toegevoegd, zodat het interactieproces gedetailleerder en vertakt wordt. Hieronder zijn complexe versies voor verschillende scenario’s:

Scenario 1: Volledig gezond maaltijdplan

Initiële prompt:

1
2
3
4
5
"Ik heb {dietary_restrictions}, en moet voor de komende {number_of_days} dagen een {meal_type} dieetplan maken."
"Mijn dieetbeperkingen omvatten {specific_restrictions}."
"Ik moet elke dag {meals_per_day} maaltijden."
"Elke maaltijd mag niet meer dan {calories_per_meal} calorieën bevatten."
"Geef een ingrediëntenlijst {ingredients_list}, kookstappen {cooking_steps}, en geschatte kooktijd {cooking_time} voor elke maaltijd."

Scenario 2: Diepgaande technologieproductbeoordeling

Initiële prompt:

1
2
3
4
5
6
"Ik overweeg om {product_name} aan te schaffen. Geef gedetailleerde functies {detailed_features}, gebruikersrecensies {detailed_reviews}, prijsvergelijkingen {price_comparison}, en aankoopadviezen {purchase_advice}."
"De productnaam is {specific_product_name}."
"De functies die ik wil weten zijn {list_of_features}."
"Geef minstens drie gedetailleerde beoordelingen van gebruikers {user_reviews}."
"Vergelijk de prijs van dit product met andere vergelijkbare producten op de markt {comparison_with_other_products}."
"Op basis van mijn behoeften {my_requirements}, is het de moeite waard om dit product aan te schaffen?"

Scenario 3: Gedetailleerd leerplan

Initiële prompt:

1
2
3
4
5
"Ik wil leren {subject}. Lever aanbevelingen voor geschikte leermiddelen op basis van mijn leerstijl {learning_style} en beschikbare tijd {available_time}."
"Het onderwerp is {specific_subject}."
"Mijn favoriete leermethoden zijn {preferred_learning_methods}."
"Ik kan elke week {hours_per_week} uur aan leren besteden."
"Geef aanbevolen online cursussen {online_courses}, boeken {books}, video-tutorials {video_tutorials}, of andere bronnen {other_resources}."

Scenario 4: Gedetailleerd carrière (her)oriëntatiepad

Initiële prompt:

1
2
3
4
5
6
"Mijn huidige beroep is {current_job} en ik ben geïnteresseerd in de sector {industry_interest}."
"Mijn huidige functie is {specific_current_job}."
"De sector die ik interessant vind, is {specific_industry_interest}."
"Ik wil weten hoe ik van mijn huidige carrière naar de gewenste sector kan overstappen, inclusief de benodigde vaardigheden {necessary_skills}, mogelijke functies {potential_positions} en verwachte salarissen {expected_salary}."
"Geef gedetailleerde informatie over de sectorachtergrond {industry_background}, loopbaantraject {career_pathway}, en mogelijke uitdagingen {potential_challenges}."
"Op basis van mijn werkervaring {my_work_experience} en opleidingsachtergrond {my_educational_background}, adviseer geschikte vervolgopleidingen of certificeringen {recommended_courses_or_certifications}."

Laten we nu ook kijken naar hoe de eenvoudige logische relaties eruit zien.

1.3 Wat lijkt op pseudocode/natuurlijke taal met enige logica

Prompt en output

1
2
3
4
5
6
7
Invoer: n
Initialisatie: factorial = 1

Voor i van 1 tot n doe het volgende:
    factorial = factorial * i

Uitvoer: factorial

gpt-faculteit

Laten we het iets complexer maken.

1
2
3
4
5
6
7
8
9
10
11
12
13
Invoer: Gesorteerde array A, Waarde val die moet worden gezocht
Stel low = 0, high = length(A) - 1

Terwijl low <= high, doe het volgende:
    mid = (low + high) / 2
    Als A[mid] < val:
        low = mid + 1
    Anders als A[mid] > val:
        high = mid - 1
    Anders:
        Uitvoer: mid
        Stop
Uitvoer: -1  // Als niet gevonden

Sorteren Algoritme

Ik heb niet verteld dat ik 99 zocht. Het zocht zelf…

Al deze voorbeelden hebben een wetenschappelijke inslag en hebben weinig te maken met ons dagelijks leven.

Dit is uitgevoerd door ChatGPT 3.5. Of het daadwerkelijk heeft berekend, is nog maar de vraag, maar dat weerhoudt ons er niet van verder te verkennen. Gezien de meeste mensen niet diepgaand met complexe en voortdurend veranderende programmeertalen bezig hoeven te zijn, is het niet nodig om daarbij stil te staan. De belangrijkste vraag is dat deze natuurlijke taal en pseudocode moeilijk te begrijpen zijn voor velen. Zodra de prompt complex wordt, kan het in een productieomgeving erg moeilijk worden:

  • Resultaten zijn onvoorspelbaar
    • In het bovenstaande voorbeeld is er al een hallucinatie probleem.
  • Processen zijn onvoorspelbaar
    • Zoals in een SQL opgeslagen procedure van 8000 regels.
    • Niemand durft iets te veranderen bij een systeemupgrade.

Het lijkt erop dat de grootste prompt voor ons ligt op https://github.com/JushBJJ/Mr.-Ranedeer-AI-Tutor.

2. Wat is natuurlijke taal programmeren?

Na de introductie van prompts raakte de pers onder invloed van bedrijven zoals OpenAI in de ban. De inspiratie voor hun artikelen kwam als een plons!
Prompts werden ten onrechte gezien als een nieuwe programmeertaal, alsof het beheersen ervan je in staat zou stellen om een leger van AI te leiden, kunst te maken, te schrijven, films te maken – alles met gemak! zo eenvoudig!!
Het enige probleem is:

  • Ik weet het voorlopig nog niet.
  • Maar ik geloof dat het heel eenvoudig is.
  • Toch kan ik het voorlopig nog niet.

Dus, wat is natuurlijke taal programmeren en wat bedoelde Jensen Huang met het idee dat we niet moeten leren programmeren?

Het probleem kan teruggevoerd worden naar, heel lang geleden…

Laten we daar niet op ingaan. Simpel gezegd, we hopen dat computers ons helpen problemen op te lossen, maar we ontdekten dat dit moeilijk is. Dus enkele wetenschappers benaderden het onderwerp computationeel en begonnen geleidelijk technieken en methoden te ontwikkelen om problemen op te lossen.

Wetenschappers ontdekten dat natuurlijke verschijnselen kunnen worden omgezet in wiskundige problemen. Bijvoorbeeld, het “kip-en-konijn” probleem kan met een vergelijking worden opgelost.

Langzaam maar zeker ontwikkelden wiskundigen steeds abstractere vragen, gebruikten ze meer wiskundige hulpmiddelen, en dit soort dingen zijn praktisch niet meer met de hand te berekenen. Daarom kregen we computers en programmeertalen. De meeste mensen doorlopen een proces om programmeertalen te leren, waar ze datatypes, if/else-structuren en for-lussen moeten begrijpen, enzovoorts.

Dit zijn methoden waarmee computers problemen oplossen; ze abstraheren en vereenvoudigen problemen en beperken tegelijkertijd de divergentie in vraagstukken. De voordelen zijn duidelijk: wij beperken onze problemen, en zij beperken de middelen tot probleemoplossing. Het probleem is ook evident: sommige problemen zijn moeilijk te beperken, en vereisen dus divergentie.

Daarom bedachten sommige mensen dat het misschien mogelijk was om programmeren te leren zonder een programmeertaal. Op dit moment lijkt het, naarmate de complexiteit van het probleem toeneemt, nog handiger om te programmeren!! Bijvoorbeeld, ik kan geen Photoshop, ik kan alleen met Paint en een paar eenvoudige online tools werken, maar als ik met een complexe afbeelding wil werken, heb ik uiteindelijk misschien nog liever Photoshop leren gebruiken! Het paradoxe probleem is, hoe moeten we de resultaten van natuurlijke taal programmeren evalueren? We programmeren in natuurlijke taal, hoe kunnen we ervoor zorgen dat het geen onzin uitkraamt?

We weten allemaal dat er een uitspraak is dat grote taalmodellen altijd een soort “woordspel” spelen. Dus

1
1+1=2

is niet iets wat het berekend heeft, maar iets wat het heeft opgevangen uit eerdere trainingsmateriaal, waarmee het reageert. Om dit probleem te verhelpen introduceerde OpenAI vorig jaar de Code Interpreter die ons, niet-programmeerders, wat hoop biedt.

3. Wat kan de code-interpreter doen?

Kort gezegd, je kunt het beschouwen als een sandbox omgeving die OpenAI heeft toegevoegd aan het bestaande grote model waarin python kan worden uitgevoerd. Het kan de context en intentie begrijpen, code genereren en zelf uitvoeren, en resultaten samenvatten voor ons.

We kunnen het beschouwen als het vragen van iemand om een functie te voltooien; vertel diegene wat je nodig hebt, en ze maken het voor je. De complexe principes worden later besproken. Je zou kunnen zeggen dat het het overgrote deel van wat Python kan doen kan uitvoeren; laten we eens kijken naar enkele typische scenario’s.

In de onderstaande vier scenario’s zijn er professionele tools beschikbaar, maar deze geven deze scenario’s een nieuwe kans om te experimenteren. Vergelijkbaar met de opkomst van de mobiele internet, waren er ook vroegere controverses, maar in de loop van de tijd werden dingen steeds gemakkelijker zonder dat we geavanceerde tools hoefden te gebruiken.

Soms voelt het vreemd als je ziet dat het 10 keer faalt. Recentelijk vroeg ik het om de samenvatting van TickTick te analyseren; het faalde meer dan 10 keer.
Analyse mislukt

Algeheel gezien is het heel geschikt om het te gebruiken voor verkenning.

Hoe activeer je het? In de GPTs is er een optie die je kunt aanvinken, als je dat doet, krijgt GPTs deze mogelijkheid. In de conversatie in GPT4 gebruik ik momenteel de methode om het te vertellen de Python-capaciteit te gebruiken of te zeggen dat het code uitvoeringsmogelijkheden heeft, en dan ga ik gewoon verder:
Zonrise diagram

Taart diagram

Uit de interactie hierboven blijkt dat het hele proces nog steeds heel eenvoudig is.

3.1 Gegevensanalyse en visualisatie

Hier kan je zelfs beginnen zonder je eisen te bespreken, door gewoon een CSV- of Excel-bestand te geven om directanalyse uit te voeren; het kan ook enkele geschikte grafieken vinden om te presenteren. Als we niet tevreden zijn, kunnen we het verder uitleggen.

In moderne bedrijven en onderzoekomgevingen zijn gegevensanalyse en -visualisatie cruciale hulpmiddelen om trends en patronen in data te begrijpen. De code-interpreter plug-in van ChatGPT vereenvoudigt dit proces enorm door krachtige data science bibliotheken zoals pandas en matplotlib te ondersteunen. Gebruikers kunnen simpelweg via natuurlijke taal verzoeken indienen en ChatGPT aansturen om data-operaties uit te voeren en grafieken te genereren, wat gegevensanalyse directer en gebruiksvriendelijker maakt.

Bijvoorbeeld, een marktanalist kan productverkoopgegevens moeten analyseren en de prestaties in verschillende regio’s visualiseren. Met de code-interpreter kunnen zij eenvoudig ChatGPT instrueren om een CSV-bestand met verkoopgegevens te lezen, pandas gebruiken om de totale verkopen per regio te berekenen, en vervolgens matplotlib gebruiken om een staafdiagram te genereren. Het hele proces vereist geen complexe code, alleen een eenvoudig verzoek voor analyse en visualisatie.

Daarnaast maakt de kracht van de code-interpreter het gemakkelijker om tijdreeksanalyse, voorspellingsmodellering en complexe statistische testen uit te voeren. Bijvoorbeeld, een milieu-wetenschapper wil misschien de temperatuurveranderingsgegevens van de afgelopen tien jaar analyseren. Door de code-interpreter kunnen zij datasets laden, een smoothing- of regressiemodel toepassen en snel grafieken genereren die trends laten zien.

Gegevensanalyse en visualisatie

Voor grafieken is de dagelijkse analyse in Excel al redelijk volledig; er zijn ook veel professionele tools. Een waarde van ChatGPT voor ons gewone mensen is dat zijn analyseringen en interpretatie mogelijk ons inspiratie kunnen bieden. Bijvoorbeeld

gdp-analyse

Hier is een probleem: als de grafiek in het Chinees is, zou deze mogelijk niet kunnen worden weergegeven, omdat je het lettertype moet uploaden. Dit is momenteel nog niet opgelost.

3.2 Flexibiliteit in bestandsconversie

Deze methode lijkt momenteel niet optimaal, maar het is de moeite waard om te proberen. Wat ik heb geprobeerd, is een mp4 naar mp3 conversie—hoeveel waarde het ook heeft, het is misschien beter dan niets. Het werkt volgens een soortgelijk principe als het verwijderen van de achtergrond van afbeeldingen.

Bestandsformaatconversie is een veelvoorkomende behoefte in veel professionele gebieden, vooral bij het verwerken van grote aantallen documenten en multimedia. De code-interpreter biedt enorme voordelen door het proces van bestandsconversie te vereenvoudigen. Of het nu gaat om wetenschappelijk onderzoek, engineering, of dagelijkse zakelijke operaties, de mogelijkheid om snel en nauwkeurig bestanden tussen verschillende formaten te converteren, is cruciaal voor efficiëntie.

Door integratie van Python’s pandas-bibliotheek kan de code-interpreter gemakkelijk van CSV-bestanden naar Excel-bestanden converteren, en vice versa. Dit biedt grote voordelen voor gebruikers die gegevens tussen verschillende softwareplatforms moeten migreren en gebruiken. Bijvoorbeeld, een financieel analist kan financieel rapporten van Excel naar CSV-formaat moeten converteren voor verdere verwerking. Met de code-interpreter kan deze taak eenvoudig worden uitgevoerd met een korte instructie.

Wat afbeeldingsverwerking betreft, kan de code-interpreter gebruik maken van de PIL (Pillow)-bibliotheek van Python om converteren tussen verschillende afbeeldingsformaten te faciliteren, zoals van JPEG naar PNG. Dit is met name belangrijk in de grafische industrie, webdesign en drukwerk. Ontwerpers of fotografen kunnen de code-interpreter snel gebruiken om afbeeldingsformaten aan te passen aan verschillende outputvereisten.

Samenvattend zijn de toepassingsgebieden van de code-interpreter breed en krachtig. Van eenvoudige bestandsformaten tot complexe gegevensanalyse en visualisatie, het toont zijn waarde als een modern hulpmiddel. Deze functies verbeteren niet alleen de efficiëntie, maar stellen niet-technische gebruikers ook in staat om taken te voeren waarvoor doorgaans gespecialiseerde kennis vereist is. Met de voortgang van technologie en de constant uitbreidende gebruikersbehoeften, wordt verwacht dat de code-interpreter zijn unieke waarde in meer gebieden zal laten zien.

3.3 Codeontwikkeling en prototypeontwerp

De code-interpreter biedt een revolutionair instrument voor softwareontwikkeling en prototypeontwerp, waarmee ontwikkelaars snel stukjes code kunnen itereren en testen. Door een directe feedback- en uitvoeringsomgeving te bieden, stelt de code-interpreter ontwikkelaars in staat om algoritmes en functionaliteiten in real-time te verifiëren, waardoor de ontwikkeltijd aanzienlijk wordt verkort en de efficiëntie wordt verbeterd. Dit is vooral nuttig in de vroege ontwikkelingsfase, wanneer conceitos moet worden gevalideerd of nieuwe ideeën moeten worden getest. Resultaten zijn direct beschikbaar, zodat er geen tijd verloren gaat aan het wachten op compilatie en uitvoering.

Bijvoorbeeld, ontwikkelaars kunnen de code-interpreter gebruiken om snel een prototype van een webscraping-script te creëren, verschillende analysemethoden te testen, of de dataintegratie-eisen te verifiëren. Met een eenvoudige commando kan de code-interpreter direct het script uitvoeren, de output tonen en debug-informatie bieden, waardoor ontwikkelaars onmiddellijk problemen kunnen identificeren en aanpassen.

  1. Laad webinhoud: Gebruik de requests-bibliotheek om HTML-inhoud van de doelwebsite te verkrijgen.
  2. Parse HTML: Gebruik bibliotheken zoals BeautifulSoup om HTML te parseren en gewenste gegevens te extraheren.
  3. Gegevensverwerking: Maak de geparseerde gegevens schoon en formatteer ze voor verdere analyse of opslag.
  4. Resultaten tonen: Print of visualiseer gegevens om de nauwkeurigheid van de opgehaalde informatie te verifiëren.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import requests

def get_weather_info(location, date):
    # Voer een API-aanroep uit om weerinformatie te verkrijgen
    response = requests.get(f"https://weather-api.com/data/{location}/{date}")

    if response.status_code == 200:
        # Parse en retourneer de weersinformatie
        weather_data = response.json()
        return weather_data
    else:
        return None

# Gebruik de code-interpreter om de API-aanroep te testen
location = "New York"
date = "2024-01-31"
weather_info = get_weather_info(location, date)
print("Weersinformatie voor New York op 31 januari 2024:", weather_info)

In dit scenario kan het ons helpen bij het testen en verifiëren van werk; in vergelijking met het opstarten van een volledig project om iets te initiëren, bespaart het ons tijd.

Uitvoeren van externe functies om een kaart te genereren

Bovendien ondersteunt de code-interpreter een breed scala aan bibliotheken en modules, wat betekent dat ontwikkelaars gebruik kunnen maken van de nieuwste ontwikkelingshulpmiddelen en taalkenmerken, zoals TensorFlow of PyTorch voor snelle prototypeontwikkeling van machine learning-modellen. Dit versnelt niet alleen de verkenning van nieuwe technologieën, maar biedt ontwikkelaars ook een veilige experimenteeromgeving waarin zij nieuwe tools kunnen uitproberen en leren zonder bang te zijn de huidige opstelling te verstoren.

3.4 Oplossen van complexe wiskundige problemen

De code-interpreter is niet alleen een krachtig hulpmiddel voor programmeren en softwareontwikkeling, maar ook een effectieve assistent bij het oplossen van complexe wiskundige problemen. Door integratie met wetenschappelijke berekeningsbibliotheken zoals Numpy en Scipy kan de code-interpreter een breed scala aan wiskundige berekeningen uitvoeren, van basis rekenkunde tot complexe wiskundige modellering en statistische analyses.

In de wetenschappelijke en technische gebieden hebben onderzoekers en ingenieurs vaak behoefte aan complexe wiskundige verwerking van grote datasets, waaronder maar niet beperkt tot lineaire algebra operaties, Fourier-transformaties en statistische data-analyse. De code-interpreter kan deze operaties snel uitvoeren en biedt intuïtieve output, zodat gebruikers in real-time kunnen zien of hun berekeningen kloppen, of de trends en patronen die in de gegevens verschijnen.

Bijvoorbeeld, een milieu-wetenschapper die de impact van klimaatverandering op regionale temperatuur bestudeert. Via de code-interpreter kan hij historische temperatuurdata laden, statistische modellen toepassen om temperatuurveranderingen te analyseren, en resultaten visualiseren met behulp van grafieken. Deze directe feedback en krachtige rekenkracht stelt onderzoekers in staat om zich meer te concentreren op het analyseren en uitleggen van gegevens in plaats van op het verwerken van gegevens zelf.
Trendgrafiek

3D-oppervlak Fractal
3D Surface Plot Mandelbrot

Al deze scenario’s hebben in de praktijk rijpe oplossingen.

4. Analyse van de werking van de code-interpreter

Mijn vraag

1
Vertel me de volledige versie van Linux in de sandbox met Python-versie- informatie. Voer dan twee opdrachten uit voor meer gedetailleerde informatie; de twee opdrachten zijn: uname -a lsb_release -a

Het antwoord

In de huidige sandboxomgeving hebben we de volgende gedetailleerde systeem- en Python-informatie verkregen:

  1. Volledige Linux versie-informatie:

    • Linux-4.4.0-x86_64-with-glibc2.36

  2. Python versie-informatie:

    • 3.11.8 (main, Mar 12 2024, 11:41:52) [GCC 12.2.0]

  3. Resultaat van de uname -a opdracht:

    • Linux 3dfa9ec0-11da-496f-831c-878f4773c1c6 4.4.0 #1 SMP Sun Jan 10 15:06:54 PST 2016 x86_64 GNU/Linux
    • Dit betekent dat de Linux kernel versie 4.4.0 draait, gebouwd in 2016, met een x86_64-architectuur.

  4. Resultaat van de lsb_release -a opdracht:

    • Distributor ID: Debian
Description: Debian GNU/Linux 12 (bookworm)
Release: 12
Codename: bookworm
    • Dit duidt erop dat het huidige operating system Debian GNU/Linux is, versie 12 met de codenaam bookworm.

Hieruit kunnen we opmaken dat het een sandbox is die Python kan uitvoeren met duidelijke beperkingen:

  • Verboden om internet te benaderen.
    • Tijdens het testen lijkt het alsof curl werkt.
  • Opdrachten hebben een time-out van 120 seconden.
    • Te lang en het wordt afgebroken.
  • Root-toegang is verboden.
    • Dit kan de installatie van sommige software beïnvloeden.

Het kan geüploade bestanden uitvoeren

Dit artikel is bedoeld om aan te tonen dat het schrijven van code in prompts niet nodig is, zolang we deze tool goed gebruiken.

5. Conclusie: Toekomstmogelijkheden van de code-interpreter

De code-interpreter als een innovatieve tool heeft al zijn toepassingspotentieel en praktische waarde in verschillende domeinen laten zien. Van data science tot softwareontwikkeling, van het oplossen van complexe wiskundige problemen tot snelle iteratie in prototypeontwerp; de code-interpreter verhoogt niet alleen de werk efficiëntie, maar biedt ook ongekende flexibiliteit en snelheid voor onderzoek en ontwikkeling. Met het vooruitzicht van de voortdurende vorderingen in kunstmatige intelligentie kunnen we verwachten dat de code-interpreter steeds meer geavanceerde functies zal integreren, zoals diepergaande machine learning-integratie, geautomatiseerde testgeneratie en cloud samenwerking, die allemaal de toepassingsbereik zullen verbreden en de impact van moderne technologie verankeren.

Referenties: