README.md · lmstudio-community/stable-code-instruct-3b-GGUF at 3f7425a3aae82b502e93968f6073ed3b8bb88f06

metadata

license: other
language:
  - en
tags:
  - causal-lm
  - code
metrics:
  - code_eval
library_name: transformers
model-index:
  - name: stabilityai/stable-code-instruct-3b
    results:
      - task:
          type: text-generation
        dataset:
          type: nuprl/MultiPL-E
          name: MultiPL-HumanEval (Python)
        metrics:
          - name: pass@1
            type: pass@1
            value: 32.4
            verified: false
      - task:
          type: text-generation
        dataset:
          type: nuprl/MultiPL-E
          name: MultiPL-HumanEval (C++)
        metrics:
          - name: pass@1
            type: pass@1
            value: 30.9
            verified: false
      - task:
          type: text-generation
        dataset:
          type: nuprl/MultiPL-E
          name: MultiPL-HumanEval (Java)
        metrics:
          - name: pass@1
            type: pass@1
            value: 32.1
            verified: false
      - task:
          type: text-generation
        dataset:
          type: nuprl/MultiPL-E
          name: MultiPL-HumanEval (JavaScript)
        metrics:
          - name: pass@1
            type: pass@1
            value: 32.1
            verified: false
      - task:
          type: text-generation
        dataset:
          type: nuprl/MultiPL-E
          name: MultiPL-HumanEval (PHP)
        metrics:
          - name: pass@1
            type: pass@1
            value: 24.2
            verified: false
      - task:
          type: text-generation
        dataset:
          type: nuprl/MultiPL-E
          name: MultiPL-HumanEval (Rust)
        metrics:
          - name: pass@1
            type: pass@1
            value: 23
            verified: false
quantized_by: bartowski
pipeline_tag: text-generation
lm_studio:
  param_count: 3b
  use_case: coding
  release_date: 19-03-2024
  model_creator: stabilityai
  prompt_template: ChatML
  system_prompt: >-
    A chat between a curious user and an artificial intelligence assistant. The
    assistant gives helpful, detailed, and polite answers to the user's
    questions.
  base_model: stablelm
  original_repo: stabilityai/stable-code-instruct-3b

💫 Community Model> Stable Code Instruct 3B by Stability AI

👾 LM Studio Community models highlights program. Highlighting new & noteworthy models by the community. Join the conversation on Discord.

Model creator: Stability AI
Original model: stable-code-instruct-3b
GGUF quantization: provided by bartowski based on llama.cpp release b2440

Model Summary:

Stable Code Instruct 3B is part of the Stable Code family, instruction tuned using Direct Preference Optimization (DPO) from the base Stable Code 3B model. This model is great for general purpose coversational coding, as well as SQL generation.

Prompt Template:

Choose the ChatML preset in your LM Studio.

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

<|im_start|>system
A chat between a curious user and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions.<|im_end|>
<|im_start|>user
{prompt}<|im_end|>
<|im_start|>assistant

Use case and examples

Stable Code Instruct 3B is trained primarily on coding, with a bit of conversational tuning to provide some assistant behavior. It also excels at SQL generation. This makes it great for light-weight coding purposes and its size makes it extremely fast for potential code-completion.

SQL generation with explanation:

import sqlite3
# Connect to the database (or create it if it doesn't exist)
conn = sqlite3.connect('example.db')
# Create a cursor object to execute SQL commands
c = conn.cursor()
# Define the table schema with a composite primary key
schema = '''
CREATE TABLE example_table (
    column1 TEXT,
    column2 INTEGER,
    PRIMARY KEY (column1, column2)
);
'''
# Execute the SQL command to create the table
c.execute(schema)
# Commit the changes to the database
conn.commit()
# Close the database connection
conn.close()

In this example, we first import the sqlite3 module and create a connection to the database (or create it if it doesn't exist). We then create a cursor object to execute SQL commands. Next, we define the table schema with a composite primary key using the CREATE TABLE command. In this example, the table is named example_table and has two columns: column1 (text data type) and column2 (integer data type). The PRIMARY KEY constraint is used to specify that the combination of column1 and column2 should be unique for each row in the table. After defining the table schema, we execute the SQL command using the cursor object. We then commit the changes to the database and close the database connection. Note that this example assumes that you have already installed the sqlite3 module in your Python environment. If you haven't done so already, you can install it by running the following command in your terminal or command prompt:

pip install sqlite3

This will install the sqlite3 module in your Python environment.<|im_end|>

General python coding questions:

<|im_start|>system
A chat between a curious user and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions.<|im_end|>
<|im_start|>user
Using python, how can I create an SQL table where the primary key is a combination of two columns?<|im_end|>
<|im_start|>assistant
You can achieve this by using Python's built-in sort() function or sorted() function. Both these functions allow you to specify multiple sorting conditions.

Here is an example code snippet that demonstrates how to sort a list of integer tuples based on the second item, then the first:

# Sample list of integer tuples
my_list = [(1, 2), (3, 1), (2, 3)]

# Sort the list by the second item, then the first
my_list.sort(key=lambda x: (x[1], x[0]))))

# Print the sorted list
print(my_list)

In this example, we use a lambda function as the key argument to the sort() function. The lambda function takes each tuple in the list and returns a tuple of the second item and the first item of the original tuple. This way, the tuples are sorted based on the second item first, then by the first item if there is a tie.

The output of this code will be:

[(3, 1), (1, 2), (2, 3)]

This means that the list has been sorted in ascending order based on the second item of each tuple, and if there is a tie, it is resolved by sorting based on the first item of each tuple.<|im_end|>

General C coding questions:

#include <stdio.h>

int main() {
    int num1, num2, sum;

    printf("Enter first number: ");
    scanf("%d", &num1);

    printf("Enter second number: ");
    scanf("%d", &num2);

    sum = num1 + num2;

    printf("The sum of %d and %d is %d\n", num1, num2, sum);

    return 0;
}

This program first prompts the user to enter two numbers. It then calculates the sum of those two numbers and prints the result to the console.<|im_end|>

Technical Details

The base model was trained from the following datasets:

Specializing in the following languages:

C
CPP
Java
JavaScript
CSS
Go
HTML
Ruby
Rust
Markdown
Shell
Php
Sql
R
Typescript
Python
Jupyter-Clean
RestructuredText

Special thanks

🙏 Special thanks to Georgi Gerganov and the whole team working on llama.cpp for making all of this possible.

Disclaimers

TBD