Pierwsze kroki z Gemma i LangChain

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

Z tego samouczka dowiesz się, jak zacząć korzystać z usług Gemma i LangChain w Google Cloud lub środowisku Colab. Gemma to rodzina lekkich, najnowocześniejszych otwartych modeli opracowanych na podstawie tych samych badań i technologii, które służyły do tworzenia modeli Gemini. LangChain to platforma do tworzenia i wdrażania aplikacji rozpoznających kontekst opartych na modelach 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 oraz aplikacji AI. Baza modeli to wyselekcjonowany zbiór modeli, które możesz przeglądać w konsoli Google Cloud.

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

  1. Wybierz Wdróż.
  2. Wprowadź odpowiednie zmiany w polach formularza wdrożenia lub pozostaw je bez zmian, jeśli odpowiadają Ci wartości domyślne. Zanotuj 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. Wybierz Wdróż, aby wdrożyć model w Vertex AI. Wdrożenie zajmie kilka minut.

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

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

Uruchom model

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

Możesz też używać Gemma do czatu wieloetapowego:

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 udzielić odpowiedzi po zakończeniu przetwarzania danych:

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

Uruchom Gemma z pobranego pliku Kaggle

W tej sekcji dowiesz się, jak pobrać Gemma z Kaggle, a następnie uruchomić model.

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

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

Ustawianie zmiennych środowiskowych

Ustaw zmienne środowiskowe dla 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

Uruchom model

from langchain_google_vertexai import GemmaLocalKaggle

Możesz określić backend Keras (domyślnie jest to tensorflow, ale możesz zmienić go 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 powyżej Google Cloud, do czatu wieloetapowego możesz użyć lokalnego wdrożenia Gemma. Aby uniknąć błędów OOM, może być konieczne ponowne uruchomienie notatnika 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ąć instrukcji wieloetapowych, możesz przetworzyć odpowiedź po ich przetworzeniu:

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'

Uruchom Gemma z pobranej twarzy

Konfiguracja

Podobnie jak Kaggle, Hugging Face wymaga zaakceptowania warunków korzystania z usługi Gemma przed uzyskaniem dostępu do modelu. Aby uzyskać dostęp do Gemmy przez przytuloną twarz, otwórz kartę modelu Gemma.

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

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

Uruchom model

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 powyższych przykładach, do czatu wieloetapowego możesz użyć lokalnego wdrożenia Gemma. Aby uniknąć błędów OOM, może być konieczne ponowne uruchomienie notatnika 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<"

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

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