Pemrograman berbantuan AI dengan CodeGemma dan KerasNLP

Lihat di ai.google.dev Berjalan di Google Colab Lihat sumber di GitHub

Ringkasan

CodeGemma adalah varian Gemma yang disesuaikan untuk tugas coding. Tutorial ini dikembangkan berdasarkan panduan memulai Keras CodeGemma dan menunjukkan lebih banyak cara CodeGemma dapat membantu tugas pemrograman Anda.

Penyiapan

Mendapatkan akses ke CodeGemma

Untuk menyelesaikan tutorial ini, Anda harus menyelesaikan petunjuk penyiapan terlebih dahulu di penyiapan Gemma. Petunjuk penyiapan Gemma menunjukkan kepada Anda cara melakukan hal berikut:

  • Dapatkan akses ke Gemma di kaggle.com.
  • Pilih runtime Colab dengan resource yang memadai untuk menjalankan model Gemma 7B.
  • Membuat dan mengkonfigurasi nama pengguna dan kunci API Kaggle.

Setelah Anda menyelesaikan penyiapan Gemma, lanjutkan ke bagian berikutnya, untuk menetapkan variabel lingkungan untuk lingkungan Colab Anda.

Pilih runtime

Untuk menjalankan model CodeGemma 7B, Anda harus memiliki paket Colab Pro berbayar yang menyediakan runtime dengan GPU A100.

  1. Di kanan atas jendela Colab, pilih ▾ (Opsi koneksi tambahan).
  2. Pilih Ubah jenis runtime.
  3. Di bagian Hardware akselerator, pilih A100 GPU.

Mengonfigurasi kunci API

Untuk menggunakan Gemma, Anda harus memberikan nama pengguna Kaggle dan kunci API Kaggle.

Untuk membuat kunci API Kaggle, buka tab Account di profil pengguna Kaggle Anda, lalu pilih Create New Token. Tindakan ini akan memicu download file kaggle.json yang berisi kredensial API Anda.

Di Colab, pilih Secrets (Shopping) di panel kiri dan tambahkan nama pengguna Kaggle dan Kaggle API Anda. Simpan nama pengguna Anda dengan nama KAGGLE_USERNAME dan kunci API Anda dengan nama KAGGLE_KEY.

Menetapkan variabel lingkungan

Menetapkan variabel lingkungan untuk KAGGLE_USERNAME dan 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')

Menginstal dependensi

pip install -q -U keras-nlp

Pilih backend

Keras adalah API deep learning multi-framework tingkat tinggi yang dirancang untuk kesederhanaan dan kemudahan penggunaan. Dengan Keras 3, Anda dapat menjalankan alur kerja di salah satu dari tiga backend: TensorFlow, JAX, atau PyTorch.

Untuk tutorial ini, konfigurasikan backend untuk JAX.

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

Mengimpor paket

Impor Keras dan KerasNLP.

import keras_nlp
import keras

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

Contoh Model CodeGemma 7B

Bagian ini membahas contoh penggunaan model CodeGemma 7B terlatih untuk membantu tugas coding.

Muat model

KerasNLP menyediakan implementasi dari ketiga varian CodeGemma (2B dan 7B terlatih (PT) dan 7B Instruction-tuned (IT)) menggunakan GemmaCausalLM, model Gemma end-to-end untuk pemodelan bahasa kausal. Model bahasa kausal memprediksi token berikutnya berdasarkan token sebelumnya.

Untuk contoh ini, muat model code_gemma_7b_en menggunakan metode 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()

Metode from_preset membuat instance model dari bobot dan arsitektur preset.

Penyelesaian kode dengan FIM Multibaris

Model PT CodeGemma dilatih dalam tugas pengisian kode. Bagian ini menunjukkan contoh yang menggunakan kemampuan multi-baris isian tengah (FIM) CodeGemma untuk mengisi otomatis kode di lokasi kursor yang ditentukan berdasarkan konteks di sekitarnya.

Sebagai langkah pertama, tentukan konstanta dan fungsi bantuan pemformatan perintah.

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

Contoh 1 - Sisipkan kondisi yang tidak ada

Kode contoh di bawah ini untuk menghasilkan urutan Fibonacci tidak akan dijalankan dengan benar jika 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)

Dengan asumsi bahwa kursor berada di awal baris 4 (tempat klausa else berada), konten sebelum dan sesudah kursor adalah:

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

Jalankan perintah.

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 ini menyisipkan susunan elif yang benar untuk n=1 di lokasi kursor.

Contoh 2 - Algoritma traversal DFS lengkap

Kode pelengkapan otomatis untuk algoritme tree traversal penelusuran mendalam (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|>

Jalankan perintah.

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

Pembuatan kode

Selain pengisian kode, model PT CodeGemma 7B juga dilatih menggunakan korpus natural language. Anda dapat menggunakannya untuk memerintahkan model membuat kode.

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 miliar contoh model IT

Bagian ini menggunakan model yang Disesuaikan dengan Instruksi CodeGemma 7B untuk tugas coding tingkat lanjut. Model IT CodeGemma 7B berasal dari model PT CodeGemma 7B melalui supervised fine-tuning pada kode beserta Reinforcement Learning with Human Feedback. Bagian ini membahas contoh penggunaan model ini untuk pembuatan uraian.

Memuat model IT

Muat model code_gemma_instruct_7b_en menggunakan metode 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]

Model IT dilatih dengan pemformat khusus yang memberikan anotasi ke semua contoh penyesuaian instruksi dengan informasi tambahan untuk menunjukkan peran dan menandai perubahan dalam percakapan.

Sebagai langkah pertama, tentukan konstanta dan fungsi bantuan pemformatan perintah.

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

Terjemahan kode

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

Memformat perintah.

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

Jalankan perintah.

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

Deteksi kerentanan kode

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

Memformat perintah.

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 ini mendeteksi potensi kerentanan dalam kode dan memberikan perubahan kode untuk memitigasinya.

Ringkasan

Tutorial ini memandu Anda menggunakan CodeGemma untuk berbagai tugas coding. Untuk mempelajari CodeGemma lebih lanjut: