Google's Gemini-API erbjuder en unik funktion som kallas "kodexekvering" som gör att modellen kan generera och köra Python-kod, och lära sig iterativt från resultaten tills den når den slutliga utdata. Denna kraftfulla funktion gör det möjligt för utvecklare att bygga applikationer som drar nytta av kodbaserad logik, som att lösa ekvationer eller bearbeta text.

De viktigaste fördelarna med kodexekvering jämfört med vanligt funktionsanrop är:

1. Enkelhet: Språkmodellen avgör om den behöver skriva kod för att utföra en viss åtgärd, och den kan köra koden i API-backend. Detta är mycket enklare att använda jämfört med att ställa in en utvecklingsmiljö och göra flera API-anrop.

2. Flexibilitet: Med kodexekvering kan modellen iterera på koden och förfina utdata, medan funktionsanrop är begränsade till en enda API-förfrågan.

3. Isolering: Kodexekveringen sker i en helt isolerad miljö, vilket innebär att utvecklare inte behöver oroa sig för den underliggande infrastrukturen.

Det finns dock vissa begränsningar för kodexekveringsfunktionen:

• Den är för närvarande begränsad till Python och en specifik uppsättning bibliotek (NumPy och SciPy).
• Den kan inte returnera artefakter som mediefiler eller hantera icke-textutdata (t.ex. dataplotter).
• Kodexekveringen är begränsad till maximalt 30 sekunder, vilket kanske inte är lämpligt för alla användningsfall.

Trots dessa begränsningar kan kodexekveringsfunktionen vara extremt kraftfull för utvecklare, särskilt när de bygger agenter med Gemini 1.5 Flash- eller Pro-modeller. Exemplen i transkriptet visar hur modellen kan generera och köra kod för att lösa olika problem, inklusive matematiska beräkningar, strängtransformeringar, dataanalys, webbskrapning och till och med träning av maskininlärningsmodeller.

Genom att utnyttja kodexekveringsfunktionen kan utvecklare skapa mer sofistikerade och kapabla applikationer som kan dra nytta av modellens logik och iterativa problemlösningsförmåga.

De viktigaste skillnaderna mellan kodexekvering och vanligt funktionsanrop i sammanhanget av stora språkmodeller (LLM) som Gemini är:

1. Kodexekvering:

   • LLM:en kan generera och köra kod direkt inom API-backend.
   • Modellen avgör om den behöver skriva kod för att utföra en viss åtgärd och kan köra koden.
   • Det är en enda API-förfrågan, och kodexekveringen sker i backend, vilket gör att modellen kan iterera på lösningen.
   • För närvarande begränsad till Python och specifika bibliotek som NumPy och SciPy.
   • Har begränsningar som ingen fil-I/O, icke-textutdata och en tidsgräns på 30 sekunder för exekveringen.

2. Funktionsanrop:

   • Möjliggör interaktion med verkliga API:er eller verktyg med hjälp av externa funktioner.
   • Kräver att man tillhandahåller en lista över verktyg som modellen kan komma åt och ställer in utvecklingsmiljön.
   • Kan behöva göra flera API-anrop för att uppnå en uppgift.
   • Ger mer flexibilitet när det gäller språk, ramverk och funktionalitet.
   • Kräver mer konfiguration och hantering av den externa miljön.

Google rekommenderar att använda kodexekvering om uppgiften kan utföras inom de tillhandahållna möjligheterna, eftersom det är enklare att använda och inte kräver hantering av den externa miljön. Funktionsanrop erbjuder dock mer flexibilitet när uppgiften kräver åtkomst till externa resurser eller funktionalitet som inte finns i kodexekveringsmiljön.

Google's Gemini-API erbjuder en kraftfull funktion som kallas "kodexekvering" som gör det möjligt för utvecklare att generera och köra Python-kod inom API:et. Denna funktion möjliggör byggandet av applikationer som drar nytta av kodbaserad logik, som att lösa ekvationer eller bearbeta text.

Låt oss utforska några exempel på hur denna funktion kan användas:

Enkel matematik

Gemini-API:et kan generera och köra kod för att utföra grundläggande matematiska operationer, som att beräkna summan av de första 200 primtalen.

# Generera och kör kod för att beräkna summan
result = """
import math

primes = []
num = 2
while len(primes) < 200:
    is_prime = True
    for i in range(2, int(math.sqrt(num)) + 1):
        if num % i == 0:
            is_prime = False
            break
    if is_prime:
        primes.append(num)
    num += 1

total_sum = sum(primes)
print(f"The sum of the first 200 prime numbers is: {total_sum}")
"""

Utdatan visar den beräknade summan av de första 200 primtalen.

Strängtransformering

Gemini-API:et kan också generera och köra kod för att utföra olika strängtransformeringsuppgifter, som att konvertera en sträng till versaler, räkna antalet "o"-tecken och vända på strängen.

# Generera och kör kod för strängtransformering
result = """
text = "hello world, welcome to Gemini API"

# Konvertera till versaler
upper_text = text.upper()
print(f"Uppercase text: {upper_text}")

# Räkna antalet 'o'-tecken
o_count = text.count('o')
print(f"Number of 'o' characters: {o_count}")

# Vänd på strängen
reversed_text = text[::-1]
print(f"Reversed text: {reversed_text}")
"""

Utdatan visar resultaten av strängtransformeringsuppgifterna.

Dataanalys

Gemini-API:et kan generera och köra kod för att utföra grundläggande dataanalysuppgifter, som att generera slumpmässiga tal, beräkna statistik (medelvärde, median, typvärde) och skapa ett histogram.

# Generera och kör kod för dataanalys
result = """
import numpy as np
import matplotlib.pyplot as plt

# Generera slumpmässiga tal mellan 100 och 1000
numbers = np.random.randint(100, 1001, size=1000)

# Beräkna statistik
mean = np.mean(numbers)
median = np.median(numbers)
mode = stats.mode(numbers)[0]
min_value = np.min(numbers)
max_value = np.max(numbers)
total_sum = np.sum(numbers)

print(f"Mean: {mean:.2f}")
print(f"Median: {median:.2f}")
print(f"Mode: {mode}")
print(f"Minimum: {min_value}")
print(f"Maximum: {max_value}")
print(f"Sum: {total_sum}")

# Skapa ett histogram
plt.hist(numbers, bins=30)
plt.xlabel("Value")
plt.ylabel("Frequency")
plt.title("Histogram of Random Numbers")
plt.show()
"""

Utdatan innehåller de beräknade statistikvärdena och ett histogram över de genererade slumpmässiga talen.

Dessa exempel visar på mångfalden i Gemini-API:ets kodexekveringsfunktion, som gör det möjligt för utvecklare att utnyttja modellens förmågor för att effektivt lösa en bred uppsättning problem.

Gemini-API:ets kodexekveringsfunktion gör det möjligt för utvecklare att inte bara generera kod, utan också köra den inom API:ets backend. Denna funktion sträcker sig bortom enkla matematiska operationer eller strängtransformeringar, och möjliggör generering av datavisualisering och träning av maskininlärningsmodeller.

När vi testade kodexekveringsfunktionen innehöll exempeluppmaningarna en begäran om att skapa en histogram-plot. Även om API:et kunde generera den nödvändiga Python-koden för att producera diagrammet, kunde det inte direkt returnera diagramartefakten. Dock kan den genererade koden köras lokalt, vilket gör att utvecklaren kan generera den önskade visualiseringen.

På liknande sätt visade API:et förmågan att generera syntetiska data, dela upp dem i tränings- och testuppsättningar, skapa och träna en linjär regressionsmodell och utvärdera modellens prestanda på testuppsättningen. Återigen returnerade API:et Python-koden för att utföra dessa uppgifter, som utvecklaren sedan kan köra lokalt för att få de slutliga resultaten.

Dessa exempel visar på mångfalden i Gemini-API:ets kodexekveringsfunktion. Utvecklare kan utnyttja denna funktion för att bygga applikationer som kräver avancerad databearbetning, visualisering och maskininlärningskapaciteter, utan att behöva hantera den underliggande infrastrukturen eller ställa in komplexa utvecklingsmiljöer. API:et hanterar kodgenereringen och exekveringen, vilket gör att utvecklare kan fokusera på problemlösning på hög nivå och applikationsdesign.

Gemini-API:et erbjuder en gratis nivå för utvecklare att utforska kodexekveringsfunktionen. Det finns dock några begränsningar att ha i åtanke:

• Förfrågningsbegränsningar: Den gratis nivån har begränsningar för antalet förfrågningar du kan göra per minut. Detta är för att förhindra missbruk och säkerställa rättvis användning av API:et.

• Exekveringstid: Kodexekveringsfunktionen har en maximal körtid på 30 sekunder. All kod som tar längre tid än så kommer att avbrytas.

• Stödda bibliotek: Kodexekveringsmiljön har tillgång till en begränsad uppsättning bibliotek, främst NumPy och SciPy. Mer komplexa bibliotek eller anpassade paket stöds inte.

• Ingen fil-I/O eller icke-textutdata: Kodexekveringsfunktionen stöder inte fil-I/O-åtgärder eller generering av icke-textutdata som mediefiler. Detta innebär att du inte kan använda den för uppgifter som kräver dessa funktioner.

• Potentiell påverkan på andra funktioner: Aktivering av kodexekvering kan ibland ha en negativ inverkan på prestanda eller kvalitet för andra modellutdata, som att generera berättelser eller uppsatser. Detta är något att ha i åtanke när du använder funktionen.

För utvecklare som behöver mer flexibilitet eller högre användningsgränser erbjuder Google betalda nivåer av Gemini-API:et. Dessa nivåer ger ökade förfrågningsgränser, längre exekveringstider och tillgång till ett bredare utbud av bibliotek och funktioner.

Sammanfattningsvis kan kodexekveringsfunktionen i Gemini-API:et vara ett kraftfullt verktyg för utvecklare, men det är viktigt att förstå dess begränsningar och prissättningsstruktur för att säkerställa att den passar ditt användningsfall och budget.