Exécution du code

Python Node.js Go REST

La fonctionnalité d'exécution de code de l'API Gemini permet au modèle de générer et d'exécuter du code Python, et d'apprendre de manière itérée à partir des résultats jusqu'à obtenir un résultat final. Vous pouvez utiliser cette fonctionnalité d'exécution de code pour créer des applications qui bénéficient du raisonnement basé sur le code et qui produisent une sortie textuelle. Par exemple, vous pouvez utiliser l'exécution de code dans une application qui résout des équations ou traite du texte.

L'exécution du code est disponible à la fois dans AI Studio et dans l'API Gemini. Dans AI Studio, vous pouvez activer l'exécution du code dans le panneau de droite sous Outils. L'API Gemini fournit l'exécution de code en tant qu'outil, semblable à l'appel de fonction. Une fois que vous avez ajouté l'exécution de code en tant qu'outil, le modèle décide quand l'utiliser.

L'environnement d'exécution du code inclut les bibliothèques suivantes : altair, chess, cv2, matplotlib, mpmath, numpy, pandas, pdfminer, reportlab, seaborn, sklearn, statsmodels, striprtf, sympy et tabulate. Vous ne pouvez pas installer vos propres bibliothèques.

Premiers pas avec l'exécution de code

Un notebook d'exécution de code est également disponible:

Afficher sur ai.google.dev

Essayer un notebook Colab

Afficher le notebook sur GitHub

Cette section suppose que vous avez suivi les étapes de configuration et de configuration décrites dans le guide de démarrage rapide.

Activer l'exécution du code sur le modèle

Vous pouvez activer l'exécution de code sur le modèle, comme indiqué ci-dessous:

from google import genai
from google.genai import types

client = genai.Client(api_key="GEMINI_API_KEY")

response = client.models.generate_content(
  model='gemini-2.0-flash',
  contents='What is the sum of the first 50 prime numbers? '
           'Generate and run code for the calculation, and make sure you get all 50.',
  config=types.GenerateContentConfig(
    tools=[types.Tool(
      code_execution=types.ToolCodeExecution
    )]
  )
)

Dans un notebook, vous pouvez afficher tout le contenu au format Markdown à l'aide de cette fonction d'assistance:

def display_code_execution_result(response):
  for part in response.candidates[0].content.parts:
    if part.text is not None:
      display(Markdown(part.text))
    if part.executable_code is not None:
      code_html = f'<pre style="background-color: #BBBBEE;">{part.executable_code.code}</pre>' # Change code color
      display(HTML(code_html))
    if part.code_execution_result is not None:
      display(Markdown(part.code_execution_result.output))
    if part.inline_data is not None:
      display(Image(data=part.inline_data.data, format="png"))
    display(Markdown("---"))

display_code_execution_result(response)

Le résultat peut ressembler à ceci:

D\'accord. Je dois calculer la somme des 50 premiers nombres premiers. Je vais utiliser un script Python pour générer les 50 premiers nombres premiers, puis les additionner.

```python
def is_prime(n):
  """Checks if a number is prime."""
  if n <= 1:
    return False
  for i in range(2, int(n**0.5) + 1):
    if n % i == 0:
      return False
  return True

def sum_of_primes(n):
  """Calculates the sum of the first n prime numbers."""
  primes = []
  i = 2
  while len(primes) < n:
    if is_prime(i):
      primes.append(i)
    i += 1
  return sum(primes)

# Calculate the sum of the first 50 prime numbers
sum_of_first_50_primes = sum_of_primes(50)

print(f"The sum of the first 50 prime numbers is: {sum_of_first_50_primes}")
```

**Output:**

```
The sum of the first 50 prime numbers is: 5117
```

Utiliser l'exécution de code dans le chat

Vous pouvez également utiliser l'exécution de code dans le cadre d'un chat.

from google import genai
from google.genai import types

client = genai.Client(api_key="GEMINI_API_KEY")

chat = client.chats.create(
    model='gemini-2.0-flash',
    config=types.GenerateContentConfig(
      tools=[types.Tool(
        code_execution=types.ToolCodeExecution
      )]
    )
)

response = chat.send_message("Can you run some code to bogo-sort this list of numbers?: [2,34,1,65,4]")
display_code_execution_result(response)

La conversation pourrait se poursuivre comme suit:

Si je comprends bien, vous souhaitez que je trie la liste [2, 34, 1, 65, 4] en utilisant la méthode Bogosort. Le bogosort est un algorithme de tri notoirement inefficace. Il fonctionne en mélangeant la liste à plusieurs reprises jusqu'à ce qu'elle soit triée. En raison de ses performances extrêmement médiocres, il est peu pratique pour les listes de grande taille.

Toutefois, à des fins de démonstration, je peux exécuter une version simplifiée pour un nombre très limité d'itérations, juste pour montrer le processus. Est-ce que vous confirmez ?

response = chat.send_message("Yes, please create the code.")
display_code_execution_result(response)

D\'accord,je vais créer une fonction qui mélange la liste et vérifie si elle est triée. Je l'exécuterai pour un maximum de 10 itérations. …

Entrée/Sortie (E/S)

À partir de Gemini 2.0 Flash, l'exécution de code est compatible avec l'entrée de fichiers et la sortie de graphiques. Grâce à ces nouvelles fonctionnalités d'entrée et de sortie, vous pouvez importer des fichiers CSV et texte, poser des questions sur les fichiers et générer des graphiques Matplotlib en réponse.

Tarifs des E/S

Lorsque vous utilisez l'E/S d'exécution de code, les jetons d'entrée et de sortie vous sont facturés:

Jetons d'entrée:

• Requête de l'utilisateur

Jetons de sortie:

• Code généré par le modèle
• Sortie de l'exécution du code dans l'environnement de code
• Résumé généré par le modèle

Détails des E/S

Lorsque vous travaillez avec les entrées/sorties d'exécution de code, tenez compte des détails techniques suivants:

• La durée d'exécution maximale de l'environnement de code est de 30 secondes.
• Si l'environnement de code génère une erreur, le modèle peut décider de générer à nouveau la sortie du code. Cela peut se produire jusqu'à cinq fois.
• La taille maximale d'entrée de fichier est limitée par la fenêtre de jeton du modèle. Dans AI Studio, avec Gemini Flash 2.0, la taille maximale du fichier d'entrée est de 1 million de jetons (environ 2 Mo pour les fichiers texte des types d'entrée acceptés). Si vous importez un fichier trop volumineux, AI Studio ne vous permettra pas de l'envoyer.

Facturation

L'activation de l'exécution de code à partir de l'API Gemini n'entraîne aucun coût supplémentaire. Vous serez facturé au tarif actuel des jetons d'entrée et de sortie en fonction du modèle Gemini que vous utilisez.

Voici quelques autres points à connaître concernant la facturation de l'exécution du code:

• Vous ne serez facturé qu'une seule fois pour les jetons d'entrée que vous transmettez au modèle, et pour les jetons de sortie finaux qui vous sont renvoyés par le modèle.
• Les jetons représentant le code généré sont comptabilisés comme des jetons de sortie. Le code généré peut inclure du texte et une sortie multimodale, comme des images.
• Les résultats de l'exécution du code sont également comptabilisés comme des jetons de sortie.

Le modèle de facturation est illustré dans le schéma suivant:

• Vous êtes facturé au tarif actuel des jetons d'entrée et de sortie en fonction du modèle Gemini que vous utilisez.
• Si Gemini utilise l'exécution de code pour générer votre réponse, la requête d'origine, le code généré et le résultat du code exécuté sont désignés comme jetons intermédiaires et sont facturés en tant que jetons d'entrée.
• Gemini génère ensuite un récapitulatif et renvoie le code généré, le résultat du code exécuté et le récapitulatif final. Ils sont facturés en tant que jetons de sortie.
• L'API Gemini inclut un nombre de jetons intermédiaires dans la réponse de l'API afin que vous sachiez pourquoi vous recevez des jetons d'entrée supplémentaires au-delà de votre invite initiale.

Limites

• Le modèle ne peut générer et exécuter du code que. Il ne peut pas renvoyer d'autres artefacts tels que des fichiers multimédias.
• Dans certains cas, l'activation de l'exécution de code peut entraîner des régressions dans d'autres domaines de la sortie du modèle (par exemple, l'écriture d'une histoire).
• La capacité des différents modèles à utiliser l'exécution de code avec succès varie.