---
library_name: transformers
extra_gated_heading: Access Gemma on Hugging Face
extra_gated_prompt: >-
  To access CodeGemma on Hugging Face, you’re required to review and agree to
  Google’s usage license. To do this, please ensure you’re logged-in to Hugging
  Face and click below. Requests are processed immediately.
extra_gated_button_content: Acknowledge license
pipeline_tag: text-generation
widget:
- text: >
    <start_of_turn>user
    Write a Python function to calculate the nth fibonacci number.<end_of_turn>
    <start_of_turn>model
inference:
  parameters:
    max_new_tokens: 200
license: gemma
license_link: https://ai.google.dev/gemma/terms
quantized_by: bartowski
lm_studio:
  param_count: 8b
  use_case: coding
  release_date: 09-04-2024
  model_creator: google
  prompt_template: Google Gemma Instruct
  system_prompt: none
  base_model: gemma
  original_repo: google/codegemma-7b-it
---

## 💫 Community Model> CodeGemma 7b Instruct by Google

*👾 [LM Studio](https://lmstudio.ai) Community models highlights program. Highlighting new & noteworthy models by the community. Join the conversation on [Discord](https://discord.gg/aPQfnNkxGC)*.

**Model creator:** [Google](https://huggingface.co/google)<br>
**Original model**: [google/codegemma-7b-it](https://huggingface.co/google/codegemma-7b-it)<br>
**GGUF quantization:** provided by [bartowski](https://huggingface.co/bartowski) based on `llama.cpp` release [b2589](https://github.com/ggerganov/llama.cpp/releases/tag/b2589)<br>

## Model Summary:
CodeGemma 7b Instruct is the first in a series of coding models released by Google. As an instruct model, it specializes in being asked coding related questions, but can also function as an autocomplete/fill-in-middle model for tools like co-pilot.<br>
This model is perfect for general coding questions or code generation.

## Prompt Template:

Choose the 'Google Gemma Instruct' preset in your LM Studio. 

Under the hood, the model will see a prompt that's formatted like so:

```
<start_of_turn>user
{prompt}<end_of_turn>
<start_of_turn>model
```

Note that this model does not support a System prompt.

## Use case and examples

This model should be used for coding purposes.

### Coding 1

```
<start_of_turn>user
Write a quicksort in C++<end_of_turn>
<start_of_turn>model
    #include <iostream>
    
    using namespace std;
    
    int partition(int arr[], int low, int high) {
      int pivot = arr[high];
      int i = (low - 1);
    
      for (int j = low; j <= high - 1; j++) {
        if (arr[j] <= pivot) {
          i++;
          swap(arr[i], arr[j]);
        }
      }
      swap(arr[i + 1], arr[high]);
      return (i + 1);
    }
    
    void quickSort(int arr[], int low, int high) {
      if (low < high) {
        int pi = partition(arr, low, high);
    
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
      }
    }
    
    int main() {
      int arr[] = {10, 7, 8, 9, 1, 5};
      int n = sizeof(arr) / sizeof(arr[0]);
    
      quickSort(arr, 0, n - 1);
    
      cout << "Sorted array: ";
      for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
      }
    
      return 0;
    }
<end_of_turn>
```

### Coding 2

```
<start_of_turn>user
Write a merge sort in java<end_of_turn>
<start_of_turn>model

    public class MergeSort {

        public static void mergeSort(int[] arr) {
            int n = arr.length;
            if (n < 2) {
                return;
            }
            int mid = n / 2;
            int[] left = new int[mid];
            int[] right = new int[n - mid];
            for (int i = 0; i < mid; i++) {
                left[i] = arr[i];
            }
            for (int i = mid; i < n; i++) {
                right[i - mid] = arr[i];
            }
            mergeSort(left);
            mergeSort(right);
            merge(arr, left, right);
        }
    
        public static void merge(int[] arr, int[] left, int[] right) {
            int i = 0;
            int j = 0;
            int k = 0;
            while (i < left.length && j < right.length) {
                if (left[i] <= right[j]) {
                    arr[k] = left[i];
                    i++;
                } else {
                    arr[k] = right[j];
                    j++;
                }
                k++;
            }
            while (i < left.length) {
                arr[k] = left[i];
                i++;
                k++;
            }
            while (j < right.length) {
                arr[k] = right[j];
                j++;
                k++;
            }
        }
    
        public static void main(String[] args) {
            int[] arr = {5, 2, 4, 6, 1, 3};
            mergeSort(arr);
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
        }
    }
<end_of_turn>
```

### Coding 3

```
<bos><start_of_turn>user
How do you write a for loop in react?<end_of_turn>
<start_of_turn>model
The syntax for a for loop in React is:

    for (let i = 0; i < array.length; i++) {
      // Code to be executed for each iteration
    }

Where:

* `i` is the loop variable, which starts at 0 and increments by 1 with each iteration.
* `array` is the array you want to iterate over.
* `array.length` is the length of the array.
* `// Code to be executed for each iteration` is the code you want to execute for each iteration of the loop.

Here is an example of how to use a for loop to render a list of items:

    const items = ["item 1", "item 2", "item 3"];
    
    const listItems = items.map((item, index) => (
      <li key={index}>{item}</li>
    ));
    
    return (
      <ul>
        {listItems}
      </ul>
    );

In this example, the `map()` method is used to create a new array of `li` elements. The `key` prop is used to uniquely identify each `li` element.

Here are some other things to keep in mind when using for loops in React:

* You can use any variable name for the loop variable.
* You can use any condition for the loop condition.
* You can use any code inside the loop.
* You can use nested for loops.

Here are some resources that you may find helpful:

* **For Loop in JavaScript:** https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for
* **Map() method:** https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map
* **Key prop:** https://reactjs.org/docs/lists-and-keys.html#keys<end_of_turn>
```

## Coding related question

```
<bos><start_of_turn>user
When would you use an array versus a dictionary?<end_of_turn>
<start_of_turn>model
**Arrays** and **dictionaries** are both data structures used in computer programming, but they have different purposes and characteristics.

**Arrays** are ordered collections of elements of the same data type. They are indexed by their position in the array, starting from 0. Arrays are ideal for storing and accessing data in a sequential manner.

**Dictionaries**, on the other hand, are unordered collections of key-value pairs. Keys are unique identifiers that are used to access the corresponding values. Dictionaries are ideal for storing and accessing data based on a specific key.

**When to use an array:**

* When you need to store a fixed number of elements of the same data type.
* When you need to access elements by their position in the array.
* When you need to iterate over the elements in a specific order.

**When to use a dictionary:**

* When you need to store a variable number of elements of different data types.
* When you need to access elements by their key.
* When you need to quickly check if a key exists in the dictionary.

**Example:**

**Array:**

    # Create an array of integers
    numbers = [1, 2, 3, 4, 5]
    
    # Access the first element
    print(numbers[0])  # Output: 1
    
    # Iterate over the elements
    for number in numbers:
        print(number)

**Dictionary:**

    # Create a dictionary of names and ages
    names_ages = {"John": 30, "Jane": 25, "Peter": 40}
    
    # Access the age of John
    print(names_ages["John"])  # Output: 30
    
    # Check if a key exists
    if "Mary" in names_ages:
        print("Mary is in the dictionary")
    else:
        print("Mary is not in the dictionary")

**In summary:**

* Use an array when you need to store a fixed number of elements of the same data type and access them by their position.
* Use a dictionary when you need to store a variable number of elements of different data types and access them by their key.<end_of_turn>
```

## Technical Details

CodeGemma is based on the Gemma 7b model with additional training on web documents, mathematics, and code, with a mixture of 80% code and 20% natural language.

The code used is based on publicly avaialble code repositories.

The instruct version was further trained on mathematical datasets in an attempt to improve its mathematical reasoning capabilities, as well as synthetic code generation combined with a second LLM for evaluation and reinforcement feedback.

Additional details can be found on Google's official report PDF [here](https://storage.googleapis.com/deepmind-media/gemma/codegemma_report.pdf)

## Special thanks

🙏 Special thanks to [Georgi Gerganov](https://github.com/ggerganov) and the whole team working on [llama.cpp](https://github.com/ggerganov/llama.cpp/) for making all of this possible.

🙏 Special thanks to [Kalomaze](https://github.com/kalomaze) for his dataset (linked [here](https://github.com/ggerganov/llama.cpp/discussions/5263)) that was used for calculating the imatrix for these quants, which improves the overall quality!

## Disclaimers

LM Studio is not the creator, originator, or owner of any Model featured in the Community Model Program. Each Community Model is created and provided by third parties. LM Studio does not endorse, support, represent or guarantee the completeness, truthfulness, accuracy, or reliability of any Community Model.  You understand that Community Models can produce content that might be offensive, harmful, inaccurate or otherwise inappropriate, or deceptive. Each Community Model is the sole responsibility of the person or entity who originated such Model. LM Studio may not monitor or control the Community Models and cannot, and does not, take responsibility for any such Model. LM Studio disclaims all warranties or guarantees about the accuracy, reliability or benefits of the Community Models.  LM Studio further disclaims any warranty that the Community Model will meet your requirements, be secure, uninterrupted or available at any time or location, or error-free, viruses-free, or that any errors will be corrected, or otherwise. You will be solely responsible for any damage resulting from your use of or access to the Community Models, your downloading of any Community Model, or use of any other Community Model provided by or through LM Studio.