Programowanie wspomagane AI z użyciem CodeGemma i KerasNLP

Wyświetl na ai.google.dev Uruchom w Google Colab Wyświetl źródło w GitHubie

Omówienie

CodeGemma to odmiana Gemma, która została dostrojona pod kątem zadań związanych z kodowaniem. Ten samouczek jest rozwinięciem krótkiego wprowadzenia do Keras CodeGemma i przedstawia więcej sposobów, w jakie CodeGemma może pomóc Ci w programowaniu.

Konfiguracja

Dostęp do CodeGemma

Aby ukończyć ten samouczek, musisz najpierw wykonać instrukcje konfiguracji opisane na stronie konfiguracji Gemma. Z instrukcji konfiguracji Gemma dowiesz się, jak:

  • Uzyskaj dostęp do Gemmy na kaggle.com.
  • Wybierz środowisko wykonawcze Colab z wystarczającą ilością zasobów do uruchomienia modelu Gemma 7B.
  • Wygeneruj i skonfiguruj nazwę użytkownika i klucz interfejsu API Kaggle.

Po zakończeniu konfiguracji Gemma przejdź do następnej sekcji, w której możesz ustawić zmienne środowiskowe dla środowiska Colab.

Wybierz środowisko wykonawcze

Aby móc uruchamiać modele CodeGemma 7B, musisz mieć płatny abonament Colab Pro, który zapewnia środowisko wykonawcze z GPU A100.

  1. W prawym górnym rogu okna Colab wybierz ▾ (Dodatkowe opcje połączenia).
  2. Kliknij Zmień typ środowiska wykonawczego.
  3. W sekcji Akcelerator sprzętowy wybierz GPU A100.

Skonfiguruj klucz interfejsu API

Aby używać Gemma, musisz podać swoją nazwę użytkownika Kaggle i klucz interfejsu API Kaggle.

Aby wygenerować klucz interfejsu API Kaggle, otwórz kartę Account (Konto) w profilu użytkownika Kaggle i wybierz Create New Token (Utwórz nowy token). Spowoduje to pobranie pliku kaggle.json zawierającego dane logowania do interfejsu API.

W Colab wybierz Obiekty tajne (🔑) w panelu po lewej stronie i dodaj swoją nazwę użytkownika Kaggle i klucz interfejsu API Kaggle. Zapisz swoją nazwę użytkownika pod nazwą KAGGLE_USERNAME, a klucz interfejsu API pod nazwą KAGGLE_KEY.

Ustawianie zmiennych środowiskowych

Ustaw zmienne środowiskowe dla interfejsów KAGGLE_USERNAME i 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')

Instalowanie zależności

pip install -q -U keras-nlp

Wybierz backend

Keras to wysokopoziomowy, wieloramowy interfejs API deep learning, który został zaprojektowany z myślą o łatwości obsługi. Keras 3 pozwala uruchamiać przepływy pracy w jednym z 3 backendów: TensorFlow, JAX lub PyTorch.

W tym samouczku skonfiguruj backend dla języka JAX.

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

Importuj pakiety

Importuj Keras i KerasNLP.

import keras_nlp
import keras

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

CodeGemma 7B – przykłady modeli

W tej sekcji znajdziesz przykłady użycia wytrenowanego modelu 7B CodeGemma do celów związanych z kodowaniem.

Wczytaj model

KerasNLP umożliwia wdrożenie wszystkich 3 wariantów CodeGemma (2B i 7B wytrenowanych (PT) oraz 7B dostrojonych według instrukcji (IT)) przy użyciu GemmaCausalLM – kompleksowego modelu Gemma do modelowania językowego. Przypadkowy model językowy przewiduje kolejny token na podstawie poprzednich tokenów.

W tym przykładzie wczytaj model code_gemma_7b_en za pomocą metody 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()

Metoda from_preset tworzy instancję modelu na podstawie gotowej architektury i wag.

Uzupełnianie kodu za pomocą wielowierszowego FIM

Modele PT CodeGemma są trenowane z wykorzystaniem zadań uzupełniania kodu. W tej sekcji przedstawiamy przykłady, które korzystają z udostępnianej przez CodeGemma funkcji wielowierszowej „wypełnienia pośrodku” (FIM) w celu autouzupełniania kodu w określonej lokalizacji kursora na podstawie kontekstu.

Zacznij od zdefiniowania stałych i funkcji pomocniczej formatowania promptów.

# 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}"

Przykład 1. Wstaw brakujący warunek

Przykładowy kod podany poniżej do wygenerowania sekwencji Fibonacciego nie zadziała poprawnie, jeśli 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)

Zakładając, że kursor znajduje się na początku wiersza 4 (gdzie znajduje się klauzula else), treść przed kursorem i po nim jest:

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

Uruchom prompt.

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

Model wstawia prawidłową kondycję elif dla parametru n=1 w miejscu kursora.

Przykład 2. Kompletny algorytm przemierzania w trybie DFS

Kod autouzupełniania w algorytmie przemierzania drzewa z pierwszeństwem wyszukiwania głębokiego (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|>

Uruchom prompt.

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

Generowanie kodu

Oprócz uzupełniania kodem model CodeGemma 7B PT jest też trenowany na korpusach w języku naturalnym. Możesz użyć tej opcji, aby poprosić model o wygenerowanie kodu.

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 mld przykładów modeli IT

W tej sekcji wykorzystywany jest model dostrojony przez instrukcje CodeGemma 7B do bardziej zaawansowanych zadań związanych z kodowaniem. Model IT CodeGemma 7B jest oparty na modelu PT CodeGemma 7B w ramach nadzorowanego dostrajania kodu oraz uczenia się przez wzmacnianie z wykorzystaniem opinii człowieka. W tej sekcji znajdziesz przykłady jego zastosowania w generowaniu otwartych wiadomości.

Wczytaj model IT

Wczytaj model code_gemma_instruct_7b_en za pomocą metody 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]

Modele IT są trenowane przy użyciu konkretnej narzędzia do formatowania, które dodaje adnotacje do wszystkich przykładów dostrajania instrukcji z dodatkowymi informacjami wskazującymi role i określone etapy rozmowy.

Zacznij od zdefiniowania stałych i funkcji pomocniczej formatowania promptów.

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

Tłumaczenie kodu

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

Sformatuj prompt.

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

Uruchom prompt.

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

Wykrywanie luk w zabezpieczeniach kodu

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

Sformatuj prompt.

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.

Model wykrywa potencjalną lukę w zabezpieczeniach w kodzie i udostępnia zmiany w kodzie, aby zniwelować skutki.

Podsumowanie

W tym samouczku omawialiśmy korzystanie z CodeGemma do różnych zadań związanych z kodowaniem. Aby dowiedzieć się więcej o CodeGemma: