Consultez le dépôt des livres de recettes Gemma pour des exemples de génération et de réglage ! En savoir plus

Cette page a été traduite par l'API Cloud Translation.

Guide de démarrage rapide de Keras CodeGemma

CodeGemma est une famille de modèles ouverts légers et de pointe, créés à partir des recherches et des technologies utilisées pour créer les modèles Gemini.

Les modèles CodeGemma sont entraînés sur plus de 500 milliards de jetons, principalement du code, à l'aide de les mêmes architectures que la famille de modèles Gemma. Par conséquent, les modèles CodeGemma atteignent des performances de code de pointe dans les deux de génération de texte et de génération de requêtes, tout en maintenant de compréhension et de raisonnement à grande échelle.

CodeGemma a trois variantes:

Un modèle pré-entraîné avec du code de 7 milliards
Un modèle de code réglé avec les instructions 7B
Un modèle 2B, entraîné spécifiquement pour le remplissage de code et la génération ouverte.

Ce guide vous explique comment utiliser le modèle CodeGemma 2B avec KerasNLP pour une tâche de saisie de code.

Configuration

Accéder à CodeGemma

Pour suivre ce tutoriel, vous devez d'abord suivre les instructions de configuration de Gemma. Les instructions de configuration de Gemma vous expliquent comment:

Accédez à Gemma sur kaggle.com.
Sélectionnez un environnement d'exécution Colab avec suffisamment de ressources pour s'exécuter le modèle Gemma 2B.
Générez et configurez un nom d'utilisateur et une clé API Kaggle.

Une fois la configuration de Gemma terminée, passez à la section suivante, dans laquelle vous allez définir des variables d'environnement pour votre environnement Colab.

Sélectionner l'environnement d'exécution

Pour suivre ce tutoriel, vous devez disposer d'un environnement d'exécution Colab disposant de suffisamment de ressources pour exécuter le modèle CodeGemma 2B. Dans ce cas, vous pouvez utiliser un GPU T4:

En haut à droite de la fenêtre Colab, sélectionnez ▾ (Options de connexion supplémentaires).
Sélectionnez Modifier le type d'environnement d'exécution.
Dans Accélérateur matériel, sélectionnez GPU T4.

Configurer votre clé API

Pour utiliser Gemma, vous devez fournir votre nom d'utilisateur Kaggle et une clé d'API Kaggle.

Pour générer une clé API Kaggle, accédez à l'onglet Compte de votre profil utilisateur Kaggle et sélectionnez Créer un jeton. Cette opération déclenchera le téléchargement d'un fichier kaggle.json contenant vos identifiants pour l'API.

Dans Colab, sélectionnez Secrets (pensez) dans le volet de gauche et ajoutez votre nom d'utilisateur Kaggle et votre clé API Kaggle. Stockez votre nom d'utilisateur sous le nom KAGGLE_USERNAME et votre clé API sous le nom KAGGLE_KEY.

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

os.environ["KAGGLE_USERNAME"] = userdata.get('KAGGLE_USERNAME')
os.environ["KAGGLE_KEY"] = userdata.get('KAGGLE_KEY')

Installer des dépendances

pip install -q -U keras-nlp

Sélectionnez un backend

Keras est une API de deep learning multi-framework de haut niveau, conçue pour être simple et facile à utiliser. Avec Keras 3, vous pouvez exécuter des workflows sur l'un des trois backends suivants: TensorFlow, JAX ou PyTorch.

Pour ce tutoriel, configurez le backend pour TensorFlow.

os.environ["KERAS_BACKEND"] = "tensorflow"  # Or "jax" or "torch".

Importer des packages

Importer Keras et KerasNLP

import keras_nlp
import keras

# Run at half precision.
keras.config.set_floatx("bfloat16")

Charger le modèle

KerasNLP fournit des implémentations de nombreuses architectures de modèles courantes. Dans ce tutoriel, vous allez créer un modèle à l'aide de GemmaCausalLM, un modèle Gemma de bout en bout destiné à la modélisation du langage causale. Un modèle de langage causal prédit le jeton suivant en fonction des jetons précédents.

Créez le modèle à l'aide de la méthode from_preset:

gemma_lm = keras_nlp.models.GemmaCausalLM.from_preset("code_gemma_2b_en")
gemma_lm.summary()

