Destaques Principais
Gemma 3 27B é um modelo de IA multimodal de ponta, lançado pelo Google, com 27 bilhões de parâmetros e suporte para mais de 140 idiomas.
Chamada de Função por meio de ferramentas como LangChain permite integração perfeita com sistemas externos, expandindo suas capacidades para executar tarefas especializadas, como cálculos, análise de dados e automação de fluxos de trabalho.
Combinada com as capacidades multimodais do Gemma 3 27B, a Chamada de Função aprimora significativamente a automação de tarefas, permitindo uma cooperação avançada entre texto, processamento de imagens e ferramentas externas. A disponibilidade de código aberto incentiva a adoção e inovação em todos os setores.
Gemma 3 27B representa um avanço na IA multimodal, oferecendo capacidades incomparáveis na compreensão e geração de texto e imagens. Com impressionantes 27 bilhões de parâmetros e suporte para mais de 140 idiomas, ele lida facilmente com tarefas complexas em todos os setores.
O que é o Gemma 3 27B?
Data de Lançamento
12 de março de 2025
Tamanho do Modelo
27 bilhões de parâmetros
Código Aberto
Sim (lançado pelo Google)
Suporte a Idiomas
Mais de 140 idiomas
Dados de Treinamento
14 trilhões de tokens
Pontos Fortes
Matemática, programação, seguir instruções
Capacidade Multimodal
Sim (processa imagens e texto, gera texto)
Janela de Contexto
128 mil tokens
Teste de Capacidade Multimodal do Gemma 3 27B
Prompt: Diga-me quantas vezes a pontuação elo aumentou do gemma 2 27b para o gemma 3 27b?
Fonte: Google
Saída: Identificou corretamente os números, mas não calculou os múltiplos conforme instruído pelo prompt; em vez disso, apenas calculou a diferença.
Com base na imagem, aqui está o cálculo:
- Pontuação Elo do Gemma 2 27B: 1220
- Pontuação Elo do Gemma 3 27B: 1338
Aumento: 1338 - 1220 = 118
A pontuação Elo aumentou 118 pontos do Gemma 2 27B para o Gemma 3 27B.
Benchmark do Gemma 3 27B
| Benchmark | Gemma 3 27B | DeepSeek R1 | LLaMA 3.3 70B |
|---|---|---|---|
| Pontuação Elo LMSys | 1339 | ~1360 | ~1260 |
| MMLU-Pro | 67,5 | 84,0 | 66,4 |
| LiveCodeBench | 29,7 | 65,9 | ~29 |
| GPQA Diamond | 42,4 | 71,5 | 50,5 |
| MATH | 69,0 | 97,3 | 77,0 |
Fonte: Hugging Face
Quais problemas podem ser resolvidos combinando Modelos Multimodais com Chamada de Função?
Problema 1
Manipulação de arquivos grandes com recursos limitados
Embora os LLMs possam processar diretamente imagens ou vídeos, lidar com arquivos grandes (por exemplo, vídeos longos ou imagens de alta resolução) pode consumir muitos recursos e pode exceder a janela de contexto do modelo.
Papel da Chamada de Função: Distribuir tarefas complexas ou de alto consumo de recursos para sistemas externos, permitindo que o LLM se concentre em coordenar e integrar resultados.
Problema 2
Expandir capacidades para funcionalidades específicas
Os LLMs são focados principalmente em compreender e gerar conteúdo, mas em certos cenários, os usuários podem precisar de funcionalidades mais específicas (por exemplo, geração de gráficos, edição de imagens, corte de vídeo) que vão além das capacidades nativas do LLM.
Papel da Chamada de Função: Expandir as capacidades do LLM, permitindo que ele gere ou execute saídas especializadas por meio de ferramentas externas.
Problema 3
Alcançar análises mais profundas com ferramentas profissionais
Embora os LLMs possam analisar entradas multimodais como texto, imagens e vídeos, eles podem não ter a profundidade necessária para realizar tarefas de nível profissional, como análise de imagens médicas ou edição de vídeo de alta precisão.
Papel da Chamada de Função: Delegar tarefas a ferramentas ou APIs profissionais, garantindo maior precisão e análise mais profunda do que o LLM sozinho pode oferecer.
Como Usar a Chamada de Função do Llama 3.3 70B via Novita AI
Passo 1: Obter a Chave da API e Instalar!
Acessando a página “Gerenciamento de Chaves”, você pode copiar a chave da API conforme indicado na imagem.
Testar o Gemma 3 27B Demo Agora!
Passo 2: Usar LangChain para Implementar a Chamada de Função
Criaremos um aplicativo matemático simples que pode realizar operações de adição e multiplicação.
💡 Embora este guia use LangChain por conveniência, a implementação da chamada de função não requer nenhum framework específico. O segredo está em projetar os prompts corretos para fazer o modelo entender e invocar funções corretamente. O LangChain é usado aqui apenas para simplificar a implementação.
Pré-requisitos
Primeiro, instale os pacotes necessários:
pip install langchain-openai python-dotenv
Configuração do Ambiente
Crie um arquivo .env na raiz do seu projeto e adicione sua chave da API Novita AI:
NOVITA_API_KEY=sua_chave_api_aqui
Passo 3: Etapas de Implementação
1. Definir as Ferramentas
Primeiro, vamos criar duas ferramentas matemáticas simples usando o decorador @tool do LangChain:
from langchain_core.tools import tool
@tool
def multiply(x: float, y: float) -> float:
"""Multiply two numbers together."""
return x * y
@tool
def add(x: int, y: int) -> int:
"""Add two numbers."""
return x + y
tools = [multiply, add]
2. Criar a Função de Execução das Ferramentas
Em seguida, implemente uma função para executar as ferramentas:
from typing import Any, Dict, Optional, TypedDict
from langchain_core.runnables import RunnableConfig
class ToolCallRequest(TypedDict):
name: str
arguments: Dict[str, Any]
def invoke_tool(
tool_call_request: ToolCallRequest,
config: Optional[RunnableConfig] = None
):
"""Execute the specified tool with given arguments."""
tool_name_to_tool = {tool.name: tool for tool in tools}
name = tool_call_request["name"]
requested_tool = tool_name_to_tool[name]
return requested_tool.invoke(tool_call_request["arguments"], config=config)
3. Configurar o Pipeline LangChain
Crie uma cadeia que use o LLM da Novita AI para selecionar e preparar as chamadas de ferramenta:
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.tools import render_text_description
def create_chain():
"""Create a chain that uses the specified LLM model to select and prepare tool calls."""
model = ChatOpenAI(
model="google/gemma-3-27b-it",
api_key=os.getenv("NOVITA_API_KEY"),
base_url="https://api.novita.ai/v3/openai",
)
rendered_tools = render_text_description(tools)
system_prompt = f"""\
You are an assistant that has access to the following set of tools.
Here are the names and descriptions for each tool:
{rendered_tools}
Given the user input, return the name and input of the tool to use.
Return your response as a JSON blob with 'name' and 'arguments' keys.
The `arguments` should be a dictionary, with keys corresponding
to the argument names and the values corresponding to the requested values.
"""
prompt = ChatPromptTemplate.from_messages(
[("system", system_prompt), ("user", "{input}")]
)
return prompt | model | JsonOutputParser()
4. Criar a Função Principal de Processamento
Implemente a função principal que processa consultas matemáticas:
def process_math_query(query: str):
"""Process a mathematical query by using an LLM to select the appropriate tool and execute it."""
chain = create_chain()
message = chain.invoke({"input": query})
result = invoke_tool(message, config=None)
return message, result
5. Exemplo de Uso
Veja como usar a implementação:
if __name__ == "__main__":
message, result = process_math_query(
"meta-llama/llama-3.3-70b-instruct",
"what's 3 plus 1132"
)
print(result) # Output: 1135
O Gemma 3 27B redefine a IA multimodal com desempenho líder do setor em matemática, programação e tarefas baseadas em instruções. Sua integração multimodal e extensos dados de treinamento o tornam uma ferramenta versátil para desenvolvedores e pesquisadores.
Perguntas Frequentes
O que é o Gemma 3 27B?
O Gemma 3 27B é um modelo de IA multimodal com 27 bilhões de parâmetros, capaz de processar texto e imagens e suportar mais de 140 idiomas.
Como o Gemma 3 27B se compara ao seu predecessor?
O Gemma 3 27B mostra melhorias significativas, incluindo um aumento de 118 pontos na pontuação Elo e desempenho aprimorado em programação, matemática e tarefas multimodais.
O Gemma 3 27B é código aberto?
Sim, o Gemma 3 27B é de código aberto, incentivando a inovação impulsionada pela comunidade.
Novita AI é uma plataforma de nuvem de IA que oferece aos desenvolvedores uma maneira fácil de implantar modelos de IA usando nossa API simples, além de fornecer a nuvem de GPU acessível e confiável para construir e escalar.
