Voir sur ai.google.dev | Exécuter dans Google Colab | Afficher la source sur GitHub |
Ce tutoriel vous explique comment utiliser Gemma et LangChain dans Google Cloud ou dans votre environnement Colab. Gemma est une famille de modèles ouverts légers et de pointe conçus à partir des mêmes recherches et technologies que celles utilisées pour créer les modèles Gemini. LangChain est un framework permettant de créer et de déployer des applications contextuelles reposant sur des modèles de langage.
Exécuter Gemma dans Google Cloud
Le package langchain-google-vertexai
permet l'intégration de LangChain aux modèles Google Cloud.
Installer des dépendances
pip install --upgrade -q langchain langchain-google-vertexai
Authentifier
Vous devez vous authentifier, sauf si vous utilisez Colab Enterprise.
from google.colab import auth
auth.authenticate_user()
Déployer le modèle
Vertex AI est une plate-forme permettant d'entraîner et de déployer des modèles et des applications d'IA. Model Garden est une collection de modèles soigneusement sélectionnés que vous pouvez explorer dans la console Google Cloud.
Pour déployer Gemma, ouvrez le modèle dans Model Garden pour Vertex AI, puis procédez comme suit:
- Sélectionnez Deploy (Déployer).
- Apportez toutes les modifications souhaitées aux champs du formulaire de déploiement ou laissez-les tels quels, si vous acceptez les valeurs par défaut. Notez les champs suivants, car vous en aurez besoin ultérieurement :
- Nom du point de terminaison (par exemple,
google_gemma-7b-it-mg-one-click-deploy
) - Région (par exemple,
us-west1
)
- Nom du point de terminaison (par exemple,
- Sélectionnez Déployer pour déployer le modèle sur Vertex AI. Le déploiement prendra quelques minutes.
Lorsque le point de terminaison est prêt, copiez son ID de projet, son ID et son emplacement, puis saisissez-les en tant que paramètres.
# @title Basic parameters
project: str = "" # @param {type:"string"}
endpoint_id: str = "" # @param {type:"string"}
location: str = "" # @param {type:"string"}
Exécuter le modèle
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
Vous pouvez également utiliser Gemma pour un chat multitours:
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'
Vous pouvez post-traiter les réponses pour éviter les répétitions:
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<'
Exécuter Gemma depuis un téléchargement Kaggle
Cette section vous montre comment télécharger Gemma depuis Kaggle et exécuter le modèle.
Pour terminer cette section, vous devez d'abord suivre les instructions de configuration de l'article Configuration de Gemma.
Passez ensuite à la section suivante, dans laquelle vous allez définir les variables d'environnement de votre environnement Colab.
Définir des variables d'environnement
Définissez les variables d'environnement pour KAGGLE_USERNAME
et 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')
Installer des dépendances
# 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
Exécuter le modèle
from langchain_google_vertexai import GemmaLocalKaggle
Vous pouvez spécifier le backend Keras (par défaut, il s'agit de tensorflow
, mais vous pouvez le remplacer par jax
ou 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
Exécuter le modèle de chat
Comme dans l'exemple Google Cloud ci-dessus, vous pouvez utiliser un déploiement local de Gemma pour le chat multitours. Vous devrez peut-être redémarrer le notebook et nettoyer la mémoire de votre GPU afin d'éviter les erreurs OOM:
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"
Vous pouvez post-traiter la réponse si vous souhaitez éviter les instructions multitours:
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'
Exécuter Gemma depuis le téléchargement d'un Hugging Face
Préparation
Comme Kaggle, Hugging Face nécessite que vous acceptiez les conditions générales de Gemma avant d'accéder au modèle. Pour accéder à Gemma via Hugging Face, consultez la fiche du modèle Gemma.
Vous devez également obtenir un jeton d'accès utilisateur avec des autorisations de lecture, que vous pouvez saisir ci-dessous.
# @title Basic parameters
hf_access_token: str = "" # @param {type:"string"}
model_name: str = "google/gemma-2b" # @param {type:"string"}
Exécuter le modèle
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
Comme dans les exemples ci-dessus, vous pouvez utiliser un déploiement local de Gemma pour le chat multitours. Vous devrez peut-être redémarrer le notebook et nettoyer la mémoire de votre GPU afin d'éviter les erreurs OOM:
Exécuter le modèle de chat
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<"
Comme dans les exemples précédents, vous pouvez post-traiter la réponse:
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'
Étapes suivantes
- Découvrez comment affiner un modèle Gemma.
- Découvrez comment effectuer l'affinage distribué et l'inférence sur un modèle Gemma.
- Découvrez comment utiliser des modèles Gemma avec Vertex AI.