Gemma ile chatbot oluşturma

ai.google.dev'de görüntüleyin Google Colab'de çalıştır Vertex AI'da aç Kaynağı GitHub'da görüntüle

Gemma gibi büyük dil modelleri (LLM) bilgilendirici yanıtlar oluşturma konusunda uzmanlaştığından bu modelleri sanal asistanlar ve chatbot'lar oluşturmak için idealdir.

Geleneksel olarak LLM'ler durum bilgisiz bir şekilde çalışırlar. Diğer bir deyişle, geçmiş görüşmeleri depolamak için gerekli olan yerleşik bir hafızaya sahip değildirler. Her istem veya soru, önceki etkileşimler dikkate alınmadan bağımsız olarak işlenir. Ancak doğal konuşmanın önemli yanlarından biri, önceki etkileşimlerdeki bağlamı koruyabilme becerisidir. Bu sınırlamanın üstesinden gelmek ve LLM'lerin sohbet bağlamını muhafaza etmesini sağlamak için LLM'ye sunulan her yeni istemde sohbet geçmişi (veya ilgili bölümler) gibi alakalı bilgilerin açıkça sağlanması gerekir.

Bu eğiticide, Gemma'nın talimatlar ayarlı model varyantını kullanarak nasıl chatbot geliştireceğiniz gösterilmektedir.

Kurulum

Gemma kurulumu

Bu eğiticiyi tamamlamak için önce Gemma kurulumu bölümündeki kurulum talimatlarını tamamlamanız gerekir. Gemma kurulum talimatları, aşağıdakileri nasıl yapacağınızı gösterir:

  • kaggle.com adresinden Gemma'ya erişin.
  • Çalıştırmak için yeterli kaynağa sahip bir Colab çalışma zamanı seçin Gemma 2B modeli.
  • Kaggle kullanıcı adı ve API anahtarı oluşturup yapılandırın.

Gemma kurulumunu tamamladıktan sonra bir sonraki bölüme geçin. Burada, Colab ortamınız için ortam değişkenlerini ayarlayabilirsiniz.

Ortam değişkenlerini ayarlama

KAGGLE_USERNAME ve KAGGLE_KEY için ortam değişkenlerini ayarlayın.

import os
from google.colab import userdata

# Note: `userdata.get` is a Colab API. If you're not using Colab, set the env
# vars as appropriate for your system.
os.environ["KAGGLE_USERNAME"] = userdata.get('KAGGLE_USERNAME')
os.environ["KAGGLE_KEY"] = userdata.get('KAGGLE_KEY')

Bağımlıları yükleme

Keras ve KerasNLP'yi yükleyin.

# Install Keras 3 last. See https://keras.io/getting_started/ for more details.
pip install -q tensorflow-cpu
pip install -q -U keras-nlp tensorflow-hub
pip install -q -U "keras>=3"
pip install -q -U tensorflow-text

Arka uç seçin

Keras, basitlik ve kullanım kolaylığı için tasarlanmış üst düzey, çok çerçeveli bir derin öğrenme API'sidir. Keras 3 arka ucu seçmenizi sağlar: TensorFlow, JAX veya PyTorch. Bu eğitimde üçü de kullanılabilir.

import os

# Select JAX as the backend
os.environ["KERAS_BACKEND"] = "jax"

# Pre-allocate 100% of TPU memory to minimize memory fragmentation
os.environ["XLA_PYTHON_CLIENT_MEM_FRACTION"] = "1.0"

Paketleri içe aktarma

Keras ve KerasNLP'yi içe aktarın.

import keras
import keras_nlp

# for reproducibility
keras.utils.set_random_seed(42)

Modeli örneklendirme

KerasNLP, birçok popüler model mimarisinin uygulanmasını sağlar. Bu eğiticide, nedensel dil modelleme için uçtan uca Gemma modeli olan GemmaCausalLM'i kullanarak modeli örneklendireceksiniz. Nedensel dil modeli, önceki jetonlara dayanarak bir sonraki jetonu tahmin eder.

from_preset yöntemini kullanarak modeli örneklendirin:

