A API Gemini do Google oferece um recurso exclusivo chamado "execução de código" que permite que o modelo gere e execute código Python, e aprenda iterativamente a partir dos resultados até chegar à saída final. Essa poderosa capacidade permite que os desenvolvedores criem aplicativos que se beneficiam do raciocínio baseado em código, como resolver equações ou processar texto.

As principais vantagens da execução de código em relação à chamada de função normal são:

1. Simplicidade: O modelo de linguagem decide se precisa escrever código para realizar uma determinada operação, e pode executar o código no back-end da API. Isso é muito mais simples de usar em comparação com a configuração de um ambiente de desenvolvimento e a realização de várias chamadas de API.

2. Flexibilidade: Com a execução de código, o modelo pode iterar no código e refinar a saída, enquanto a chamada de função é limitada a uma única solicitação de API.

3. Isolamento: A execução de código acontece em um ambiente completamente isolado, o que significa que os desenvolvedores não precisam se preocupar com a infraestrutura subjacente.

No entanto, existem algumas limitações no recurso de execução de código:

• Atualmente está limitado ao Python e a um conjunto específico de bibliotecas (NumPy e SciPy).
• Não pode retornar artefatos como arquivos de mídia ou lidar com saída não textual (por exemplo, gráficos de dados).
• A execução de código é limitada a um máximo de 30 segundos, o que pode não ser adequado para todos os casos de uso.

Apesar dessas limitações, o recurso de execução de código pode ser extremamente poderoso para os desenvolvedores, especialmente ao construir agentes com os modelos Gemini 1.5 Flash ou Pro. Os exemplos fornecidos na transcrição demonstram como o modelo pode gerar e executar código para resolver vários problemas, incluindo cálculos matemáticos, manipulações de strings, análise de dados, raspagem da web e até mesmo o treinamento de modelos de aprendizado de máquina.

Ao aproveitar a capacidade de execução de código, os desenvolvedores podem criar aplicativos mais sofisticados e capazes que podem se beneficiar do raciocínio do modelo e de suas habilidades de resolução de problemas iterativa.

As principais diferenças entre a execução de código e a chamada de função normal no contexto de modelos de linguagem de grande porte (LLMs) como o Gemini são:

1. Execução de Código:

   • O LLM pode gerar e executar código diretamente no back-end da API.
   • O modelo decide se precisa escrever código para realizar uma determinada operação e pode executar o código.
   • É uma única solicitação de API, e a execução de código acontece no back-end, permitindo que o modelo itere na solução.
   • Atualmente limitado ao Python e a bibliotecas específicas como NumPy e SciPy.
   • Tem limitações, como nenhuma entrada/saída de arquivo, saída não textual e um limite de tempo de execução de 30 segundos.

2. Chamada de Função:

   • Permite a interação com APIs ou ferramentas do mundo real usando funções externas.
   • Requer fornecer uma lista de ferramentas às quais o modelo pode acessar e configurar o ambiente de desenvolvimento.
   • Pode precisar fazer várias chamadas de API para concluir uma tarefa.
   • Oferece mais flexibilidade em termos de linguagem, estrutura e funcionalidade.
   • Requer mais configuração e gerenciamento do ambiente externo.

O Google recomenda usar a execução de código se a tarefa puder ser realizada dentro das capacidades fornecidas, pois é mais simples de usar e não requer o gerenciamento do ambiente externo. No entanto, a chamada de função oferece mais flexibilidade quando a tarefa requer acesso a recursos ou funcionalidades externos que não estão disponíveis no ambiente de execução de código.

A API Gemini do Google oferece um recurso poderoso chamado "execução de código" que permite que os desenvolvedores gerem e executem código Python dentro da API. Essa capacidade permite a construção de aplicativos que se beneficiam do raciocínio baseado em código, como resolver equações ou processar texto.

Vamos explorar alguns exemplos de como esse recurso pode ser utilizado:

Matemática Simples

A API Gemini pode gerar e executar código para realizar operações matemáticas básicas, como calcular a soma dos primeiros 200 números primos.

# Gerar e executar código para calcular a soma
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"A soma dos primeiros 200 números primos é: {total_sum}")
"""

A saída mostra a soma calculada dos primeiros 200 números primos.

Manipulação de Strings

A API Gemini também pode gerar e executar código para realizar várias tarefas de manipulação de strings, como converter uma string para maiúsculas, contar o número de caracteres "o" e inverter a string.

# Gerar e executar código para manipulação de strings
result = """
text = "hello world, welcome to Gemini API"

# Converter para maiúsculas
upper_text = text.upper()
print(f"Texto em maiúsculas: {upper_text}")

# Contar o número de caracteres 'o'
o_count = text.count('o')
print(f"Número de caracteres 'o': {o_count}")

# Inverter a string
reversed_text = text[::-1]
print(f"Texto invertido: {reversed_text}")
"""

A saída mostra os resultados das tarefas de manipulação de strings.

Análise de Dados

A API Gemini pode gerar e executar código para realizar tarefas básicas de análise de dados, como gerar números aleatórios, calcular estatísticas (média, mediana, moda) e criar um histograma.

# Gerar e executar código para análise de dados
result = """
import numpy as np
import matplotlib.pyplot as plt

# Gerar números aleatórios entre 100 e 1000
numbers = np.random.randint(100, 1001, size=1000)

# Calcular estatísticas
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"Média: {mean:.2f}")
print(f"Mediana: {median:.2f}")
print(f"Moda: {mode}")
print(f"Mínimo: {min_value}")
print(f"Máximo: {max_value}")
print(f"Soma: {total_sum}")

# Criar um histograma
plt.hist(numbers, bins=30)
plt.xlabel("Valor")
plt.ylabel("Frequência")
plt.title("Histograma de Números Aleatórios")
plt.show()
"""

A saída inclui as estatísticas calculadas e um histograma dos números aleatórios gerados.

Esses exemplos demonstram a versatilidade do recurso de execução de código da API Gemini, permitindo que os desenvolvedores aproveitem as capacidades do modelo para resolver uma ampla gama de problemas de maneira eficiente.

O recurso de execução de código da API Gemini permite que os desenvolvedores não apenas gerem código, mas também o executem no back-end da API. Essa capacidade vai além de simples operações matemáticas ou manipulações de strings, permitindo a geração de visualizações de dados e o treinamento de modelos de aprendizado de máquina.

Ao testar o recurso de execução de código, os exemplos de prompt incluíram uma solicitação para criar um gráfico de histograma. Embora a API tenha sido capaz de gerar o código Python necessário para produzir o gráfico, ela não pôde retornar diretamente o artefato do gráfico. No entanto, o código gerado pode ser executado localmente, permitindo que o desenvolvedor gere a visualização desejada.

Da mesma forma, a API demonstrou a capacidade de gerar dados sintéticos, dividi-los em conjuntos de treinamento e teste, criar e treinar um modelo de regressão linear e avaliar o desempenho do modelo no conjunto de teste. Novamente, a API retornou o código Python para realizar essas tarefas, que o desenvolvedor pode então executar localmente para obter os resultados finais.

Esses exemplos demonstram a versatilidade do recurso de execução de código da API Gemini. Os desenvolvedores podem aproveitar essa capacidade para construir aplicativos que exigem processamento de dados avançado, visualização e capacidades de aprendizado de máquina, sem a necessidade de gerenciar a infraestrutura subjacente ou configurar ambientes de desenvolvimento complexos. A API cuida da geração e execução do código, permitindo que os desenvolvedores se concentrem na resolução de problemas de alto nível e no design da aplicação.

A API Gemini oferece um plano gratuito para que os desenvolvedores explorem o recurso de execução de código. No entanto, existem algumas limitações a serem consideradas:

• Limites de Solicitação: O plano gratuito tem limites no número de solicitações que você pode fazer por minuto. Isso é para evitar abusos e garantir o uso justo da API.

• Tempo de Execução: O recurso de execução de código tem um tempo máximo de execução de 30 segundos. Qualquer código que leve mais tempo do que isso irá expirar.

• Bibliotecas Suportadas: O ambiente de execução de código tem acesso a um conjunto limitado de bibliotecas, principalmente NumPy e SciPy. Bibliotecas mais complexas ou pacotes personalizados não são suportados.

• Sem Entrada/Saída de Arquivo ou Saída Não Textual: O recurso de execução de código não suporta operações de entrada/saída de arquivo ou geração de saída não textual, como arquivos de mídia. Isso significa que você não pode usá-lo para tarefas que exigem essas capacidades.

• Possível Impacto em Outros Recursos: Habilitar a execução de código pode, às vezes, ter um impacto negativo no desempenho ou na qualidade de outras saídas do modelo, como a geração de histórias ou ensaios. Isso é algo a ser considerado ao usar o recurso.

Para desenvolvedores que precisam de mais flexibilidade ou limites de uso mais altos, o Google oferece planos pagos da API Gemini. Esses planos fornecem limites de solicitação aumentados, tempos de execução mais longos e acesso a um conjunto mais amplo de bibliotecas e capacidades.

Em geral, o recurso de execução de código na API Gemini pode ser uma ferramenta poderosa para os desenvolvedores, mas é importante entender suas limitações e estrutura de preços para garantir que ele se ajuste ao seu caso de uso e orçamento.