Points clés
Gemma 3 27B est un modèle d’IA multimodale de pointe, publié par Google, avec 27 milliards de paramètres et la prise en charge de plus de 140 langues.
L’appel de fonctions via des outils comme LangChain permet une intégration transparente avec des systèmes externes, étendant ses capacités pour exécuter des tâches spécialisées telles que les calculs, l’analyse de données et l’automatisation des workflows.
Combiné aux capacités multimodales de Gemma 3 27B, l’appel de fonctions améliore considérablement l’automatisation des tâches, permettant une coopération avancée entre le texte, le traitement d’images et les outils externes. La disponibilité open-source encourage une large adoption et l’innovation dans tous les secteurs.
Gemma 3 27B représente une percée dans l’IA multimodale, offrant des capacités inégalées pour comprendre et générer du texte et des images. Avec 27 milliards de paramètres et la prise en charge de plus de 140 langues, il gère sans effort des tâches complexes dans tous les secteurs.
Qu’est-ce que Gemma 3 27B ?
Date de sortie
12 mars 2025
Taille du modèle
27 milliards de paramètres
Open Source
Oui (publié par Google)
Langues prises en charge
Plus de 140 langues
Données d’entraînement
14 000 milliards de tokens
Points forts
Mathématiques, codage, suivi d’instructions
Capacité multimodale
Oui (traite les images et le texte, produit du texte)
Fenêtre de contexte
128 000 tokens
Test de capacité multimodale de Gemma 3 27B
Prompt : Dites-moi combien de fois le score Elo a augmenté de gemma 2 27b à gemma 3 27b ?
De Google
Réponse : A correctement identifié les nombres mais n’a pas calculé les multiples comme demandé par le prompt ; a seulement calculé la différence.
D’après l’image, voici le calcul :
- Score Elo de Gemma 2 27B : 1220
- Score Elo de Gemma 3 27B : 1338
Augmentation : 1338 - 1220 = 118
Le score Elo a augmenté de 118 points de Gemma 2 27B à Gemma 3 27B.
Benchmark de Gemma 3 27B
| Benchmark | Gemma 3 27B | DeepSeek R1 | LLaMA 3.3 70B |
|---|---|---|---|
| LMSys Elo Score | 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 |
De Hugging Face
Quels problèmes peuvent être résolus en combinant modèles multimodaux et appel de fonctions ?
Problème 1
Gérer de gros fichiers avec des ressources limitées
Bien que les LLM puissent traiter directement des images ou des vidéos, la gestion de fichiers volumineux (par exemple, longues vidéos ou images haute résolution) peut consommer des ressources importantes et dépasser la fenêtre de contexte du modèle.
Rôle de l’appel de fonctions : Distribuer des tâches complexes ou gourmandes en ressources à des systèmes externes, permettant au LLM de se concentrer sur la coordination et l’intégration des résultats.
Problème 2
Étendre les capacités pour des fonctionnalités spécifiques
Les LLM sont principalement axés sur la compréhension et la génération de contenu, mais dans certains scénarios, les utilisateurs peuvent avoir besoin de fonctionnalités plus spécifiques (par exemple, génération de graphiques, édition d’images, découpage vidéo) qui dépassent les capacités intégrées du LLM.
Rôle de l’appel de fonctions : Étendre les capacités du LLM en lui permettant de générer ou d’exécuter des sorties spécialisées via des outils externes.
Problème 3
Réaliser une analyse plus approfondie avec des outils professionnels
Bien que les LLM puissent analyser des entrées multimodales comme le texte, les images et les vidéos, il leur manque souvent la profondeur nécessaire pour effectuer des tâches de niveau professionnel, comme l’analyse d’images médicales ou le montage vidéo de haute précision.
Rôle de l’appel de fonctions : Déléguer des tâches à des outils ou API professionnels, garantissant une précision et une analyse plus approfondies que ce que le LLM seul peut fournir.
Comment utiliser l’appel de fonctions de Gemma 3 27B via Novita AI
Étape 1 : Obtenir une clé API et l’installer !
Rendez-vous sur la page “Gestion des clés” et copiez la clé API comme indiqué dans l’image.
Essayez la démo de Gemma 3 27B maintenant !
Étape 2 : Utiliser LangChain pour implémenter l’appel de fonctions
Nous allons créer une application mathématique simple capable d’effectuer des opérations d’addition et de multiplication.
💡 Bien que ce guide utilise LangChain pour plus de commodité, l’implémentation de l’appel de fonctions ne nécessite aucun framework spécifique. La clé réside dans la conception des bons prompts pour que le modèle comprenne et invoque correctement les fonctions. LangChain est utilisé ici simplement pour simplifier l’implémentation.
Prérequis
Tout d’abord, installez les paquets requis :
pip install langchain-openai python-dotenv
Configuration de l’environnement
Créez un fichier .env à la racine de votre projet et ajoutez votre clé API Novita AI :
NOVITA_API_KEY=your_api_key_here
Étape 3 : Étapes d’implémentation
1. Définir les outils
Commençons par créer deux outils mathématiques simples en utilisant le décorateur @tool de 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. Créer la fonction d’exécution des outils
Ensuite, implémentez une fonction pour exécuter les outils :
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. Configurer le pipeline LangChain
Créez une chaîne qui utilise le LLM de Novita AI pour sélectionner et préparer les appels d’outils :
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. Créer la fonction de traitement principale
Implémentez la fonction principale qui traite les requêtes mathématiques :
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. Exemple d’utilisation
Voici comment utiliser l’implémentation :
if __name__ == "__main__":
message, result = process_math_query(
"meta-llama/llama-3.3-70b-instruct",
"what's 3 plus 1132"
)
print(result) # Output: 1135
Gemma 3 27B redéfinit l’IA multimodale avec des performances de pointe en mathématiques, codage et tâches basées sur des instructions. Son intégration multimodale et ses données d’entraînement étendues en font un outil polyvalent pour les développeurs et les chercheurs.
Foire aux questions
Qu’est-ce que Gemma 3 27B ?
Gemma 3 27B est un modèle d’IA multimodale avec 27 milliards de paramètres, capable de traiter du texte et des images et prenant en charge plus de 140 langues.
Comment Gemma 3 27B se compare-t-il à son prédécesseur ?
Gemma 3 27B montre des améliorations significatives, notamment une augmentation du score Elo de 118 points et des performances améliorées en codage, mathématiques et tâches multimodales.
Gemma 3 27B est-il open source ?
Oui, Gemma 3 27B est open source, encourageant l’innovation pilotée par la communauté.
Novita AI est une plateforme cloud IA qui offre aux développeurs un moyen simple de déployer des modèles d’IA via notre API simple, tout en fournissant un cloud GPU abordable et fiable pour la construction et la mise à l’échelle.