gemma_lm = keras_nlp.models.GemmaCausalLM.from_preset("gemma2_instruct_2b_en")

GemmaCausalLM.from_preset() işlevi, modeli önceden ayarlanmış mimariden ve ağırlıklardan örneklendirir. Yukarıdaki kodda "gemma2_instruct_2b_en" dizesi, 2 milyar parametreyle Gemma 2 2B modelini içeren hazır ayarı belirtir. 7B, 9B ve 27B parametrelerine sahip Gemma modelleri de mevcuttur. Gemma modellerinin kod dizelerini, Kaggle'daki Model Varyasyonu girişlerinde bulabilirsiniz.

Model hakkında daha fazla bilgi edinmek için summary yöntemini kullanın:

gemma_lm.summary()

Özetten görebileceğiniz gibi, modelin 2,6 milyar eğitilebilir parametresi vardır.

Biçimlendirme yardımcı işlevlerini tanımlama

from IPython.display import Markdown
import textwrap

def display_chat(prompt, text):
  formatted_prompt = "<font size='+1' color='brown'>🙋‍♂️<blockquote>" + prompt + "</blockquote></font>"
  text = text.replace('•', '  *')
  text = textwrap.indent(text, '> ', predicate=lambda _: True)
  formatted_text = "<font size='+1' color='teal'>🤖\n\n" + text + "\n</font>"
  return Markdown(formatted_prompt+formatted_text)

def to_markdown(text):
  text = text.replace('•', '  *')
  return Markdown(textwrap.indent(text, '> ', predicate=lambda _: True))

Chatbot'u derleme

Gemma talimat ayarı yapılmış gemma2_instruct_2b_en modelinde, aşağıdaki dönüş jetonlarını anlayacak şekilde ince ayar yapıldı:

<start_of_turn>user\n  ... <end_of_turn>\n
<start_of_turn>model\n ... <end_of_turn>\n

Bu eğitim, chatbot'u derlemek için bu jetonları kullanır. Gemma kontrol jetonları hakkında daha fazla bilgi için Biçimlendirme ve sistem talimatları bölümüne bakın.

Sohbet durumunu yönetmek için bir sohbet yardımcısı oluşturun

class ChatState():
  """
  Manages the conversation history for a turn-based chatbot
  Follows the turn-based conversation guidelines for the Gemma family of models
  documented at https://ai.google.dev/gemma/docs/formatting
  """

  __START_TURN_USER__ = "<start_of_turn>user\n"
  __START_TURN_MODEL__ = "<start_of_turn>model\n"
  __END_TURN__ = "<end_of_turn>\n"

  def __init__(self, model, system=""):
    """
    Initializes the chat state.

    Args:
        model: The language model to use for generating responses.
        system: (Optional) System instructions or bot description.
    """
    self.model = model
    self.system = system
    self.history = []

  def add_to_history_as_user(self, message):
      """
      Adds a user message to the history with start/end turn markers.
      """
      self.history.append(self.__START_TURN_USER__ + message + self.__END_TURN__)

  def add_to_history_as_model(self, message):
      """
      Adds a model response to the history with start/end turn markers.
      """
      self.history.append(self.__START_TURN_MODEL__ + message)

  def get_history(self):
      """
      Returns the entire chat history as a single string.
      """
      return "".join([*self.history])

  def get_full_prompt(self):
    """
    Builds the prompt for the language model, including history and system description.
    """
    prompt = self.get_history() + self.__START_TURN_MODEL__
    if len(self.system)>0:
      prompt = self.system + "\n" + prompt
    return prompt

  def send_message(self, message):
    """
    Handles sending a user message and getting a model response.

    Args:
        message: The user's message.

    Returns:
        The model's response.
    """
    self.add_to_history_as_user(message)
    prompt = self.get_full_prompt()
    response = self.model.generate(prompt, max_length=2048)
    result = response.replace(prompt, "")  # Extract only the new response
    self.add_to_history_as_model(result)
    return result

Modelle sohbet edin

Modelle sohbet etmeye başlayın.

chat = ChatState(gemma_lm)
message = "Tell me, in a few words,  how to compute all prime numbers up to 1000?"
display_chat(message, chat.send_message(message))

🙋‍♂️

1000'e kadar olan tüm asal sayıların nasıl hesaplanacağını birkaç kelimeyle anlatır mısın?
🤖

Eratosthanes'in kümesi.

Görüşmeyi sürdürün.

message = "Now in Python! No numpy, please!"
display_chat(message, chat.send_message(message))

🙋‍♂️

Şimdi Python'da! Hayır lütfen!
🤖

def sieve_of_eratosthenes(n):
  """Returns a list of prime numbers up to n."""
  primes = [True] * (n + 1)
  primes[0] = primes[1] = False
  for i in range(2, int(n**0.5) + 1):
    if primes[i]:
      for j in range(i * i, n + 1, i):
        primes[j] = False
  return [i for i, is_prime in enumerate(primes) if is_prime]

primes = sieve_of_eratosthenes(1000)
print(primes)

Açıklama:

  1. Başlatma:

    • primes = [True] * (n + 1): Başlangıçta tüm sayıların asal olduğu varsayılarak boole değerlerinin yer aldığı bir primes listesi oluşturur.
    • primes[0] = primes[1] = False: 0 ve 1'i asal olmayan olarak ayarlar.

  2. Yineleme:

    • for i in range(2, int(n**0.5) + 1):: 2'den n değerinin kareköküne kadar iterasyon yapar. Her bileşik sayının asal çarpanının karekökten küçük veya ona eşit olması gerektiğinden, yalnızca karekökü kontrol etmemiz gerekir.
    • if primes[i]:: i asal olarak işaretlendiyse:
      • for j in range(i * i, n + 1, i):: i sayısının tüm katlarını asal olmayan olarak işaretler.

  3. Sonuç:

    • return [i for i, is_prime in enumerate(primes) if is_prime]: primes[i] değerinin Doğru olduğu ve asal sayıları temsil eden bir dizin listesi oluşturur.

Herhangi bir bölümle ilgili daha ayrıntılı açıklama yapmak isterseniz lütfen bize bildirin. 

message = "Thank you, it works! Can you explain the code in French?"
display_chat(message, chat.send_message(message))

🙋‍♂️

Teşekkürler, işe yarıyor! Kodu Fransızca olarak açıklayabilir misiniz?
🤖

Bien sür ! Voici une explication du code en français :

def sieve_of_eratosthenes(n):
  """Retourne une liste de nombres premiers jusqu'à n."""
  primes = [True] * (n + 1)
  primes[0] = primes[1] = False
  for i in range(2, int(n**0.5) + 1):
    if primes[i]:
      for j in range(i * i, n + 1, i):
        primes[j] = False
  return [i for i, is_prime in enumerate(primes) if is_prime]

primes = sieve_of_eratosthenes(1000)
print(primes)

Örnek:

  1. Başlatma:

    • primes = [True] * (n + 1): Crée une list primes de valeurs booléennes, initialement supposant que tous les nombres sont premiers.
    • primes[0] = primes[1] = False: Definit 0 ve 1 comme non-premiers.

  2. Yineleme:

    • for i in range(2, int(n**0.5) + 1):: n tarihinde itère de 2 jusqu'à la racine Carrée de Hayır.
    • if primes[i]:: Si i est considéré comme premier:
      • for j in range(i * i, n + 1, i):: Marquer tous les multiples de i comme non-premiers.

  3. Sonuç:

    • return [i for i, is_prime in enumerate(primes) if is_prime]: Crée une liste des indices où primes[i] est vrai, représentant les nombres premiers.

N'hésitez pas à me requester si vous avez besoin d'une explication plus détaillée de quelque choose! 

message = "Great! Now add those explanations as comments in the code."
display_chat(message, chat.send_message(message))

🙋‍♂️

Mükemmel. Şimdi bu açıklamaları koda yorum olarak ekleyin.
🤖

