CodeGemma और KerasNLP में एआई से चलने वाली प्रोग्रामिंग

ai.google.dev पर देखें Google Colab में चलाएं GitHub पर सोर्स देखें

खास जानकारी

CodeGemma, Gemma का एक वैरिएंट है. इसे कोडिंग के कामों के लिए बेहतर बनाया जाता है. यह ट्यूटोरियल Keras CodeGemma क्विकस्टार्ट पर आधारित है. साथ ही, इसमें आपको ऐसे कई तरीके बताए गए हैं जिनकी मदद से CodeGemma, प्रोग्रामिंग के टास्क में आपकी मदद कर सकता है.

सेटअप

CodeGemma का ऐक्सेस पाएं

इस ट्यूटोरियल को पूरा करने के लिए, आपको सबसे पहले Gemma सेटअप में दिए गए सेटअप के निर्देशों को पूरा करना होगा. Gemma के सेटअप से जुड़े निर्देशों में बताया गया है कि ये काम कैसे किए जा सकते हैं:

  • kaggle.com पर Gemma का ऐक्सेस पाएं.
  • Gemma 7B मॉडल को चलाने के लिए, ज़रूरत के मुताबिक संसाधनों वाला Colab रनटाइम चुनें.
  • Kaggle उपयोगकर्ता नाम और एपीआई पासकोड को जनरेट और कॉन्फ़िगर करें.

Gemma का सेटअप पूरा करने के बाद, अगले सेक्शन पर जाएं. यहां अपने Colab एनवायरमेंट के लिए, एनवायरमेंट वैरिएबल सेट किए जा सकते हैं.

रनटाइम चुनें

CodeGemma 7B मॉडल का इस्तेमाल करने के लिए, आपके पास पैसे चुकाकर लिया गया Colab Pro प्लान होना चाहिए. इसमें, A100 जीपीयू के साथ रनटाइम की सुविधा मिलती है.

  1. Colab विंडो के ऊपर दाईं ओर, 🛍 (कनेक्शन के अन्य विकल्प) चुनें.
  2. रनटाइम का टाइप बदलें को चुनें.
  3. Hardware Accelerator में जाकर, A100 जीपीयू चुनें.

अपनी एपीआई कुंजी कॉन्फ़िगर करें

Gemma का इस्तेमाल करने के लिए, आपको अपना Kaggle उपयोगकर्ता नाम और Kaggle API पासकोड देना होगा.

Kaggle API पासकोड को जनरेट करने के लिए, अपनी Kaggle उपयोगकर्ता प्रोफ़ाइल के खाता टैब पर जाएं और नया टोकन बनाएं चुनें. इससे kaggle.json में, आपके एपीआई क्रेडेंशियल वाली फ़ाइल डाउनलोड होगी.

Colab में, बाएं पैनल में Secrets (कंसोल) चुनें और अपना Kaggle उपयोगकर्ता नाम और Kaggle API पासकोड जोड़ें. अपना उपयोगकर्ता नाम KAGGLE_USERNAME नाम से और एपीआई पासकोड KAGGLE_KEY नाम से सेव करें.

एनवायरमेंट वैरिएबल सेट करना

KAGGLE_USERNAME और 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')

डिपेंडेंसी इंस्टॉल करें

pip install -q -U keras-nlp

बैकएंड चुनें

Keras एक हाई-लेवल, मल्टी-फ़्रेमवर्क डीप लर्निंग एपीआई है. इसे सरलता और इस्तेमाल में आसानी के लिए डिज़ाइन किया गया है. Keras 3 का इस्तेमाल करके, वर्कफ़्लो को इन तीन बैकएंड पर चलाया जा सकता है: TensorFlow, JAX या PyTorch.

इस ट्यूटोरियल के लिए, JAX के बैकएंड को कॉन्फ़िगर करें.

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

पैकेज इंपोर्ट करें

Keras और KerasNLP इंपोर्ट करें.

import keras_nlp
import keras

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

CodeGemma 7B मॉडल के उदाहरण

इस सेक्शन में, कोडिंग से जुड़े कामों में मदद पाने के लिए, पहले से ट्रेन किए गए 7B CodeGemma मॉडल के इस्तेमाल के उदाहरण दिए गए हैं.

मॉडल लोड करें

KerasNLP, GemmaCausalLM का इस्तेमाल करके CodeGemma के तीनों वैरिएंट (2B और 7B पहले से ट्रेन किए गए (पीटी) और 7B के लिए निर्देश से ट्यून किया गया (आईटी)) को लागू करने की सुविधा देता है. यह कैज़ुअल लैंग्वेज मॉडलिंग के लिए, एंड-टू-एंड जेमा मॉडल है. कॉज़ल लैंग्वेज मॉडल, पिछले टोकन के आधार पर अगले टोकन का अनुमान लगाता है.

