Dai un'occhiata al repository del libro di ricette di Gemma per esempi di generazione e ottimizzazione. Scopri di più

Questa pagina è stata tradotta dall'API Cloud Translation.

Guida rapida di Keras CodeGemma

CodeGemma è una famiglia di modelli aperti leggeri e all'avanguardia basati sulla stessa ricerca e tecnologia utilizzate per creare i modelli Gemini.

I modelli CodeGemma vengono addestrati su oltre 500 miliardi di token principalmente di codice, utilizzando le stesse architetture della famiglia di modelli Gemma. Di conseguenza, i modelli CodeGemma ottengono prestazioni all'avanguardia del codice sia di sviluppo e generazione, mantenendo al contempo solide di comprensione e ragionamento su vasta scala.

CodeGemma ha 3 varianti:

Un modello preaddestrato con codice 7B
Un modello di codice ottimizzato per l'istruzione di 7 miliardi
Un modello 2B, addestrato specificamente per il riempimento del codice e la generazione aperta.

Questa guida illustra l'utilizzo del modello CodeGemma 2B con KerasNLP per un'attività di completamento del codice.

Configurazione

Accedi a CodeGemma

Per completare questo tutorial, devi prima completare le istruzioni di configurazione nella configurazione di Gemma. Le istruzioni di configurazione di Gemma mostrano come fare:

Accedi a Gemma su kaggle.com.
Seleziona un runtime Colab con risorse sufficienti da eseguire il modello Gemma 2B.
Genera e configura un nome utente e una chiave API Kaggle.

Dopo aver completato la configurazione di Gemma, passa alla sezione successiva, in cui imposterai le variabili di ambiente per il tuo ambiente Colab.

Seleziona il runtime

Per completare questo tutorial, dovrai avere un runtime Colab con risorse sufficienti per eseguire il modello CodeGemma 2B. In questo caso, puoi utilizzare una GPU T4:

Nell'angolo in alto a destra della finestra Colab, seleziona ▾ (Opzioni di connessione aggiuntive).
Seleziona Modifica tipo di runtime.
In Acceleratore hardware, seleziona GPU T4.

Configura la chiave API

Per utilizzare Gemma, devi fornire il tuo nome utente Kaggle e una chiave API Kaggle.

Per generare una chiave API Kaggle, vai alla scheda Account del tuo profilo utente Kaggle e seleziona Create New Token (Crea nuovo token). Verrà attivato il download di un file kaggle.json contenente le tue credenziali API.

In Colab, seleziona Secret (webinar) nel riquadro a sinistra e aggiungi il tuo nome utente Kaggle e la tua chiave API Kaggle. Memorizza il tuo nome utente sotto il nome KAGGLE_USERNAME e la chiave API sotto il nome KAGGLE_KEY.

Imposta le variabili di ambiente

Imposta le variabili di ambiente per KAGGLE_USERNAME e 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')

Installa le dipendenze

pip install -q -U keras-nlp

Seleziona un servizio di backend

Keras è un'API di deep learning multi-framework di alto livello progettata per la semplicità e la facilità d'uso. Con Keras 3, puoi eseguire flussi di lavoro su uno dei tre backend: TensorFlow, JAX o PyTorch.

Per questo tutorial, configura il backend per TensorFlow.

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

Importa pacchetti

Importare Keras e KerasNLP.

import keras_nlp
import keras

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

Carica modello

KerasNLP fornisce implementazioni di molte architetture di modelli popolari. In questo tutorial, creerai un modello utilizzando GemmaCausalLM, un modello Gemma end-to-end per la creazione di modelli linguistici causali. Un modello linguistico causale prevede il token successivo in base a quelli precedenti.

Crea il modello utilizzando il metodo 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]

Il metodo from_preset crea un'istanza del modello da un'architettura e pesi predefiniti. Nel codice precedente, la stringa code_gemma_2b_en specifica l'architettura preimpostata: un modello CodeGemma con 2 miliardi di parametri.

Completamento del codice Fillin the middle

In questo esempio viene utilizzata la funzionalità FIM (fill-in-the- middle) di CodeGemma per completare il codice in base al contesto circostante. Ciò è particolarmente utile nelle applicazioni di editor di codice per l'inserimento di codice in cui il cursore di testo si basa sul codice circostante (prima e dopo il cursore).

CodeGemma ti consente di utilizzare 4 token definiti dall'utente: 3 per FIM e un token <|file_separator|> per il supporto del contesto di più file. Utilizzale per definire le costanti.

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

Definisci i token di interruzione per il modello.

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)

Formatta il prompt per il completamento del codice. Ricorda:

Non devono essere presenti spazi vuoti tra i token FIM e il prefisso e il suffisso.
Il token centrale FIM deve essere alla fine per preparare il modello a continuare a compilare
Il prefisso o il suffisso potrebbero essere vuoti, a seconda della posizione attuale del cursore nel file o della quantità di contesto che vuoi fornire al modello.

Utilizza una funzione helper per formattare il prompt.

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

Esegui il prompt. Ti consigliamo di trasmettere in streaming i token di risposta. Interrompi lo streaming quando incontri uno dei token definiti dall'utente o di fine turno/senetence per ottenere il completamento del codice risultante.

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

Il modello fornisce sys come completamento suggerito del codice.

Riepilogo

Questo tutorial ti ha illustrato l'utilizzo di CodeGemma per inserire il codice in base al contesto circostante. Poi, dai un'occhiata al blocco note sulla programmazione assistita dall'IA con CodeGemma e KerasNLP per altri esempi su come utilizzare CodeGemma.

Consulta anche la scheda del modello CodeGemma per le specifiche tecniche dei modelli CodeGemma.