def sieve_of_eratosthenes(n):
  """Retourne une liste de nombres premiers jusqu'à n."""
  # Initialise une liste de boolean avec True pour tous les nombres de 0 à n
  primes = [True] * (n + 1)
  # Définit 0 et 1 comme non-premiers
  primes[0] = primes[1] = False
  # Itère de 2 à la racine carrée de n
  for i in range(2, int(n**0.5) + 1):
    # Si i est considéré comme premier
    if primes[i]:
      # Itère sur tous les multiples de i
      for j in range(i * i, n + 1, i):
        # Définit les multiples de i comme non-premiers
        primes[j] = False
  # Retourne la liste des indices des nombres premiers
  return [i for i, is_prime in enumerate(primes) if is_prime]

primes = sieve_of_eratosthenes(1000)
print(primes)

Örnek:

  • Başlatma:
    • primes = [True] * (n + 1): Crée une list primes de valeurs booléennes, initialement supposant que tous les nombres sont premiers.
    • primes[0] = primes[1] = False: Definit 0 ve 1 comme non-premiers.
  • Yineleme:
    • for i in range(2, int(n**0.5) + 1):: n tarihinde itère de 2 jusqu'à la racine Carrée de Hayır.
    • if primes[i]:: Si i est considéré comme premier:
      • for j in range(i * i, n + 1, i):: Marquer tous les multiples de i comme non-premiers.
  • Sonuç:
    • return [i for i, is_prime in enumerate(primes) if is_prime]: Crée une liste des indices où primes[i] est vrai, représentant les nombres premiers.

Oluşturulan kodu çalıştırarak oluşturulan yanıtı test edin:

def sieve_of_eratosthenes(n):
  """Retourne une liste de nombres premiers jusqu'à n."""
  # Initialise une liste de boolean avec True pour tous les nombres de 0 à n
  primes = [True] * (n + 1)
  # Définit 0 et 1 comme non-premiers
  primes[0] = primes[1] = False
  # Itère de 2 à la racine carrée de n
  for i in range(2, int(n**0.5) + 1):
    # Si i est considéré comme premier
    if primes[i]:
      # Itère sur tous les multiples de i
      for j in range(i * i, n + 1, i):
        # Définit les multiples de i comme non-premiers
        primes[j] = False
  # Retourne la liste des indices des nombres premiers
  return [i for i, is_prime in enumerate(primes) if is_prime]

primes = sieve_of_eratosthenes(1000)
print(primes)

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]

Tüm bağlamın Chat sınıfı tarafından nasıl saklandığını görmek için get_history yöntemini kullanın.

print(chat.get_history())

<start_of_turn>user
Tell me, in a few words,  how to compute all prime numbers up to 1000?<end_of_turn>
<start_of_turn>model
**Sieve of Eratosthenes.** 
<end_of_turn><start_of_turn>user
Now in Python! No numpy, please!<end_of_turn>
<start_of_turn>model

```python
def sieve_of_eratosthenes(n):
  """Returns a list of prime numbers up to n."""
  primes = [True] * (n + 1)
  primes[0] = primes[1] = False
  for i in range(2, int(n**0.5) + 1):
    if primes[i]:
      for j in range(i * i, n + 1, i):
        primes[j] = False
  return [i for i, is_prime in enumerate(primes) if is_prime]

primes = sieve_of_eratosthenes(1000)
print(primes)
```

**Explanation:**

1. **Initialization:**
   - `primes = [True] * (n + 1)`: Creates a list `primes` of boolean values, initially assuming all numbers are prime.
   - `primes[0] = primes[1] = False`: Sets 0 and 1 as non-prime.

2. **Iteration:**
   - `for i in range(2, int(n**0.5) + 1):`: Iterates from 2 to the square root of `n`. We only need to check up to the square root because any composite number must have a prime factor less than or equal to its square root.
   - `if primes[i]:`: If `i` is marked as prime:
     - `for j in range(i * i, n + 1, i):`: Marks all multiples of `i` as non-prime.

3. **Result:**
   - `return [i for i, is_prime in enumerate(primes) if is_prime]`: Creates a list of indices where `primes[i]` is True, representing the prime numbers.


Let me know if you'd like a more detailed explanation of any part! 
<end_of_turn><start_of_turn>user
Thank you, it works! Can you explain the code in French?<end_of_turn>
<start_of_turn>model
Bien sûr ! Voici une explication du code en français :

```python
def sieve_of_eratosthenes(n):
  """Retourne une liste de nombres premiers jusqu'à n."""
  primes = [True] * (n + 1)
  primes[0] = primes[1] = False
  for i in range(2, int(n**0.5) + 1):
    if primes[i]:
      for j in range(i * i, n + 1, i):
        primes[j] = False
  return [i for i, is_prime in enumerate(primes) if is_prime]

primes = sieve_of_eratosthenes(1000)
print(primes)
```

**Explication:**

1. **Initialisation:**
   - `primes = [True] * (n + 1)`: Crée une liste `primes` de valeurs booléennes, initialement supposant que tous les nombres sont premiers.
   - `primes[0] = primes[1] = False`: Définit 0 et 1 comme non-premiers.

2. **Itération:**
   - `for i in range(2, int(n**0.5) + 1):`: Itère de 2 jusqu'à la racine carrée de `n`. Nous ne devons vérifier que jusqu'à la racine carrée car tout nombre composite doit avoir un facteur premier inférieur ou égal à sa racine carrée.
   - `if primes[i]:`: Si `i` est considéré comme premier:
     - `for j in range(i * i, n + 1, i):`:  Marquer tous les multiples de `i` comme non-premiers.

3. **Resultat:**
   - `return [i for i, is_prime in enumerate(primes) if is_prime]`: Crée une liste des indices où `primes[i]` est vrai, représentant les nombres premiers.


N'hésitez pas à me demander si vous avez besoin d'une explication plus détaillée de quelque chose! 
<end_of_turn><start_of_turn>user
Great! Now add those explanations as comments in the code.<end_of_turn>
<start_of_turn>model

```python
def sieve_of_eratosthenes(n):
  """Retourne une liste de nombres premiers jusqu'à n."""
  # Initialise une liste de boolean avec True pour tous les nombres de 0 à n
  primes = [True] * (n + 1)
  # Définit 0 et 1 comme non-premiers
  primes[0] = primes[1] = False
  # Itère de 2 à la racine carrée de n
  for i in range(2, int(n**0.5) + 1):
    # Si i est considéré comme premier
    if primes[i]:
      # Itère sur tous les multiples de i
      for j in range(i * i, n + 1, i):
        # Définit les multiples de i comme non-premiers
        primes[j] = False
  # Retourne la liste des indices des nombres premiers
  return [i for i, is_prime in enumerate(primes) if is_prime]

primes = sieve_of_eratosthenes(1000)
print(primes)
```

**Explication:**

* **Initialisation:**
    * `primes = [True] * (n + 1)`:  Crée une liste `primes` de valeurs booléennes, initialement supposant que tous les nombres sont premiers.
    * `primes[0] = primes[1] = False`: Définit 0 et 1 comme non-premiers.
* **Itération:**
    * `for i in range(2, int(n**0.5) + 1):`: Itère de 2 jusqu'à la racine carrée de `n`. Nous ne devons vérifier que jusqu'à la racine carrée car tout nombre composite doit avoir un facteur premier inférieur ou égal à sa racine carrée.
    * `if primes[i]:`: Si `i` est considéré comme premier:
        * `for j in range(i * i, n + 1, i):`:  Marquer tous les multiples de `i` comme non-premiers.
* **Resultat:**
    * `return [i for i, is_prime in enumerate(primes) if is_prime]`: Crée une liste des indices où `primes[i]` est vrai, représentant les nombres premiers. 



<end_of_turn>

Özet ve ek okuma

Bu eğiticide, JAX'ta Keras'ı kullanarak Gemma 2B Talimatı hassaslaştırılmış modelle nasıl sohbet edeceğinizi öğrendiniz.

Gemma hakkında daha fazla bilgi edinmek için şu kılavuzlara ve eğiticilere göz atın: