CodeGemma ve KerasNLP ile yapay zeka destekli programlama

ai.google.dev'de görüntüleyin Google Colab'de çalıştır Kaynağı GitHub'da görüntüle

Genel Bakış

CodeGemma, Gemma'nın kodlama görevleri için ince ayarlanmış bir varyantıdır. Bu eğiticide, Keras CodeGemma hızlı başlangıç kılavuzu temel alınmıştır ve CodeGemma'nın programlama görevlerinize yardımcı olabileceği diğer yollar gösterilmektedir.

Kurulum

CodeGemma'ya erişim elde etme

Bu eğiticiyi tamamlamak için önce Gemma kurulumu sayfasındaki kurulum talimatlarını tamamlamanız gerekir. Gemma kurulum talimatları, aşağıdakileri nasıl yapacağınızı gösterir:

  • kaggle.com adresinden Gemma'ya erişin.
  • Gemma 7B modelini çalıştırmak için yeterli kaynağa sahip bir Colab çalışma zamanı seçin.
  • Kaggle kullanıcı adı ve API anahtarı oluşturup yapılandırın.

Gemma kurulumunu tamamladıktan sonra bir sonraki bölüme geçin. Burada, Colab ortamınız için ortam değişkenlerini ayarlayabilirsiniz.

Çalışma zamanını seçin

CodeGemma 7B modellerini çalıştırmak için A100 GPU ile çalışma zamanı sağlayan ücretli bir Colab Pro planınızın olması gerekir.

  1. Colab penceresinin sağ üst kısmından ▾ (Ek bağlantı seçenekleri) öğesini seçin.
  2. Çalışma zamanı türünü değiştir'i seçin.
  3. Donanım hızlandırıcı altında A100 GPU'yu seçin.

API anahtarınızı yapılandırma

Gemma'yı kullanmak için Kaggle kullanıcı adınızı ve bir Kaggle API anahtarı girmeniz gerekir.

Kaggle API anahtarı oluşturmak için Kaggle kullanıcı profilinizin Account sekmesine gidin ve Create New Token'ı (Yeni Jeton Oluştur) seçin. Bu işlem, API kimlik bilgilerinizi içeren bir kaggle.json dosyasının indirilmesini tetikler.

Colab'de sol bölmeden Sırlar'ı (🔑) seçip Kaggle kullanıcı adınızı ve Kaggle API anahtarınızı ekleyin. Kullanıcı adınızı KAGGLE_USERNAME adı, API anahtarınızı ise KAGGLE_KEY adı ile saklayın.

Ortam değişkenlerini ayarlama

KAGGLE_USERNAME ve KAGGLE_KEY için ortam değişkenlerini ayarlayın.

import os
from google.colab import userdata

os.environ["KAGGLE_USERNAME"] = userdata.get('KAGGLE_USERNAME')
os.environ["KAGGLE_KEY"] = userdata.get('KAGGLE_KEY')

Bağımlıları yükleme

pip install -q -U keras-nlp

Arka uç seçin

Keras, basitlik ve kullanım kolaylığı için tasarlanmış üst düzey, çok çerçeveli bir derin öğrenme API'sidir. Keras 3'ü kullanarak iş akışlarını üç arka uçtan birinde çalıştırabilirsiniz: TensorFlow, JAX veya PyTorch.

Bu eğiticide JAX'in arka ucunu yapılandırın.

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

Paketleri içe aktarma

Keras ve KerasNLP'yi içe aktarın.

import keras_nlp
import keras

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

CodeGemma 7B Model Örnekleri

Bu bölümde, kodlama görevlerine yardımcı olması için önceden eğitilmiş 7B CodeGemma modelini kullanma örnekleri ele alınmaktadır.

Modeli yükleme

KerasNLP, nedensel dil modelleme için uçtan uca Gemma modeli olan GemmaCausalLM ile üç CodeGemma varyantının (önceden eğitilmiş 2B ve 7B önceden eğitilmiş (PT) ve 7B talimatına göre ayarlanmış (BT)) uygulanmasını sağlar. Nedensel dil modeli, önceki jetonlara dayanarak bir sonraki jetonu tahmin eder.

Bu örnekte, from_preset yöntemini kullanarak code_gemma_7b_en modelini yükleyin.

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

from_preset yöntemi, modeli önceden ayarlanmış mimariden ve ağırlıklardan örneklendirir.

Çok satırlı FIM ile kod tamamlama

PT CodeGemma modelleri, kod doldurma görevleri konusunda eğitilir. Bu bölümde, çevresindeki bağlama göre belirtilen imleç konumunda kodu otomatik olarak doldurmak için CodeGemma'nın çok satırlı ortayı doldurma (FIM) özelliğini kullanan örnekler gösterilmektedir.

İlk adım olarak sabit değerler ve bir istem biçimlendirme yardımcı işlevi tanımlayın.

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

1. Örnek - Eksik koşulu ekleyin

Fibonacci dizisini oluşturmak için kullanılan aşağıdaki örnek kod, n=1 aşağıdaki durumlarda doğru şekilde yürütülmez:

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)

İmlecin 4. satırın başında (else deyiminin bulunduğu) olduğu varsayıldığında, imleçten önceki ve sonraki içerik şu şekildedir:

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

İstemi çalıştırı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|>

Model, imlecin konumuna n=1 için doğru elif koşulunu ekler.

2. Örnek - Tam DFS geçiş algoritması

Derinlik öncelikli arama (DFS) ağaç geçiş algoritması için otomatik tamamlama kodu.

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

İstemi çalıştırı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|>

Kod oluşturma

CodeGemma 7B PT, kod doldurmanın yanı sıra doğal dil toplulukları üzerinde de eğitilmiştir. Bunu kullanarak modelden kod oluşturmasını isteyebilirsiniz.

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
}

7B BT modeli örnekleri

Bu bölümde, daha gelişmiş kodlama görevleri için CodeGemma 7B Talimat Ayarlı model kullanılmaktadır. CodeGemma 7B BT modeli, İnsan Geri Bildirimi ile Pekiştirmeli Öğrenme ile birlikte kod üzerinde denetimli ince ayar aracılığıyla CodeGemma 7B PT modelinden türetilmiştir. Bu bölümde, açık uçlu oluşturma için bu modeli kullanma örnekleri ele alınmaktadır.

BT modelini yükleme

from_preset yöntemini kullanarak code_gemma_instruct_7b_en modelini yükleyin.

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]

BT modelleri, belirli bir biçimlendiriciyle eğitilir. Bu biçim, tüm talimat ayarlama örneklerine rolleri ve bir görüşmedeki dönüşleri belirleyebilmek için ekstra bilgiler ekler.

İlk adım olarak sabit değerler ve bir istem biçimlendirme yardımcı işlevi tanımlayın.

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

Kod çevirisi

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

İstemi biçimlendirin.

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

İstemi çalıştırı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`.

Kod güvenlik açığı algılama

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

İstemi biçimlendirin.

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, koddaki olası bir güvenlik açığını tespit eder ve bu güvenlik açığının etkilerini azaltmak için kod değişiklikleri sunar.

Özet

Bu eğitim, çeşitli kodlama görevleri için CodeGemma'yı kullanma konusunda size yol gösterecektir. CodeGemma hakkında daha fazla bilgi edinmek için: