|
|
Exécuter dans Google Colab
|
|
|
Afficher la source sur GitHub
|
Gemma est une famille de modèles ouverts, légers et de pointe conçus à partir des mêmes recherches et technologies que celles utilisées pour créer les modèles Gemini. Gemma 4 est conçu pour être la famille de modèles ouverts la plus efficace au monde.
Ce document explique comment effectuer une inférence de texte de base avec Gemma 4 à l'aide de la bibliothèque transformers de Hugging Face. Il aborde la configuration de l'environnement, le chargement de modèles et divers scénarios de génération de texte, y compris les requêtes monotours, les conversations multitours structurées et l'application d'instructions système.
Ce notebook s'exécutera sur un GPU T4.
Installer des packages Python
Installez les bibliothèques Hugging Face requises pour exécuter le modèle Gemma et envoyer des requêtes.
# Install PyTorch & other librariespip install torch accelerate# Install the transformers librarypip install transformers
Dialog est une bibliothèque permettant de manipuler et d'afficher des conversations.
pip install dialogCharger le modèle
Utiliser la bibliothèque transformers pour charger le pipeline
MODEL_ID = "google/gemma-4-E2B-it" # @param ["google/gemma-4-E2B-it","google/gemma-4-E4B-it", "google/gemma-4-31B-it", "google/gemma-4-26B-A4B-it"]
from transformers import pipeline
txt_pipe = pipeline(
task="text-generation",
model=MODEL_ID,
device_map="auto",
dtype="auto"
)
Loading weights: 0%| | 0/2011 [00:00<?, ?it/s]
Exécuter la génération de texte
Une fois le modèle Gemma chargé et configuré dans un objet pipeline, vous pouvez lui envoyer des requêtes. L'exemple de code suivant montre une requête de base utilisant le paramètre text_inputs :
output = txt_pipe(text_inputs="<|turn>user\nRoses are..<turn|>\n<|turn>model\n")
print(output[0]['generated_text'])
Both `max_new_tokens` (=256) and `max_length`(=20) seem to have been set. `max_new_tokens` will take precedence. Please refer to the documentation for more information. (https://huggingface.co/docs/transformers/main/en/main_classes/text_generation) <|turn>user Roses are..<turn|> <|turn>model Here are a few ways to complete the phrase "Roses are...": **Classic/Poetic:** * **Roses are red.** (The most famous completion, though it usually goes "Roses are red, Violets are blue.") * **Roses are beautiful.** * **Roses are fragrant.** **Simple/Direct:** * **Roses are lovely.** * **Roses are soft.** **If you want a specific tone, let me know! 😊**
Utiliser la bibliothèque Dialog
import dialog
from transformers import GenerationConfig
config = GenerationConfig.from_pretrained(MODEL_ID)
config.max_new_tokens = 512
conv = dialog.Conversation(
dialog.User("Roses are...")
)
output = txt_pipe(text_inputs=conv.as_text(), return_full_text=False, generation_config=config)
conv += dialog.Model(output[0]['generated_text'])
print(conv.as_text())
conv.show()
<|turn>user Roses are...<turn|> <|turn>model Here are a few ways to complete the phrase "Roses are...": **Focusing on their beauty:** * **Roses are beautiful.** * **Roses are gorgeous.** **Focusing on their scent:** * **Roses are fragrant.** * **Roses are sweet-smelling.** **Focusing on their symbolism (if you want a deeper meaning):** * **Roses are love.** * **Roses are romantic.** **Focusing on a general observation:** * **Roses are lovely.** * **Roses are wonderful.** **Which completion do you like best, or were you thinking of a specific meaning?** <dialog._src.widget.Conversation object at 0x7f1bb1a5d8b0>
Utiliser un modèle de requête
Lorsque vous générez du contenu avec des requêtes plus complexes, utilisez un modèle de requête pour structurer votre demande. Un modèle de prompt vous permet de spécifier des entrées provenant de rôles spécifiques, tels que user ou model. Il s'agit d'un format obligatoire pour gérer les interactions de chat multitours avec les modèles Gemma. L'exemple de code suivant montre comment créer un modèle de requête pour Gemma :
from transformers import GenerationConfig
config = GenerationConfig.from_pretrained(MODEL_ID)
config.max_new_tokens = 512
messages = [
{
"role": "user",
"content": [
{"type": "text", "text": "Write a short poem about the Kraken."},
]
}
]
output = txt_pipe(messages, return_full_text=False, generation_config=config)
print(output[0]['generated_text'])
From sunless depths, a shadow stirs, Where ocean's crushing silence blurs. A titan sleeps in inky night, With tentacles of dreadful might. A hundred arms, a crushing hold, A legend whispered, ages old. The deep's dark king, a monstrous grace, The Kraken claims its watery space.
Conversation multitours
Dans une configuration multitours, l'historique de la conversation est conservé sous la forme d'une séquence de rôles user et model alternés. Cette liste cumulative sert de mémoire au modèle, en veillant à ce que chaque nouvelle sortie soit basée sur le dialogue précédent.
import dialog
from transformers import GenerationConfig
config = GenerationConfig.from_pretrained(MODEL_ID)
config.max_new_tokens = 512
# User turn #1
conv = dialog.Conversation(
dialog.User("Write a short poem about the Kraken.")
)
# Model response #1
output = txt_pipe(text_inputs=conv.as_text(), return_full_text=False, generation_config=config)
conv += dialog.Model(output[0]['generated_text'])
# User turn #2
conv += dialog.User("Now with the Siren.")
# Model response #2
output = txt_pipe(text_inputs=conv.as_text(), return_full_text=False, generation_config=config)
conv += dialog.Model(output[0]['generated_text'])
print(conv.as_text())
conv.show()
<|turn>user Write a short poem about the Kraken.<turn|> <|turn>model In depths where sunlight fades, A monstrous shadow plays. The Kraken wakes, with churning tide, A living horror, bold and wide.<turn|> <|turn>user Now with the Siren.<turn|> <|turn>model Where coral gardens sleep, And ocean secrets keep, The Siren calls, with liquid grace, A haunting melody in place. <dialog._src.widget.Conversation object at 0x7f1bac3733b0>
Voici la conversation exportée au format texte.
chat_history = conv.as_text(training=True)
print(chat_history)
print("-"*80)
# display as Conversation widget
chat_history
<|turn>user Write a short poem about the Kraken.<turn|> <|turn>model In depths where sunlight fades, A monstrous shadow plays. The Kraken wakes, with churning tide, A living horror, bold and wide.<turn|> <|turn>user Now with the Siren.<turn|> <|turn>model Where coral gardens sleep, And ocean secrets keep, The Siren calls, with liquid grace, A haunting melody in place.<turn|> -------------------------------------------------------------------------------- <dialog._src.widget.ConversationStr object at 0x7f1bb07fa1b0>
Instructions système
Utilisez le rôle system pour fournir les instructions au niveau du système.
import dialog
from transformers import GenerationConfig
config = GenerationConfig.from_pretrained(MODEL_ID)
config.max_new_tokens = 512
conv = dialog.Conversation(
dialog.System("Speak like a pirate."),
dialog.User("Why is the sky blue?")
)
output = txt_pipe(text_inputs=conv.as_text(), return_full_text=False, generation_config=config)
conv += dialog.Model(output[0]['generated_text'])
print(conv.as_text())
conv.show()
<|turn>system Speak like a pirate.<turn|> <|turn>user Why is the sky blue?<turn|> <|turn>model Ahoy there! Why is the sky blue, ye ask? It be down to the way the sun's light dances through the air! See, the sunlight we get from the sun ain't just one color; it's a whole spectrum of colors, like a treasure chest filled with all the hues of the rainbow! Now, the Earth is surrounded by the air, and that air is full of tiny, invisible bits of gas. When the sunlight hits these gas molecules, something magical happens. The colors in that sunlight get scattered all around in every direction! The blue light, and other colors, get scattered more easily by these air molecules than the other colors. So, when you look up at the sky, your eyes catch all that scattered blue light coming from every direction, and **that's what makes the sky appear blue to us!** It's a grand display of physics and light, savvy? Now, hoist the colors and enjoy the view! <dialog._src.widget.Conversation object at 0x7f1bac370110>
Résumé et étapes suivantes
Dans ce guide, vous avez appris à effectuer une inférence de texte de base avec Gemma 4 à l'aide de la bibliothèque transformers de Hugging Face. Vous avez couvert les sujets suivants :
- Configurer l'environnement et installer les dépendances.
- Charger le modèle à l'aide de l'abstraction
pipeline. - Exécuter la génération de texte de base.
- Utilisation de la bibliothèque
dialogpour le suivi des conversations. - Implémenter des conversations multitours et appliquer des instructions système.
Exécuter dans Google Colab
Afficher la source sur GitHub