Membangun chatbot dengan Gemma

Lihat di ai.google.dev Berjalan di Google Colab Buka di Vertex AI Lihat sumber di GitHub

Model Bahasa Besar (LLM) seperti Gemma unggul dalam menghasilkan respons yang informatif, sehingga ideal untuk membangun asisten virtual dan chatbot.

Secara konvensional, LLM beroperasi secara stateless, artinya LLM tidak memiliki memori inheren untuk menyimpan percakapan sebelumnya. Setiap perintah atau pertanyaan diproses secara terpisah, mengabaikan interaksi sebelumnya. Namun, aspek penting dari percakapan alami adalah kemampuan untuk mempertahankan konteks dari interaksi sebelumnya. Untuk mengatasi batasan ini dan memungkinkan LLM mempertahankan konteks percakapan, LLM harus diberi informasi yang relevan secara eksplisit seperti histori percakapan (atau bagian terkait) ke dalam setiap perintah baru yang disampaikan kepada LLM.

Tutorial ini menunjukkan cara mengembangkan chatbot menggunakan varian model yang disesuaikan dengan instruksi dari Gemma.

Penyiapan

Penyiapan Gemma

Untuk menyelesaikan tutorial ini, Anda harus menyelesaikan petunjuk penyiapan terlebih dahulu di penyiapan Gemma. Petunjuk penyiapan Gemma menunjukkan kepada Anda cara melakukan hal berikut:

  • Dapatkan akses ke Gemma di kaggle.com.
  • Pilih runtime Colab dengan resource yang memadai untuk dijalankan model Gemma 2B.
  • Membuat dan mengkonfigurasi nama pengguna dan kunci API Kaggle.

Setelah Anda menyelesaikan penyiapan Gemma, lanjutkan ke bagian berikutnya, untuk menetapkan variabel lingkungan untuk lingkungan Colab Anda.

Menetapkan variabel lingkungan

Menetapkan variabel lingkungan untuk KAGGLE_USERNAME dan KAGGLE_KEY.

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')

Menginstal dependensi

Instal Keras dan KerasNLP.

# 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

Pilih backend

Keras adalah API deep learning multi-framework tingkat tinggi yang dirancang untuk kesederhanaan dan kemudahan penggunaan. Keras 3 memungkinkan Anda memilih backend: TensorFlow, JAX, atau PyTorch. Ketiganya akan berfungsi untuk tutorial ini.

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"

Mengimpor paket

Impor Keras dan KerasNLP.

import keras
import keras_nlp

# for reproducibility
keras.utils.set_random_seed(42)

Membuat instance model

KerasNLP menyediakan implementasi dari banyak arsitektur model populer. Dalam tutorial ini, Anda akan membuat instance model menggunakan GemmaCausalLM, model Gemma menyeluruh untuk pemodelan bahasa kausal. Model bahasa kausal memprediksi token berikutnya berdasarkan token sebelumnya.

Buat instance model menggunakan metode from_preset:

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

Fungsi GemmaCausalLM.from_preset() membuat instance model dari bobot dan arsitektur preset. Dalam kode di atas, string "gemma2_instruct_2b_en" menentukan preset model Gemma 2 2B dengan 2 miliar parameter. Model Gemma dengan parameter 7B, 9B, dan 27B juga tersedia. Anda dapat menemukan string kode untuk model Gemma dalam listingan Variasi Model di Kaggle.

Gunakan metode summary untuk mendapatkan info selengkapnya tentang model tersebut:

gemma_lm.summary()

Seperti yang dapat Anda lihat dari ringkasan, model ini memiliki 2,6 miliar parameter yang dapat dilatih.

Menentukan fungsi bantuan pemformatan

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))

Membangun chatbot

Model gemma2_instruct_2b_en yang disesuaikan dengan instruksi Gemma telah disesuaikan untuk memahami token belokan berikut:

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

Tutorial ini menggunakan token tersebut untuk membangun chatbot. Lihat Petunjuk pemformatan dan sistem untuk informasi selengkapnya tentang token kontrol Gemma.

Membuat chat helper untuk mengelola status percakapan

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

Chat dengan model

Mulailah mengobrol dengan model.

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))

🙋‍♂️

Jelaskan dalam beberapa kata, bagaimana cara menghitung semua bilangan prima hingga 1000?
🤖

Saringan Eratosthenes.

Lanjutkan percakapan.

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

🙋‍♂️

Sekarang di Python! Tolong jangan numpy!
🤖

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)

Penjelasan:

  1. Inisialisasi:

    • primes = [True] * (n + 1): Membuat daftar primes nilai boolean, yang awalnya dengan asumsi semua angka adalah bilangan prima.
    • primes[0] = primes[1] = False: Menetapkan 0 dan 1 sebagai non-prima.

  2. Iterasi:

    • for i in range(2, int(n**0.5) + 1):: Melakukan iterasi dari 2 ke akar kuadrat n. Kita hanya perlu memeriksa hingga akar kuadrat karena tiap bilangan gabungan harus memiliki faktor prima kurang dari atau sama dengan akar kuadratnya.
    • if primes[i]:: Jika i ditandai sebagai bilangan prima:
      • for j in range(i * i, n + 1, i):: Menandai semua kelipatan i sebagai non-prima.

  3. Hasil:

    • return [i for i, is_prime in enumerate(primes) if is_prime]: Membuat daftar indeks dengan primes[i] adalah Benar, yang mewakili bilangan prima.

Beri tahu kami jika Anda ingin mendapatkan penjelasan yang lebih mendetail terkait bagian mana pun. 

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

🙋‍♂️

Terima kasih, berhasil. Bisakah kamu menjelaskan kodenya dalam bahasa Prancis?
🤖

Bien sûr ! {i>Voici une explication du code en français<i}:

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)

Penjelasan:

  1. Inisialisasi:

    • 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. Iterasi:

    • 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 mobil tout nombre composer doit avoir un facteur premier inférieur ou égal à sa racine carrée.
    • if primes[i]:: Jika i est considéré comme premier:
      • for j in range(i * i, n + 1, i):: Marquer tous les multiples de i adalah non-premier.

  3. Resultat:

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

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

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

🙋‍♂️

Baik. Sekarang tambahkan penjelasan itu sebagai komentar di dalam kode.
🤖

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)

Penjelasan:

  • Inisialisasi:
    • 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.
  • Iterasi:
    • 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 mobil tout nombre composer doit avoir un facteur premier inférieur ou égal à sa racine carrée.
    • if primes[i]:: Jika i est considéré comme premier:
      • for j in range(i * i, n + 1, i):: Marquer tous les multiples de i adalah non-premier.
  • Resultat:
    • return [i for i, is_prime in enumerate(primes) if is_prime]: Crée une liste des indices o penelitian primes[i] est vrai, représentant les nombres premier.

Uji respons yang dihasilkan dengan menjalankan kode yang dihasilkan:

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]

Gunakan metode get_history untuk melihat bagaimana semua konteks dipertahankan oleh class Chat.

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>

Ringkasan dan bacaan lebih lanjut

Dalam tutorial ini, Anda telah mempelajari cara melakukan chat dengan Gemma 2B Instruction Tuned menggunakan Keras di JAX.

Lihat panduan dan tutorial ini untuk mempelajari lebih lanjut tentang Gemma: