Erste Schritte mit Gemma und LangChain

Auf ai.google.dev ansehen In Google Colab ausführen Quelle auf GitHub ansehen

In dieser Anleitung werden die ersten Schritte mit Gemma und LangChain in Google Cloud oder in Ihrer Colab-Umgebung beschrieben. Gemma ist eine Familie von leichten, hochmodernen offenen Modellen, die auf derselben Forschung und Technologie basieren, die auch für die Gemini-Modelle verwendet werden. LangChain ist ein Framework für das Erstellen und Bereitstellen kontextsensitiver Anwendungen, die auf Language Models basieren.

Gemma in Google Cloud ausführen

Mit dem Paket langchain-google-vertexai lässt sich LangChain in Google Cloud-Modelle einbinden.

Abhängigkeiten installieren

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

Authentifizieren

Sofern Sie nicht Colab Enterprise verwenden, müssen Sie sich authentifizieren.

from google.colab import auth
auth.authenticate_user()

Modell bereitstellen

Vertex AI ist eine Plattform zum Trainieren und Bereitstellen von KI-Modellen und -Anwendungen. Model Garden ist eine ausgewählte Sammlung von Modellen, die Sie in der Google Cloud Console erkunden können.

Zum Bereitstellen von Gemma öffnen Sie das Modell in Model Garden für Vertex AI und führen Sie die folgenden Schritte aus:

  1. Wählen Sie Bereitstellen.
  2. Nehmen Sie die gewünschten Änderungen an den Feldern im Bereitstellungsformular vor oder lassen Sie diese unverändert, wenn Sie mit den Standardeinstellungen einverstanden sind. Notieren Sie sich die folgenden Felder, die Sie später benötigen:
    • Endpunktname (z. B. google_gemma-7b-it-mg-one-click-deploy)
    • Region (z. B. us-west1)
  3. Wählen Sie Bereitstellen aus, um das Modell in Vertex AI bereitzustellen. Die Bereitstellung kann einige Minuten dauern.

Wenn der Endpunkt bereit ist, kopieren Sie seine Projekt-ID, die Endpunkt-ID und den Standort und geben Sie diese als Parameter ein.

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

Modell ausführen

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

Sie können Gemma auch für einen Multi-Turn-Chat verwenden:

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'

Sie können Antworten nachbearbeiten, um Wiederholungen zu vermeiden:

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

Gemma über einen Kaggle-Download ausführen

In diesem Abschnitt erfahren Sie, wie Sie Gemma von Kaggle herunterladen und das Modell dann ausführen.

Um diesen Abschnitt abzuschließen, müssen Sie zunächst die Einrichtungsanleitung unter Gemma-Einrichtung befolgen.

Fahren Sie dann mit dem nächsten Abschnitt fort, in dem Sie Umgebungsvariablen für Ihre Colab-Umgebung festlegen.

Umgebungsvariablen festlegen

Legen Sie Umgebungsvariablen für KAGGLE_USERNAME und KAGGLE_KEY fest.

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

Abhängigkeiten installieren

# 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

Modell ausführen

from langchain_google_vertexai import GemmaLocalKaggle

Sie können das Keras-Back-End angeben (standardmäßig ist es tensorflow, Sie können es aber in jax oder torch ändern).

# @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

Chatmodell ausführen

Wie im Google Cloud-Beispiel oben können Sie eine lokale Bereitstellung von Gemma für Multi-Turn-Chats verwenden. Möglicherweise müssen Sie das Notebook neu starten und den GPU-Arbeitsspeicher bereinigen, um OOM-Fehler zu vermeiden:

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"

Sie können die Antwort nachbearbeiten, wenn Sie Multi-Turn-Anweisungen vermeiden möchten:

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'

Gemma über einen Hugging Face-Download ausführen

Einrichtung

Wie bei Kaggle müssen Sie die Nutzungsbedingungen von Gemma akzeptieren, bevor Sie auf das Modell zugreifen können. Wenn du Zugriff auf Gemma über das Umarmen des Gesichts erhalten möchtest, rufe die Gemma-Modellkarte auf.

Außerdem benötigen Sie ein Nutzerzugriffs-Token mit Leseberechtigungen, das Sie unten eingeben können.

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

Modell ausführen

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

Wie in den obigen Beispielen können Sie eine lokale Bereitstellung von Gemma für einen Multi-Turn-Chat verwenden. Möglicherweise müssen Sie das Notebook neu starten und den GPU-Arbeitsspeicher bereinigen, um OOM-Fehler zu vermeiden:

Chatmodell ausführen

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

Wie in den vorherigen Beispielen können Sie die Antwort nachbearbeiten:

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'

Nächste Schritte