Update README.md

README.md

@@ -18,76 +18,284 @@ inference:
 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
 ---
 
-## Llamacpp Quantizations of codegemma-7b-it
+## 💫 Community Model> CodeGemma 7b Instruct by Google
 
-Using <a href="https://github.com/ggerganov/llama.cpp/">llama.cpp</a> release <a href="https://github.com/ggerganov/llama.cpp/releases/tag/b2589">b2589</a> for quantization.
+*👾 [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)*.
 
-Original model: https://huggingface.co/google/codegemma-7b-it
+**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>
 
-All quants made using imatrix option with dataset provided by Kalomaze [here](https://github.com/ggerganov/llama.cpp/discussions/5263#discussioncomment-8395384)
+## 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 format
+## 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:
 
 ```
-<bos><start_of_turn>user
+<start_of_turn>user
 {prompt}<end_of_turn>
 <start_of_turn>model
-
 ```
 
 Note that this model does not support a System prompt.
 
-## Download a file (not the whole branch) from below:
+## 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:
 
-| Filename | Quant type | File Size | Description |
-| -------- | ---------- | --------- | ----------- |
-| [codegemma-7b-it-Q8_0.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-Q8_0.gguf) | Q8_0 | 9.07GB | Extremely high quality, generally unneeded but max available quant. |
-| [codegemma-7b-it-Q6_K.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-Q6_K.gguf) | Q6_K | 7.01GB | Very high quality, near perfect, *recommended*. |
-| [codegemma-7b-it-Q5_K_M.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-Q5_K_M.gguf) | Q5_K_M | 6.14GB | High quality, *recommended*. |
-| [codegemma-7b-it-Q5_K_S.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-Q5_K_S.gguf) | Q5_K_S | 5.98GB | High quality, *recommended*. |
-| [codegemma-7b-it-Q4_K_M.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-Q4_K_M.gguf) | Q4_K_M | 5.32GB | Good quality, uses about 4.83 bits per weight, *recommended*. |
-| [codegemma-7b-it-Q4_K_S.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-Q4_K_S.gguf) | Q4_K_S | 5.04GB | Slightly lower quality with more space savings, *recommended*. |
-| [codegemma-7b-it-IQ4_NL.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-IQ4_NL.gguf) | IQ4_NL | 5.01GB | Decent quality, slightly smaller than Q4_K_S with similar performance *recommended*. |
-| [codegemma-7b-it-IQ4_XS.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-IQ4_XS.gguf) | IQ4_XS | 4.76GB | Decent quality, smaller than Q4_K_S with similar performance, *recommended*. |
-| [codegemma-7b-it-Q3_K_L.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-Q3_K_L.gguf) | Q3_K_L | 4.70GB | Lower quality but usable, good for low RAM availability. |
-| [codegemma-7b-it-Q3_K_M.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-Q3_K_M.gguf) | Q3_K_M | 4.36GB | Even lower quality. |
-| [codegemma-7b-it-IQ3_M.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-IQ3_M.gguf) | IQ3_M | 4.10GB | Medium-low quality, new method with decent performance comparable to Q3_K_M. |
-| [codegemma-7b-it-IQ3_S.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-IQ3_S.gguf) | IQ3_S | 3.98GB | Lower quality, new method with decent performance, recommended over Q3_K_S quant, same size with better performance. |
-| [codegemma-7b-it-Q3_K_S.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-Q3_K_S.gguf) | Q3_K_S | 3.98GB | Low quality, not recommended. |
-| [codegemma-7b-it-IQ3_XS.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-IQ3_XS.gguf) | IQ3_XS | 3.80GB | Lower quality, new method with decent performance, slightly better than Q3_K_S. |
-| [codegemma-7b-it-IQ3_XXS.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-IQ3_XXS.gguf) | IQ3_XXS | 3.48GB | Lower quality, new method with decent performance, comparable to Q3 quants. |
-| [codegemma-7b-it-Q2_K.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-Q2_K.gguf) | Q2_K | 3.48GB | Very low quality but surprisingly usable. |
-| [codegemma-7b-it-IQ2_M.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-IQ2_M.gguf) | IQ2_M | 3.13GB | Very low quality, uses SOTA techniques to also be surprisingly usable. |
-| [codegemma-7b-it-IQ2_S.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-IQ2_S.gguf) | IQ2_S | 2.91GB | Very low quality, uses SOTA techniques to be usable. |
-| [codegemma-7b-it-IQ2_XS.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-IQ2_XS.gguf) | IQ2_XS | 2.81GB | Very low quality, uses SOTA techniques to be usable. |
-| [codegemma-7b-it-IQ2_XXS.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-IQ2_XXS.gguf) | IQ2_XXS | 2.58GB | Lower quality, uses SOTA techniques to be usable. |
-| [codegemma-7b-it-IQ1_M.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-IQ1_M.gguf) | IQ1_M | 2.32GB | Extremely low quality, *not* recommended. |
-| [codegemma-7b-it-IQ1_S.gguf](https://huggingface.co/bartowski/codegemma-7b-it-GGUF/blob/main/codegemma-7b-it-IQ1_S.gguf) | IQ1_S | 2.16GB | Extremely low quality, *not* recommended. |
+* `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.
 
-## Which file should I choose?
+Here is an example of how to use a for loop to render a list of items:
 
-A great write up with charts showing various performances is provided by Artefact2 [here](https://gist.github.com/Artefact2/b5f810600771265fc1e39442288e8ec9)
+    const items = ["item 1", "item 2", "item 3"];
+    
+    const listItems = items.map((item, index) => (
+      <li key={index}>{item}</li>
+    ));
+    
+    return (
+      <ul>
+        {listItems}
+      </ul>
+    );
 
-The first thing to figure out is how big a model you can run. To do this, you'll need to figure out how much RAM and/or VRAM you have.
+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>
+```
 
-If you want your model running as FAST as possible, you'll want to fit the whole thing on your GPU's VRAM. Aim for a quant with a file size 1-2GB smaller than your GPU's total VRAM.
+## Technical Details
 
-If you want the absolute maximum quality, add both your system RAM and your GPU's VRAM together, then similarly grab a quant with a file size 1-2GB Smaller than that total.
+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.
 
-Next, you'll need to decide if you want to use an 'I-quant' or a 'K-quant'.
+The code used is based on publicly avaialble code repositories.
 
-If you don't want to think too much, grab one of the K-quants. These are in format 'QX_K_X', like Q5_K_M.
+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.
 
-If you want to get more into the weeds, you can check out this extremely useful feature chart:
+Additional details can be found on Google's official report PDF [here](https://storage.googleapis.com/deepmind-media/gemma/codegemma_report.pdf)
 
-[llama.cpp feature matrix](https://github.com/ggerganov/llama.cpp/wiki/Feature-matrix)
+## Special thanks
 
-But basically, if you're aiming for below Q4, and you're running cuBLAS (Nvidia) or rocBLAS (AMD), you should look towards the I-quants. These are in format IQX_X, like IQ3_M. These are newer and offer better performance for their size.
+🙏 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.
 
-These I-quants can also be used on CPU and Apple Metal, but will be slower than their K-quant equivalent, so speed vs performance is a tradeoff you'll have to decide.
+🙏 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!
 
-The I-quants are *not* compatible with Vulcan, which is also AMD, so if you have an AMD card double check if you're using the rocBLAS build or the Vulcan build. At the time of writing this, LM Studio has a preview with ROCm support, and other inference engines have specific builds for ROCm.
+## Disclaimers
 
-Want to support my work? Visit my ko-fi page here: https://ko-fi.com/bartowski
+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.