Downloading from https://www.kaggle.com/api/v1/models/keras/codegemma/keras/code_gemma_2b_en/1/download/config.json...
100%|██████████| 554/554 [00:00<00:00, 1.41MB/s]
Downloading from https://www.kaggle.com/api/v1/models/keras/codegemma/keras/code_gemma_2b_en/1/download/model.weights.h5...
100%|██████████| 4.67G/4.67G [05:06<00:00, 16.4MB/s]
Downloading from https://www.kaggle.com/api/v1/models/keras/codegemma/keras/code_gemma_2b_en/1/download/tokenizer.json...
100%|██████████| 401/401 [00:00<00:00, 382kB/s]
Downloading from https://www.kaggle.com/api/v1/models/keras/codegemma/keras/code_gemma_2b_en/1/download/assets/tokenizer/vocabulary.spm...
100%|██████████| 4.04M/4.04M [00:01<00:00, 2.41MB/s]

La méthode from_preset instancie le modèle à partir d'une architecture et de pondérations prédéfinies. Dans le code ci-dessus, la chaîne code_gemma_2b_en spécifie l'architecture prédéfinie, un modèle CodeGemma avec deux milliards de paramètres.

Saisie automatique du code dans le milieu

Cet exemple utilise la fonctionnalité FIM de CodeGemma pour compléter le code en fonction du contexte environnant. Cette fonctionnalité est particulièrement utile dans les applications d'éditeur de code, car elle permet d'insérer du code lorsque le curseur de texte est basé sur le code qui l'entoure (avant et après le curseur).

CodeGemma vous permet d'utiliser quatre jetons définis par l'utilisateur : trois pour FIM et un jeton <|file_separator|> pour la prise en charge du contexte multifichier. Utilisez-les pour définir des constantes.

BEFORE_CURSOR = "<|fim_prefix|>"
AFTER_CURSOR = "<|fim_suffix|>"
AT_CURSOR = "<|fim_middle|>"
FILE_SEPARATOR = "<|file_separator|>"

Définissez les jetons d'arrêt du modèle.

END_TOKEN = gemma_lm.preprocessor.tokenizer.end_token

stop_tokens = (BEFORE_CURSOR, AFTER_CURSOR, AT_CURSOR, FILE_SEPARATOR, END_TOKEN)

stop_token_ids = tuple(gemma_lm.preprocessor.tokenizer.token_to_id(x) for x in stop_tokens)

Mettez en forme la requête pour la saisie automatique de code. Remarques :

Il ne doit pas y avoir d'espace entre les jetons FIM et le préfixe et le suffixe
Le jeton FIM central doit se trouver à la fin pour préparer le modèle à continuer à remplir
Le préfixe ou le suffixe peuvent être vides en fonction de l'emplacement actuel du curseur dans le fichier ou de la quantité de contexte que vous souhaitez fournir au modèle.

Utilisez une fonction d'assistance pour mettre en forme la requête.

def format_completion_prompt(before, after):
    return f"{BEFORE_CURSOR}{before}{AFTER_CURSOR}{after}{AT_CURSOR}"

before = "import "
after = """if __name__ == "__main__":\n    sys.exit(0)"""
prompt = format_completion_prompt(before, after)
print(prompt)

<|fim_prefix|>import <|fim_suffix|>if __name__ == "__main__":
    sys.exit(0)<|fim_middle|>

Exécutez la requête. Il est recommandé de diffuser les jetons de réponse. Arrêtez la diffusion lorsque vous rencontrez l'un des jetons définis par l'utilisateur ou de fin de tour/sénence pour obtenir l'achèvement du code.

gemma_lm.generate(prompt, stop_token_ids=stop_token_ids, max_length=128)

'<|fim_prefix|>import <|fim_suffix|>if __name__ == "__main__":\n    sys.exit(0)<|fim_middle|>sys\n<|file_separator|>'

Le modèle fournit sys comme suggestion de saisie automatique de code.

Résumé

Ce tutoriel vous a montré comment utiliser CodeGemma pour remplir du code en fonction du contexte environnant. Ensuite, reportez-vous à la page Programmation assistée par IA avec CodeGemma et le notebook KerasNLP pour découvrir d'autres exemples d'utilisation de CodeGemma.

Reportez-vous également à la fiche de modèle CodeGemma pour connaître les caractéristiques techniques des modèles CodeGemma.