|
|
Uruchom w Google Colab
|
|
|
Wyświetl źródło na GitHubie
|
Gemma to rodzina lekkich, zaawansowanych otwartych modeli, które powstały na podstawie tych samych badań i technologii, które zostały wykorzystane do stworzenia modeli Gemini. Gemma 4 to najbardziej wydajna na świecie rodzina modeli z otwartymi wagami.
Ten dokument zawiera przewodnik po wykonywaniu podstawowego wnioskowania tekstowego za pomocą modelu Gemma 4 przy użyciu biblioteki Hugging Face transformers. Obejmuje konfigurację środowiska, wczytywanie modelu i różne scenariusze generowania tekstu, w tym promptów jednorazowych, strukturalnych rozmów wielokrotnych i stosowania instrukcji systemowych.
Ten notatnik będzie uruchamiany na procesorze graficznym T4.
Instalowanie pakietów Pythona
Zainstaluj biblioteki Hugging Face wymagane do uruchomienia modelu Gemma i wysyłania żądań.
# Install PyTorch & other librariespip install torch accelerate# Install the transformers librarypip install transformers
Dialog to biblioteka do manipulowania rozmowami i ich wyświetlania.
pip install dialogWczytaj model
Użyj biblioteki transformers, aby wczytać potok.
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]
Uruchamianie generowania tekstu
Gdy model Gemma zostanie wczytany i skonfigurowany w obiekcie pipeline, możesz wysyłać do niego prompty. Ten przykładowy kod pokazuje podstawowe żądanie z użyciem parametru 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! 😊**
Korzystanie z biblioteki 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>
Używanie szablonu prompta
Gdy generujesz treści za pomocą bardziej złożonych promptów, użyj szablonu promptu, aby uporządkować żądanie. Szablon promptu umożliwia określanie danych wejściowych z określonych ról, takich jak user lub model, i jest wymaganym formatem do zarządzania czatem wieloetapowym z modelami Gemma. Poniższy przykładowy kod pokazuje, jak utworzyć szablon prompta dla modelu 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.
Rozmowa wieloetapowa
W przypadku promptów wieloetapowych historia rozmowy jest zachowywana jako sekwencja naprzemiennych ról user i model. Ta lista zbiorcza służy jako pamięć modelu, dzięki czemu każde nowe wyjście jest oparte na poprzednim dialogu.
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>
A oto rozmowa wyeksportowana jako tekst.
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>
Instrukcje systemowe
Użyj roli system, aby podać instrukcje na poziomie systemu.
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>
Podsumowanie i dalsze kroki
Z tego przewodnika dowiesz się, jak przeprowadzać podstawowe wnioskowanie na podstawie tekstu za pomocą modelu Gemma 4 przy użyciu biblioteki Hugging Face transformers. Obejmuje to:
- Konfigurowanie środowiska i instalowanie zależności.
- Wczytywanie modelu za pomocą abstrakcji
pipeline. - Uruchamianie podstawowego generowania tekstu.
- Korzystanie z biblioteki
dialogdo śledzenia rozmów. - wdrażanie rozmów wieloetapowych i stosowanie instrukcji systemowych;
Uruchom w Google Colab
Wyświetl źródło na GitHubie