জেমার সাথে একটি চ্যাটবট তৈরি করা

ai.google.dev-এ দেখুন

Google Colab-এ চালান

Vertex AI-তে খুলুন

GitHub-এ উৎস দেখুন

লার্জ ল্যাঙ্গুয়েজ মডেল (LLMs) যেমন Gemma তথ্যপূর্ণ প্রতিক্রিয়া তৈরি করতে পারদর্শী, ভার্চুয়াল সহকারী এবং চ্যাটবট তৈরির জন্য তাদের আদর্শ করে।

প্রচলিতভাবে, এলএলএমগুলি একটি রাষ্ট্রহীন পদ্ধতিতে কাজ করে, যার অর্থ অতীতের কথোপকথনগুলি সংরক্ষণ করার জন্য তাদের অন্তর্নিহিত স্মৃতির অভাব রয়েছে। প্রতিটি প্রম্পট বা প্রশ্ন পূর্বের মিথস্ক্রিয়া উপেক্ষা করে স্বাধীনভাবে প্রক্রিয়া করা হয়। যাইহোক, প্রাকৃতিক কথোপকথনের একটি গুরুত্বপূর্ণ দিক হল পূর্বের মিথস্ক্রিয়া থেকে প্রসঙ্গ ধরে রাখার ক্ষমতা। এই সীমাবদ্ধতা কাটিয়ে ওঠার জন্য এবং কথোপকথনের প্রেক্ষাপট বজায় রাখতে এলএলএমগুলিকে সক্ষম করতে, তাদের অবশ্যই এলএলএম-কে উপস্থাপিত প্রতিটি নতুন প্রম্পটে কথোপকথনের ইতিহাস (বা প্রাসঙ্গিক অংশ) এর মতো প্রাসঙ্গিক তথ্য সরবরাহ করতে হবে।

এই টিউটোরিয়ালটি আপনাকে দেখায় কিভাবে Gemma-এর নির্দেশ-টিউনড মডেল ভেরিয়েন্ট ব্যবহার করে একটি চ্যাটবট তৈরি করতে হয়।

সেটআপ

জেমা সেটআপ

এই টিউটোরিয়ালটি সম্পূর্ণ করতে, আপনাকে প্রথমে Gemma সেটআপে সেটআপ নির্দেশাবলী সম্পূর্ণ করতে হবে। জেমা সেটআপ নির্দেশাবলী আপনাকে দেখায় যে কীভাবে নিম্নলিখিতগুলি করতে হবে:

• kaggle.com-এ Gemma-এ অ্যাক্সেস পান।
• Gemma 2B মডেল চালানোর জন্য পর্যাপ্ত সম্পদ সহ একটি Colab রানটাইম বেছে নিন।
• একটি Kaggle ব্যবহারকারীর নাম এবং API কী তৈরি এবং কনফিগার করুন।

আপনি জেমা সেটআপ সম্পূর্ণ করার পরে, পরবর্তী বিভাগে যান, যেখানে আপনি আপনার Colab পরিবেশের জন্য পরিবেশের ভেরিয়েবল সেট করবেন।

পরিবেশের ভেরিয়েবল সেট করুন

KAGGLE_USERNAME এবং 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')

নির্ভরতা ইনস্টল করুন

Keras এবং 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

একটি ব্যাকএন্ড নির্বাচন করুন

কেরাস হল একটি উচ্চ-স্তরের, মাল্টি-ফ্রেমওয়ার্ক ডিপ লার্নিং API যা সরলতা এবং ব্যবহারের সহজতার জন্য ডিজাইন করা হয়েছে। Keras 3 আপনাকে ব্যাকএন্ড বেছে নিতে দেয়: TensorFlow, JAX, বা PyTorch। তিনটিই এই টিউটোরিয়ালের জন্য কাজ করবে।

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"

প্যাকেজ আমদানি করুন

কেরাস এবং কেরাসএনএলপি আমদানি করুন।

import keras
import keras_nlp

# for reproducibility
keras.utils.set_random_seed(42)

মডেল ইনস্ট্যান্ট

KerasNLP অনেক জনপ্রিয় মডেল আর্কিটেকচারের বাস্তবায়ন প্রদান করে। এই টিউটোরিয়ালে, আপনি GemmaCausalLM ব্যবহার করে মডেলটিকে ইনস্ট্যান্টিয়েট করবেন, কার্যকারণ ভাষার মডেলিংয়ের জন্য এন্ড-টু-এন্ড জেমা মডেল। একটি কার্যকারণ ভাষা মডেল পূর্ববর্তী টোকেনগুলির উপর ভিত্তি করে পরবর্তী টোকেনের পূর্বাভাস দেয়।

from_preset পদ্ধতি ব্যবহার করে মডেলটি ইনস্ট্যান্ট করুন:

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

GemmaCausalLM.from_preset() ফাংশন একটি প্রিসেট আর্কিটেকচার এবং ওজন থেকে মডেলটিকে ইনস্ট্যান্টিয়েট করে। উপরের কোডে, "gemma2_instruct_2b_en" স্ট্রিংটি 2 বিলিয়ন প্যারামিটার সহ Gemma 2 2B মডেলের প্রিসেটটি নির্দিষ্ট করে। 7B, 9B, এবং 27B প্যারামিটার সহ জেমা মডেলগুলিও উপলব্ধ। আপনি Gemma মডেলের জন্য কোড স্ট্রিংগুলি তাদের Kaggle- এ মডেল বৈচিত্র্যের তালিকায় খুঁজে পেতে পারেন।

মডেল সম্পর্কে আরও তথ্য পেতে summary পদ্ধতি ব্যবহার করুন:

gemma_lm.summary()

আপনি সারাংশ থেকে দেখতে পাচ্ছেন, মডেলটিতে 2.6 বিলিয়ন প্রশিক্ষণযোগ্য পরামিতি রয়েছে।

ফরম্যাটিং সহায়ক ফাংশন সংজ্ঞায়িত করুন

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

চ্যাটবট তৈরি করা

নিচের টার্ন টোকেন বোঝার জন্য Gemma instruction-tuned মডেল gemma2_instruct_2b_en সূক্ষ্ম-টিউন করা হয়েছে:

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

এই টিউটোরিয়ালটি চ্যাটবট তৈরি করতে এই টোকেনগুলি ব্যবহার করে। Gemma নিয়ন্ত্রণ টোকেন সম্পর্কে আরও তথ্যের জন্য বিন্যাস এবং সিস্টেম নির্দেশাবলী পড়ুন।

কথোপকথনের অবস্থা পরিচালনা করতে একটি চ্যাট সহায়ক তৈরি করুন৷

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 = 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 পর্যন্ত সমস্ত মৌলিক সংখ্যা গণনা করা যায়?

Eratosthenes এর চালনি।

কথোপকথন চালিয়ে যান।

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

🙋‍♂️

এখন পাইথনে! নোম্পি, প্লিজ!

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)

ব্যাখ্যা:

1. সূচনা:

   • primes = [True] * (n + 1) : বুলিয়ান মানের একটি তালিকা primes তৈরি করে, প্রাথমিকভাবে ধরে নেওয়া হয় যে সমস্ত সংখ্যা মৌলিক।
   • primes[0] = primes[1] = False : 0 এবং 1 কে নন-প্রাইম হিসাবে সেট করে।

2. পুনরাবৃত্তি:

   • for i in range(2, int(n**0.5) + 1): : 2 থেকে n এর বর্গমূলে পুনরাবৃত্তি করে। আমাদের শুধুমাত্র বর্গমূল পর্যন্ত পরীক্ষা করতে হবে কারণ যেকোনো যৌগিক সংখ্যার অবশ্যই তার বর্গমূলের থেকে কম বা সমান একটি মৌলিক গুণনীয়ক থাকতে হবে।
   • if primes[i]: : যদি i প্রাইম হিসাবে চিহ্নিত হয়:
     • for j in range(i * i, n + 1, i): : i এর সমস্ত গুণিতককে নন-প্রাইম হিসেবে চিহ্নিত করে।

3. ফলাফল:

   • return [i for i, is_prime in enumerate(primes) if is_prime] : সূচকের একটি তালিকা তৈরি করে যেখানে মৌলিক সংখ্যাগুলিকে উপস্থাপন করে primes[i] সত্য।

আপনি যদি কোন অংশের আরো বিস্তারিত ব্যাখ্যা চান তাহলে আমাকে জানান!

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

🙋‍♂️

আপনাকে ধন্যবাদ, এটা কাজ করে! আপনি ফরাসি কোড ব্যাখ্যা করতে পারেন?

ভাল! ভয়েস ইউনে এক্সপ্লিকেশন ডু কোড এবং ফ্রাঙ্কাইস:

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)

ব্যাখ্যা:

1. সূচনা:

   • primes = [True] * (n + 1) : Crée une liste primes de valeurs booléennes, সূচনা অনুমান que tous les nombres sont premiers.
   • primes[0] = primes[1] = False : Définit 0 এবং 1 comme non-primiers.

2. পুনরাবৃত্তি:

   • 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 consideré comme premier:
     • for j in range(i * i, n + 1, i): : Marquer tous les Multiples de i comme non-premiers.

3. ফলাফল:

   • 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 ব্যাখ্যা প্লাস détaillée de quelque বেছে নিয়েছেন!

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

🙋‍♂️

দারুণ! এখন কোডে মন্তব্য হিসাবে সেই ব্যাখ্যা যোগ করুন।

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)

ব্যাখ্যা:

• সূচনা:
  • primes = [True] * (n + 1) : Crée une liste primes de valeurs booléennes, সূচনা অনুমান que tous les nombres sont premiers.
  • primes[0] = primes[1] = False : Définit 0 এবং 1 comme non-primiers.
• পুনরাবৃত্তি:
  • 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 consideré comme premier:
    • for j in range(i * i, n + 1, i): : Marquer tous les Multiples de i comme non-premiers.
• ফলাফল:
  • 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.

জেনারেট কোড চালানোর মাধ্যমে উত্পন্ন প্রতিক্রিয়া পরীক্ষা করুন:

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]

Chat ক্লাসের সমস্ত প্রসঙ্গ কীভাবে ধরে রাখা হয়েছে তা দেখতে get_history পদ্ধতি ব্যবহার করুন।

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>

সারাংশ এবং আরও পড়া

এই টিউটোরিয়ালে, আপনি শিখেছেন কিভাবে JAX-এ Keras ব্যবহার করে Gemma 2B নির্দেশনা টিউন করা মডেলের সাথে চ্যাট করতে হয়।

জেমা সম্পর্কে আরও জানতে এই গাইড এবং টিউটোরিয়ালগুলি দেখুন:

• Keras Gemma দিয়ে শুরু করুন ।
• জিপিইউতে জেমা মডেলটি ফিনিটিউন করুন ।
• Vertex AI এর সাথে Gemma ইন্টিগ্রেশন সম্পর্কে জানুন
• Vertex AI এর সাথে জেমা মডেলগুলি কীভাবে ব্যবহার করবেন তা শিখুন।