 Ver en ai.google.dev
|
 Ejecutar en Google Colab
|
 Ver el código fuente en GitHub
|
Descripción general
CodeGemma es una variante de Gemma que está afinada para tareas de programación. Este instructivo se basa en la guía de inicio rápido de Keras CodeGemma y te muestra más formas en las que CodeGemma puede ayudarte con tus tareas de programación.
Configuración
Accede a CodeGemma
Para completar este instructivo, primero deberás completar las instrucciones de configuración de Gemma. Las instrucciones de configuración de Gemma te muestran cómo hacer lo siguiente:
- Obtén acceso a Gemma en kaggle.com.
- Selecciona un entorno de ejecución de Colab con recursos suficientes para ejecutar el modelo Gemma 7B.
- Generar y configurar un nombre de usuario Kaggle y una clave de API.
Después de completar la configuración de Gemma, continúa con la siguiente sección, en la que establecerás variables de entorno para tu entorno de Colab.
Selecciona el entorno de ejecución
Para ejecutar los modelos de CodeGemma 7B, necesitarás un plan de Colab Pro pago que proporcione un tiempo de ejecución con una GPU A100.
- En la esquina superior derecha de la ventana de Colab, selecciona ▾ (Opciones de conexión adicionales).
- Selecciona Cambiar tipo de entorno de ejecución.
- En Acelerador de hardware, selecciona GPU A100.
Cómo configurar tu clave de API
Para usar Gemma, debes proporcionar tu nombre de usuario y una clave de API de Kaggle.
Para generar una clave de API de Kaggle, dirígete a la pestaña Cuenta de tu perfil de usuario de Kaggle y selecciona Crear token nuevo. Esto activará la descarga de un archivo kaggle.json que contiene tus credenciales de API.
En Colab, selecciona Secrets (Compose) en el panel izquierdo y agrega tu nombre de usuario de Kaggle y tu clave de API de Kaggle. Almacena tu nombre de usuario con el nombre KAGGLE_USERNAME y tu clave de API con el nombre KAGGLE_KEY.
Configure las variables de entorno
Configura variables de entorno para KAGGLE_USERNAME y 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')
Instala dependencias
pip install -q -U keras-nlp
Seleccionar un backend
Keras es una API de aprendizaje profundo de varios marcos de alto nivel diseñada para ofrecer simplicidad y facilidad de uso. Con Keras 3, puedes ejecutar flujos de trabajo en uno de los tres backends: TensorFlow, JAX o PyTorch.
En este instructivo, configura el backend para JAX.
os.environ["KERAS_BACKEND"] = "jax" # Or "tensorflow" or "torch".
Importa paquetes
Importar Keras y KerasNLP.
import keras_nlp
import keras
# Run at half precision.
keras.config.set_floatx("bfloat16")
Ejemplos del modelo 7B de CodeGemma
Esta sección abarca ejemplos del uso del modelo 7B CodeGemma previamente entrenado para ayudar con las tareas de programación.
Carga el modelo
KerasNLP proporciona implementaciones de las tres variantes de CodeGemma (2B y 7B previamente entrenadas [PT] y 7B ajustadas por instrucciones [IT]) con GemmaCausalLM, un modelo de Gemma de extremo a extremo para el modelado de lenguaje causal. Un modelo de lenguaje causal predice el siguiente token basándose en los anteriores.
Para este ejemplo, carga el modelo code_gemma_7b_en con el método from_preset.
gemma_lm_7b = keras_nlp.models.GemmaCausalLM.from_preset("code_gemma_7b_en")
Downloading from https://www.kaggle.com/api/v1/models/keras/codegemma/keras/code_gemma_7b_en/1/download/config.json... 100%|██████████| 556/556 [00:00<00:00, 790kB/s] Downloading from https://www.kaggle.com/api/v1/models/keras/codegemma/keras/code_gemma_7b_en/1/download/model.weights.h5... 100%|██████████| 15.9G/15.9G [02:39<00:00, 107MB/s] Downloading from https://www.kaggle.com/api/v1/models/keras/codegemma/keras/code_gemma_7b_en/1/download/tokenizer.json... 100%|██████████| 401/401 [00:00<00:00, 587kB/s] Downloading from https://www.kaggle.com/api/v1/models/keras/codegemma/keras/code_gemma_7b_en/1/download/assets/tokenizer/vocabulary.spm... 100%|██████████| 4.04M/4.04M [00:00<00:00, 16.4MB/s]
gemma_lm_7b.summary()
El método from_preset crea una instancia del modelo a partir de una arquitectura y pesos preestablecidos.
Completa el código con una FIM de varias líneas
Los modelos de PT CodeGemma se entrenan con tareas de relleno de código. Esta sección muestra ejemplos que usan la capacidad de relleno en el medio de varias líneas (FIM) de CodeGemma para autocompletar código en la ubicación del cursor especificada según el contexto circundante.
Como primer paso, define las constantes y una función auxiliar para el formato de instrucciones.
# Formatting control tokens to specify cursor location
BEFORE_CURSOR = "<|fim_prefix|>"
AFTER_CURSOR = "<|fim_suffix|>"
AT_CURSOR = "<|fim_middle|>"
FILE_SEPARATOR = "<|file_separator|>"
# Define model stop tokens
END_TOKEN = gemma_lm_7b.preprocessor.tokenizer.end_token
stop_tokens = (BEFORE_CURSOR, AFTER_CURSOR, AT_CURSOR, FILE_SEPARATOR, END_TOKEN)
stop_token_ids = tuple(gemma_lm_7b.preprocessor.tokenizer.token_to_id(x) for x in stop_tokens)
def format_completion_prompt(before, after):
return f"{BEFORE_CURSOR}{before}{AFTER_CURSOR}{after}{AT_CURSOR}"
Ejemplo 1: Inserta la condición faltante
El siguiente código de ejemplo para generar la secuencia de Fibonacci no se ejecutará correctamente si n=1:
def fibonacci(n: int) -> int:
if n == 0:
return 0
# The cursor is right before the e in the following line
else:
return fibonacci(n - 1) + fibonacci(n - 2)
Suponiendo que el cursor se encuentra al principio de la línea 4 (donde se encuentra la cláusula else), el contenido antes y después del cursor es el siguiente:
before = """def fibonacci(n: int) -> int:\n if n == 0:\n return 0\n""" # Mind the spaces!
after = """\n else:\n return fibonacci(n - 1) + fibonacci(n-2)\n"""
prompt = format_completion_prompt(before, after)
print(prompt)
<|fim_prefix|>def fibonacci(n: int) -> int:
if n == 0:
return 0
<|fim_suffix|>
else:
return fibonacci(n - 1) + fibonacci(n-2)
<|fim_middle|>
Ejecuta la instrucción.
print(gemma_lm_7b.generate(prompt, stop_token_ids=stop_token_ids, max_length=128))
<|fim_prefix|>def fibonacci(n: int) -> int:
if n == 0:
return 0
<|fim_suffix|>
else:
return fibonacci(n - 1) + fibonacci(n-2)
<|fim_middle|>elif n == 1:
return 1<|file_separator|>
El modelo inserta la condición elif correcta para n=1 en la ubicación del cursor.
Ejemplo 2: Algoritmo de recorrido de DFS completo
Código de autocompletar para un algoritmo de recorrido de árbol de búsqueda en la profundidad (DFS).
before = """void dfs(node* root) {
if (root->left) {
dfs(root->left);
}"""
after = """\nprintf("%d", root->value);
}"""
prompt = format_completion_prompt(before, after)
print(prompt)
<|fim_prefix|>void dfs(node* root) {
if (root->left) {
dfs(root->left);
}<|fim_suffix|>
printf("%d", root->value);
}<|fim_middle|>
Ejecuta la instrucción.
print(gemma_lm_7b.generate(prompt, stop_token_ids=stop_token_ids, max_length=128))
<|fim_prefix|>void dfs(node* root) {
if (root->left) {
dfs(root->left);
}<|fim_suffix|>
printf("%d", root->value);
}<|fim_middle|>
if (root->right) {
dfs(root->right);
}<|file_separator|>
Generación de código
Además del relleno de código, el modelo CodeGemma 7B PT también se entrena con corpus de lenguaje natural. Puedes usarlo para indicarle al modelo que genere código.
generation_prompt= """Write a rust function to identify non-prime numbers.
Examples:
>>> is_not_prime(2)
False
>>> is_not_prime(10)
True
pub fn is_not_prime(n: i32) -> bool {"""
print(gemma_lm_7b.generate(generation_prompt, max_length=500))
Write a rust function to identify non-prime numbers.
Examples:
>>> is_not_prime(2)
False
>>> is_not_prime(10)
True
pub fn is_not_prime(n: i32) -> bool {
if n <= 1 {
return true;
}
for i in 2..n {
if n % i == 0 {
return true;
}
}
false
}
7,000 millones de ejemplos de modelos de TI
En esta sección, se usa el modelo ajustado por instrucciones CodeGemma 7B para tareas de programación más avanzadas. El modelo de TI de CodeGemma 7B se deriva del modelo CodeGemma 7B PT a través del ajuste supervisado del código junto con el aprendizaje por refuerzo con comentarios humanos. En esta sección, se cubren ejemplos de uso de este modelo para una generación abierta.
Carga el modelo de TI
Carga el modelo code_gemma_instruct_7b_en con el método from_preset.
gemma_lm_7b_it = keras_nlp.models.GemmaCausalLM.from_preset("code_gemma_instruct_7b_en")
gemma_lm_7b_it.summary()
Downloading from https://www.kaggle.com/api/v1/models/keras/codegemma/keras/code_gemma_instruct_7b_en/1/download/config.json... 100%|██████████| 556/556 [00:00<00:00, 754kB/s] Downloading from https://www.kaggle.com/api/v1/models/keras/codegemma/keras/code_gemma_instruct_7b_en/1/download/model.weights.h5... 100%|██████████| 15.9G/15.9G [03:18<00:00, 86.2MB/s] Downloading from https://www.kaggle.com/api/v1/models/keras/codegemma/keras/code_gemma_instruct_7b_en/1/download/tokenizer.json... 100%|██████████| 401/401 [00:00<00:00, 593kB/s] Downloading from https://www.kaggle.com/api/v1/models/keras/codegemma/keras/code_gemma_instruct_7b_en/1/download/assets/tokenizer/vocabulary.spm... 100%|██████████| 4.04M/4.04M [00:00<00:00, 16.8MB/s]
Los modelos de TI se entrenan con un formateador específico que anota todos los ejemplos de ajuste de instrucciones con información adicional para indicar los roles y delimitar los turnos en una conversación.
Como primer paso, define las constantes y una función auxiliar para el formato de instrucciones.
# Formatting control tokens for instruction tuning
START_OF_TURN_USER = "<start_of_turn>user"
END_OF_TURN = "<end_of_turn>"
START_OF_TURN_MODEL = "<start_of_turn>model"
# Formatting helper function
def format_instruction_prompt(context):
return f"{START_OF_TURN_USER}\n{context}{END_OF_TURN}\n{START_OF_TURN_MODEL}\n"
Traducción del código
context1 = """
You are an experienced C and Python programmer. Convert the following Python code into C.
```python
def factorial(n):
result = 1
for i in range(2, n + 1):
result *= i
return result
```\n"""
Dale formato a la instrucción.
prompt1 = format_instruction_prompt(context1)
print(prompt1)
<start_of_turn>user
You are an experienced C and Python programmer. Convert the following Python code into C.
```python
def factorial(n):
result = 1
for i in range(2, n + 1):
result *= i
return result
```
<end_of_turn>
<start_of_turn>model
Ejecuta la instrucción.
print(gemma_lm_7b_it.generate(prompt1, max_length=500))
<start_of_turn>user
You are an experienced C and Python programmer. Convert the following Python code into C.
```python
def factorial(n):
result = 1
for i in range(2, n + 1):
result *= i
return result
```
<end_of_turn>
<start_of_turn>model
Here is the C code equivalent of the Python code:
```c
int factorial(int n) {
int result = 1;
for (int i = 2; i <= n; i++) {
result *= i;
}
return result;
}
```
Here is a breakdown of the changes:
* The function is declared with the `int` return type, as in Python.
* The `for` loop is converted to a `for` loop with an `int` variable `i` initialized to 2 and incremented by 1 in each iteration.
* The `range` function is replaced with a simple loop that iterates from 2 to `n` (inclusive).
* The `result *= i` statement is used to multiply `result` by `i` in each iteration.
* The `return` statement is used to return the final value of `result`.
Detección de vulnerabilidades de código
context2 = """
You are an experienced C++ programmer hunting for vulnerable code. Is the following code vulnerable? Explain your reasoning.
```cpp
int i;
unsigned int numWidgets;
Widget **WidgetList;
numWidgets = GetUntrustedSizeValue();
if ((numWidgets == 0) || (numWidgets > MAX_NUM_WIDGETS)) {
ExitError("Incorrect number of widgets requested!");
}
WidgetList = (Widget **) malloc(numWidgets * sizeof(Widget *));
printf("WidgetList ptr=%p\n", WidgetList);
for (i = 0; i < numWidgets; i++) {
WidgetList[i] = InitializeWidget();
}
WidgetList[numWidgets] = NULL;
showWidgets(WidgetList);
```\n"""
Dale formato a la instrucción.
prompt2 = format_instruction_prompt(context2)
print(prompt2)
<start_of_turn>user
You are an experienced C++ programmer hunting for vulnerable code. Is the following code vulnerable? Explain your reasoning.
```cpp
int i;
unsigned int numWidgets;
Widget **WidgetList;
numWidgets = GetUntrustedSizeValue();
if ((numWidgets == 0) || (numWidgets > MAX_NUM_WIDGETS)) {
ExitError("Incorrect number of widgets requested!");
}
WidgetList = (Widget **) malloc(numWidgets * sizeof(Widget *));
printf("WidgetList ptr=%p
", WidgetList);
for (i = 0; i < numWidgets; i++) {
WidgetList[i] = InitializeWidget();
}
WidgetList[numWidgets] = NULL;
showWidgets(WidgetList);
```
<end_of_turn>
<start_of_turn>model
print(gemma_lm_7b_it.generate(prompt2, max_length=1000))
<start_of_turn>user
You are an experienced C++ programmer hunting for vulnerable code. Is the following code vulnerable? Explain your reasoning.
```cpp
int i;
unsigned int numWidgets;
Widget **WidgetList;
numWidgets = GetUntrustedSizeValue();
if ((numWidgets == 0) || (numWidgets > MAX_NUM_WIDGETS)) {
ExitError("Incorrect number of widgets requested!");
}
WidgetList = (Widget **) malloc(numWidgets * sizeof(Widget *));
printf("WidgetList ptr=%p
", WidgetList);
for (i = 0; i < numWidgets; i++) {
WidgetList[i] = InitializeWidget();
}
WidgetList[numWidgets] = NULL;
showWidgets(WidgetList);
```
<end_of_turn>
<start_of_turn>model
Yes, the code is vulnerable to a memory access error.
**Reasoning:**
* The code allocates memory for `WidgetList` using `malloc` based on the value of `numWidgets`.
* However, the loop iterates from `0` to `numWidgets`, which is one element beyond the allocated memory.
* This means that accessing `WidgetList[numWidgets]` will result in a memory access error, as it is outside the bounds of the allocated memory.
**Example of Memory Access Error:**
When `numWidgets` is 5, the code allocates memory for `WidgetList` as follows:
```
WidgetList = (Widget **) malloc(5 * sizeof(Widget *));
```
The loop iterates from 0 to 4, accessing the following elements:
* `WidgetList[0]`
* `WidgetList[1]`
* `WidgetList[2]`
* `WidgetList[3]`
* `WidgetList[4]`
However, the code then attempts to access `WidgetList[5]`, which is outside the allocated memory range. This will result in a memory access error.
**Solution:**
To resolve this vulnerability, the loop should be modified to iterate from 0 to `numWidgets - 1`:
```cpp
for (i = 0; i < numWidgets - 1; i++) {
WidgetList[i] = InitializeWidget();
}
```
This ensures that the loop does not access elements beyond the allocated memory range.
El modelo detecta una posible vulnerabilidad en el código y proporciona cambios de código para mitigarla.
Resumen
Este tutorial te sirvió para aprender a usar CodeGemma en una variedad de tareas de programación. Para obtener más información sobre CodeGemma:
- Consulta la tarjeta de modelo de CodeGemma para conocer las especificaciones técnicas de los modelos de CodeGemma.
- Obtén más información para usar CodeGemma en Vertex AI aquí.
- Consulta la guía de inicio rápido de Keras CodeGemma.