 Auf ai.google.dev ansehen
|
 In Google Colab ausführen
|
 Quelle auf GitHub ansehen
|
CodeGemma ist eine Familie von leichten, hochmodernen offenen Modellen, die auf derselben Forschung und Technologie basieren, die auch zur Erstellung der Gemini-Modelle verwendet wurden.
CodeGemma-Modelle werden mit mehr als 500 Milliarden Tokens trainiert, wobei hauptsächlich Code verwendet wird. Architekturen wie in der Gemma-Modellfamilie. Infolgedessen erzielen CodeGemma-Modelle bei der Vervollständigung und Generieren von Aufgaben, während Sie gleichzeitig Verständnis- und Logikfähigkeiten im großen Maßstab zu verstehen.
CodeGemma hat drei Varianten:
- Ein vortrainiertes Modell mit 7 Mrd. Code
- Ein auf 7 Milliarden abgestimmtes Codemodell
- Ein 2-Milliarden-Modell, das speziell für die Code-Füllung und offene Generierung trainiert wurde.
Dieser Leitfaden führt Sie durch die Verwendung des CodeGemma 2B-Modells mit KerasNLP für eine Codevervollständigungsaufgabe.
Einrichtung
Zugriff auf CodeGemma erhalten
Um diese Anleitung abzuschließen, müssen Sie zuerst die Schritte unter Gemma-Einrichtung ausführen. In der Anleitung zur Einrichtung von Gemma erfahren Sie, wie Sie Folgendes tun können:
- Auf kaggle.com erhalten Sie Zugriff auf Gemma.
- Colab-Laufzeit mit ausreichenden Ressourcen zum Ausführen auswählen das Modell Gemma 2B.
- Generieren und konfigurieren Sie einen Kaggle-Nutzernamen und einen API-Schlüssel.
Nachdem Sie die Gemma-Einrichtung abgeschlossen haben, fahren Sie mit dem nächsten Abschnitt fort. Dort legen Sie Umgebungsvariablen für Ihre Colab-Umgebung fest.
Laufzeit auswählen
Für diese Anleitung benötigen Sie eine Colab-Laufzeit mit ausreichenden Ressourcen, um das CodeGemma 2B-Modell auszuführen. In diesem Fall können Sie eine T4-GPU verwenden:
- Wählen Sie rechts oben im Colab-Fenster ▾ aus (Zusätzliche Verbindungsoptionen).
- Wählen Sie Laufzeittyp ändern aus.
- Wählen Sie unter Hardwarebeschleuniger die Option T4-GPU aus.
API-Schlüssel konfigurieren
Um Gemma zu verwenden, müssen Sie Ihren Kaggle-Nutzernamen und einen Kaggle API-Schlüssel angeben.
Um einen Kaggle-API-Schlüssel zu generieren, gehen Sie in Ihrem Kaggle-Nutzerprofil zum Tab Account (Konto) und wählen Sie Create New Token (Neues Token erstellen) aus. Dadurch wird der Download einer kaggle.json-Datei mit Ihren API-Anmeldedaten ausgelöst.
Wählen Sie in Colab im linken Bereich Secrets (🚀) aus und fügen Sie Ihren Kaggle-Nutzernamen und Ihren Kaggle API-Schlüssel hinzu. Speichern Sie Ihren Nutzernamen unter dem Namen KAGGLE_USERNAME und Ihren API-Schlüssel unter dem Namen KAGGLE_KEY.
Umgebungsvariablen festlegen
Legen Sie Umgebungsvariablen für KAGGLE_USERNAME und KAGGLE_KEY fest.
import os
from google.colab import userdata
os.environ["KAGGLE_USERNAME"] = userdata.get('KAGGLE_USERNAME')
os.environ["KAGGLE_KEY"] = userdata.get('KAGGLE_KEY')
Abhängigkeiten installieren
pip install -q -U keras-nlp
Backend auswählen
Keras ist eine Deep-Learning-API mit mehreren Frameworks, die auf einfache und nutzerfreundliche Weise entwickelt wurde. Mit Keras 3 können Sie Workflows auf einem von drei Back-Ends ausführen: TensorFlow, JAX oder PyTorch.
Konfigurieren Sie für diese Anleitung das Back-End für TensorFlow.
os.environ["KERAS_BACKEND"] = "tensorflow" # Or "jax" or "torch".
Pakete importieren
Importieren Sie Keras und KerasNLP.
import keras_nlp
import keras
# Run at half precision.
keras.config.set_floatx("bfloat16")
Modell laden
KerasNLP bietet Implementierungen vieler beliebter Modellarchitekturen. In dieser Anleitung erstellen Sie ein Modell mit GemmaCausalLM, einem End-to-End-Gemma-Modell für kausale Language Models. Ein kausales Sprachmodell sagt das nächste Token basierend auf vorherigen Tokens voraus.
Erstellen Sie das Modell mit der Methode 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]
Die Methode from_preset instanziiert das Modell aus einer voreingestellten Architektur und Gewichtungen. Im obigen Code gibt der String code_gemma_2b_en die voreingestellte Architektur an – ein CodeGemma-Modell mit 2 Milliarden Parametern.
Codevervollständigung durch Ausfüllen der Mitte
In diesem Beispiel wird die Fill-in-the-Middle-Funktion (FIM) von CodeGemma verwendet, um Code basierend auf dem umgebenden Kontext zu vervollständigen. Dies ist besonders in Code-Editor-Anwendungen nützlich, um Code dort einzufügen, wo sich der Textcursor auf dem Code um ihn herum befindet (vor und nach dem Cursor).
Mit CodeGemma kannst du 4 benutzerdefinierte Tokens verwenden: 3 für FIM und ein <|file_separator|>-Token für die Kontextunterstützung mehrerer Dateien. Verwenden Sie diese, um Konstanten zu definieren.
BEFORE_CURSOR = "<|fim_prefix|>"
AFTER_CURSOR = "<|fim_suffix|>"
AT_CURSOR = "<|fim_middle|>"
FILE_SEPARATOR = "<|file_separator|>"
Definieren Sie die Haltestellentokens für das Modell.
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)
Formatieren Sie den Prompt zur Codevervollständigung. Hinweis:
- Zwischen den FIM-Tokens und dem Präfix und Suffix dürfen keine Leerzeichen stehen
- Das mittlere FIM-Token sollte sich am Ende befinden, um das Modell auf das weitere Ausfüllen vorzubereiten
- Das Präfix oder Suffix kann leer sein, je nachdem, wo sich der Cursor derzeit in der Datei befindet oder wie viel Kontext Sie dem Modell bereitstellen möchten
Verwenden Sie eine Hilfsfunktion, um den Prompt zu formatieren.
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|>
Führen Sie die Aufforderung aus. Es wird empfohlen, Antworttokens zu streamen. Beenden Sie das Streaming nach der Erkennung eines benutzerdefinierten Tokens oder Tokens für das Ende des Runden-/Satzes, um die resultierende Codevervollständigung zu erhalten.
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|>'
Das Modell stellt sys als vorgeschlagene Codevervollständigung bereit.
Zusammenfassung
In dieser Anleitung wurde Ihnen gezeigt, wie Sie CodeGemma verwenden, um Code basierend auf dem umgebenden Kontext auszufüllen. Weitere Beispiele zur Verwendung von CodeGemma finden Sie im Notebook „AI Assisted Programming with CodeGemma and KerasNLP“.
Die technischen Spezifikationen der CodeGemma-Modelle finden Sie auf der CodeGemma-Modellkarte.