इस उदाहरण के लिए, from_preset तरीके का इस्तेमाल करके code_gemma_7b_en मॉडल लोड करें.

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 तरीका, मॉडल को प्रीसेट आर्किटेक्चर और वेट से इंस्टैंशिएट करता है.

मल्टी-लाइन एफ़आईएम की मदद से कोड पूरा करना

PT CodeGemma मॉडल को कोड डालने के टास्क के लिए ट्रेनिंग दी जाती है. इस सेक्शन में ऐसे उदाहरण दिखाए गए हैं जिनमें CodeGemma की मल्टी-लाइन फ़िल-इन द मिडल (एफ़आईएम) की सुविधा का इस्तेमाल किया जाता है. इसकी मदद से, आस-पास के कॉन्टेक्स्ट के आधार पर, कर्सर की तय जगह पर कोड को ऑटोमैटिक तरीके से भरा जाता है.

सबसे पहले, कॉन्सटेंट और प्रॉम्प्ट फ़ॉर्मैटिंग हेल्पर फ़ंक्शन तय करें.

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

पहला उदाहरण - छूटी हुई शर्त जोड़ें

फिबोनाशी क्रम जनरेट करने के लिए नीचे दिया गया उदाहरण कोड सही तरीके से काम नहीं करेगा अगर 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)

यह मानते हुए कि कर्सर, लाइन 4 की शुरुआत में है (जहां else क्लॉज़ है), तो कर्सर के पहले और बाद का कॉन्टेंट इस तरह होता है:

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

प्रॉम्प्ट चलाएं.

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

यह मॉडल कर्सर की जगह पर n=1 के लिए, सही elif कॉन्डिक्शन जोड़ता है.

उदाहरण 2 - पूरा डीएफ़एस ट्रैवर्सल एल्गोरिदम

डेप्थ-फ़र्स्ट सर्च (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|>

प्रॉम्प्ट चलाएं.

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

कोड जनरेशन

कोड डालने के अलावा, CodeGemma 7B PT को आम भाषा के संग्रह के हिसाब से भी ट्रेनिंग दी गई है. इसका इस्तेमाल करके, मॉडल को कोड जनरेट करने का प्रॉम्प्ट भेजा जा सकता है.

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 आईटी मॉडल के उदाहरण

यह सेक्शन, कोडिंग से जुड़े ज़्यादा ऐडवांस टास्क के लिए, CodeGemma 7B इंस्ट्रक्शन-ट्यून मॉडल का इस्तेमाल करता है. CodeGemma 7B आईटी मॉडल को CodeGemma 7B PT मॉडल से बनाया गया है. इसे लोगों के सुझाव, शिकायत या राय की मदद से रीइन्फ़ोर्समेंट लर्निंग के साथ-साथ, कोड की निगरानी में फ़ाइन ट्यूनिंग की मदद से बनाया गया है. इस सेक्शन में, ओपन-एंडेड जनरेशन के लिए इस मॉडल को इस्तेमाल करने के उदाहरण दिए गए हैं.

आईटी मॉडल लोड करें

from_preset तरीके का इस्तेमाल करके, code_gemma_instruct_7b_en मॉडल को लोड करें.

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]

आईटी मॉडल को एक खास फ़ॉर्मैटर की मदद से ट्रेनिंग दी जाती है. यह टूल निर्देशों को बेहतर बनाने के सभी उदाहरणों में ज़्यादा जानकारी जोड़कर, यह तय करता है कि किसी बातचीत में क्या मोड़ हो सकता है.

सबसे पहले, कॉन्सटेंट और प्रॉम्प्ट फ़ॉर्मैटिंग हेल्पर फ़ंक्शन तय करें.

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

कोड का अनुवाद पाएं

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

प्रॉम्प्ट को फ़ॉर्मैट करें.

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

प्रॉम्प्ट चलाएं.

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

कोड के जोखिम की आशंका का पता लगाना

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

प्रॉम्प्ट को फ़ॉर्मैट करें.

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.

यह मॉडल, कोड में किसी संभावित जोखिम की आशंका का पता लगाता है और उसे कम करने के लिए, कोड में बदलाव करने की सुविधा देता है.

खास जानकारी

इस ट्यूटोरियल में, कोडिंग से जुड़े कई तरह के टास्क पूरे करने के लिए, CodeGemma का इस्तेमाल करने का तरीका बताया गया है. CodeGemma के बारे में ज़्यादा जानने के लिए: