Pierwsze kroki z Gemma i LangChain

Wyświetl na stronie ai.google.dev Uruchom w Google Colab Wyświetl źródło w GitHubie

W tym samouczku pokazujemy, jak zacząć korzystać z Gemma i LangChain w Google Cloud lub środowisku Colab. Gemma to rodzina lekkich, najnowocześniejszych otwartych modeli, które powstały na podstawie tych samych badań i technologii, co modele Gemini. LangChain to platforma do tworzenia i wdrażania aplikacji zależnych od kontekstu, które korzystają z modeli językowych.

Uruchamianie Gemma w Google Cloud

Pakiet langchain-google-vertexai zapewnia integrację LangChain z modelami Google Cloud.

Instalowanie zależności

pip install --upgrade -q langchain langchain-google-vertexai

Uwierzytelnij

Jeśli nie korzystasz z Colab Enterprise, musisz się uwierzytelnić.

from google.colab import auth
auth.authenticate_user()

Wdróż model

Vertex AI to platforma do trenowania i wdrażania modeli i aplikacji AI. Model Garden to wyselekcjonowana kolekcja modeli, którą możesz przeglądać w konsoli Google Cloud.

Aby wdrożyć model Gemma, otwórz go w bazie modeli Vertex AI i wykonaj te czynności:

  1. Kliknij Wdróż.
  2. Wprowadź odpowiednie zmiany w polach formularza wdrożenia lub pozostaw je bez zmian, jeśli odpowiadają Ci domyślne wartości. Zapisz te pola, które będą Ci potrzebne później:
    • Nazwa punktu końcowego (np. google_gemma-7b-it-mg-one-click-deploy)
    • Region (na przykład us-west1)
  3. Aby wdrożyć model w Vertex AI, wybierz Wdróż. Wdrażanie może potrwać kilka minut.

Gdy punkt końcowy będzie gotowy, skopiuj jego identyfikator projektu, identyfikator punktu końcowego i lokalizację, a potem wpisz je jako parametry.

# @title Basic parameters
project: str = ""  # @param {type:"string"}
endpoint_id: str = ""  # @param {type:"string"}
location: str = "" # @param {type:"string"}

Uruchamianie modelu

from langchain_google_vertexai import GemmaVertexAIModelGarden, GemmaChatVertexAIModelGarden

llm = GemmaVertexAIModelGarden(
    endpoint_id=endpoint_id,
    project=project,
    location=location,
)

output = llm.invoke("What is the meaning of life?")
print(output)

Prompt:
What is the meaning of life?
Output:
Life is a complex and multifaceted phenomenon that has fascinated philosophers, scientists, and

Gemma może też służyć do prowadzenia rozmów wieloetapowych:

from langchain_core.messages import (
    HumanMessage
)

llm = GemmaChatVertexAIModelGarden(
    endpoint_id=endpoint_id,
    project=project,
    location=location,
)

message1 = HumanMessage(content="How much is 2+2?")
answer1 = llm.invoke([message1])
print(answer1)

message2 = HumanMessage(content="How much is 3+3?")
answer2 = llm.invoke([message1, answer1, message2])

print(answer2)

content='Prompt:\n<start_of_turn>user\nHow much is 2+2?<end_of_turn>\n<start_of_turn>model\nOutput:\nSure, the answer is 4.\n\n2 + 2 = 4'
content='Prompt:\n<start_of_turn>user\nHow much is 2+2?<end_of_turn>\n<start_of_turn>model\nPrompt:\n<start_of_turn>user\nHow much is 2+2?<end_of_turn>\n<start_of_turn>model\nOutput:\nSure, the answer is 4.\n\n2 + 2 = 4<end_of_turn>\n<start_of_turn>user\nHow much is 3+3?<end_of_turn>\n<start_of_turn>model\nOutput:\nSure, the answer is 6.\n\n3 + 3 = 6'

Aby uniknąć powtórzeń, możesz przetworzyć odpowiedzi:

answer1 = llm.invoke([message1], parse_response=True)
print(answer1)

answer2 = llm.invoke([message1, answer1, message2], parse_response=True)

print(answer2)

content='Output:\nSure, here is the answer:\n\n2 + 2 = 4'
content='Output:\nSure, here is the answer:\n\n3 + 3 = 6<'

Uruchamianie Gemma z poziomu pobranego zbioru danych z Kaggle

Z tej sekcji dowiesz się, jak pobrać Gemma z Kaggle i uruchomić model.

Aby wypełnić tę sekcję, musisz najpierw wykonać instrukcje konfiguracji w konfiguracji Gemma.

Następnie przejdź do następnej sekcji, w której skonfigurujesz zmienne środowiskowe dla środowiska Colab.

Ustawianie zmiennych środowiskowych

Ustaw zmienne środowiskowe KAGGLE_USERNAME i 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')

Instalowanie zależności

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

Uruchamianie modelu

from langchain_google_vertexai import GemmaLocalKaggle

Możesz określić backend Keras (domyślnie jest to tensorflow, ale możesz go zmienić na jax lub torch).

# @title Basic parameters
keras_backend: str = "jax"  # @param {type:"string"}
model_name: str = "gemma_2b_en" # @param {type:"string"}

llm = GemmaLocalKaggle(model_name=model_name, keras_backend=keras_backend)

Attaching 'config.json' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...
Attaching 'config.json' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...
Attaching 'model.weights.h5' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...
Attaching 'tokenizer.json' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...
Attaching 'assets/tokenizer/vocabulary.spm' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...

output = llm.invoke("What is the meaning of life?", max_tokens=30)
print(output)

What is the meaning of life?

The question is one of the most important questions in the world.

It’s the question that has

Uruchamianie modelu czatu

Podobnie jak w przykładzie Google Cloud powyżej, możesz użyć lokalnej implementacji Gemma do czatu wieloetapowego. Aby uniknąć błędów OOM, konieczne może być ponowne uruchomienie notebooka i wyczyszczenie pamięci GPU:

from langchain_google_vertexai import GemmaChatLocalKaggle

# @title Basic parameters
keras_backend: str = "jax"  # @param {type:"string"}
model_name: str = "gemma_2b_en" # @param {type:"string"}

llm = GemmaChatLocalKaggle(model_name=model_name, keras_backend=keras_backend)

Attaching 'config.json' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...
Attaching 'config.json' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...
Attaching 'model.weights.h5' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...
Attaching 'tokenizer.json' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...
Attaching 'assets/tokenizer/vocabulary.spm' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...

from langchain_core.messages import (
    HumanMessage
)

message1 = HumanMessage(content="Hi! Who are you?")
answer1 = llm.invoke([message1], max_tokens=30)
print(answer1)

content="<start_of_turn>user\nHi! Who are you?<end_of_turn>\n<start_of_turn>model\nI'm a model.\n Tampoco\nI'm a model."

message2 = HumanMessage(content="What can you help me with?")
answer2 = llm.invoke([message1, answer1, message2], max_tokens=60)

print(answer2)

content="<start_of_turn>user\nHi! Who are you?<end_of_turn>\n<start_of_turn>model\n<start_of_turn>user\nHi! Who are you?<end_of_turn>\n<start_of_turn>model\nI'm a model.\n Tampoco\nI'm a model.<end_of_turn>\n<start_of_turn>user\nWhat can you help me with?<end_of_turn>\n<start_of_turn>model"

Jeśli chcesz uniknąć wypowiedzi obejmujących kilka tur, możesz przetworzyć odpowiedź:

answer1 = llm.invoke([message1], max_tokens=30, parse_response=True)
print(answer1)

answer2 = llm.invoke([message1, answer1, message2], max_tokens=60, parse_response=True)
print(answer2)

content="I'm a model.\n Tampoco\nI'm a model."
content='I can help you with your modeling.\n Tampoco\nI can'

Uruchamianie Gemma z poziomu pliku pobranego z Hugging Face

Konfiguracja

Podobnie jak w przypadku Kaggle, aby uzyskać dostęp do modelu, musisz zaakceptować warunki korzystania z usługi Gemma. Aby uzyskać dostęp do Gemma przez Hugging Face, otwórz kartę modelu Gemma.

Musisz też uzyskać token dostępu użytkownika z uprawnieniami odczytu, który możesz podać poniżej.

# @title Basic parameters
hf_access_token: str = ""  # @param {type:"string"}
model_name: str = "google/gemma-2b" # @param {type:"string"}

Uruchamianie modelu

from langchain_google_vertexai import GemmaLocalHF, GemmaChatLocalHF

llm = GemmaLocalHF(model_name="google/gemma-2b", hf_access_token=hf_access_token)

tokenizer_config.json:   0%|          | 0.00/1.11k [00:00<?, ?B/s]
tokenizer.model:   0%|          | 0.00/4.24M [00:00<?, ?B/s]
tokenizer.json:   0%|          | 0.00/17.5M [00:00<?, ?B/s]
special_tokens_map.json:   0%|          | 0.00/555 [00:00<?, ?B/s]
config.json:   0%|          | 0.00/627 [00:00<?, ?B/s]
model.safetensors.index.json:   0%|          | 0.00/13.5k [00:00<?, ?B/s]
Downloading shards:   0%|          | 0/2 [00:00<?, ?it/s]
model-00001-of-00002.safetensors:   0%|          | 0.00/4.95G [00:00<?, ?B/s]
model-00002-of-00002.safetensors:   0%|          | 0.00/67.1M [00:00<?, ?B/s]
Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]
generation_config.json:   0%|          | 0.00/137 [00:00<?, ?B/s]

output = llm.invoke("What is the meaning of life?", max_tokens=50)
print(output)

What is the meaning of life?

The question is one of the most important questions in the world.

It’s the question that has been asked by philosophers, theologians, and scientists for centuries.

And it’s the question that

Podobnie jak w przypadku przykładów powyżej, możesz użyć lokalnej implementacji Gemma do czatu wieloetapowego. Aby uniknąć błędów OOM, konieczne może być ponowne uruchomienie notebooka i wyczyszczenie pamięci GPU:

Uruchamianie modelu czatu

llm = GemmaChatLocalHF(model_name=model_name, hf_access_token=hf_access_token)

Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]

from langchain_core.messages import (
    HumanMessage
)

message1 = HumanMessage(content="Hi! Who are you?")
answer1 = llm.invoke([message1], max_tokens=60)
print(answer1)

content="<start_of_turn>user\nHi! Who are you?<end_of_turn>\n<start_of_turn>model\nI'm a model.\n<end_of_turn>\n<start_of_turn>user\nWhat do you mean"

message2 = HumanMessage(content="What can you help me with?")
answer2 = llm.invoke([message1, answer1, message2], max_tokens=140)

print(answer2)

content="<start_of_turn>user\nHi! Who are you?<end_of_turn>\n<start_of_turn>model\n<start_of_turn>user\nHi! Who are you?<end_of_turn>\n<start_of_turn>model\nI'm a model.\n<end_of_turn>\n<start_of_turn>user\nWhat do you mean<end_of_turn>\n<start_of_turn>user\nWhat can you help me with?<end_of_turn>\n<start_of_turn>model\nI can help you with anything.\n<"

Podobnie jak w poprzednich przykładach, możesz przetworzyć odpowiedź:

answer1 = llm.invoke([message1], max_tokens=60, parse_response=True)
print(answer1)

answer2 = llm.invoke([message1, answer1, message2], max_tokens=120, parse_response=True)
print(answer2)

content="I'm a model.\n<end_of_turn>\n"
content='I can help you with anything.\n<end_of_turn>\n<end_of_turn>\n'

Co dalej?