starcoder2-3b-qlora-solidity

Model Card for Starcoder2-3B Fine-Tuned with QLORA on Solidity Dataset

Model Details

Model Description

This model has been fine-tuned using QLORA specifically for generating Solidity smart contracts from natural language instructions.

• Developed by: @yoniebans
• Model type: Transformer-based Causal Language Model
• Language(s) (NLP): English with programming language syntax (Solidity)
• License: [More Information Needed]
• Finetuned from model bigcode/starcoder2-3b

Model Sources [optional]

• Repository: [More Information Needed]
• Demo [optional]: [More Information Needed]

Uses

Direct Use

This model is designed to demonstrate how fine-tuning a base model such as starcoder2-3b using qlora with a targetted dataset can increase the model's ability to create Solidity code directly from natural language descriptions or instructions.

Out-of-Scope Use

This model is not intended for:

• Deployment in production systems without rigorous testing.
• Use in non-technical text generation or any context outside smart contract development.

Bias, Risks, and Limitations

The training data primarily consists of code from publicly sourced Solidity projects which may not encompass the full diversity of programming styles and techniques.

Recommendations

Users are advised to use this model as a starting point for development and not as a definitive solution. Generated code should always be reviewed by experienced developers to ensure security and functionality.

How to Get Started with the Model

Use the code below to get started with the model.

import sys
from peft import PeftModel
from transformers import BitsAndBytesConfig, AutoTokenizer, AutoModelForCausalLM
import torch
import accelerate

use_4bit = True
bnb_4bit_compute_dtype = "float32"
bnb_4bit_quant_type = "nf4"
use_double_nested_quant = True
compute_dtype = getattr(torch, bnb_4bit_compute_dtype)

device_map = "auto"
max_memory = '45000MB'
n_gpus = torch.cuda.device_count()
max_memory = {i: max_memory for i in range(n_gpus)}

model = AutoModelForCausalLM.from_pretrained(
    "bigcode/starcoder2-3b",
    cache_dir=None,
    device_map=device_map,
    max_memory=max_memory,
    quantization_config=BitsAndBytesConfig(
        load_in_4bit=use_4bit,
        llm_int8_threshold=6.0,
        llm_int8_has_fp16_weight=False,
        bnb_4bit_compute_dtype=compute_dtype,
        bnb_4bit_use_double_quant=use_double_nested_quant,
        bnb_4bit_quant_type=bnb_4bit_quant_type
    ),
    torch_dtype=torch.float32,
    trust_remote_code=False    
)
adapter_weights = "yoniebans/starcoder2-3b-qlora-solidity"
model = PeftModel.from_pretrained(model, adapter_weights)

tokenizer = AutoTokenizer.from_pretrained(
        checkpoint,
        cache_dir=None,
        padding_side="right",
        use_fast=False,
        tokenizer_type=None, # Needed for HF name change
        trust_remote_code=False,
        use_auth_token=False,
    )


input='Make a smart contract for a memecoin named 'LLMAI', adhering to the ERC20 standard. The contract should enforce a purchase limit where no individual wallet can acquire more than 1% of the total token supply, which is set at 10 billion tokens. This purchasing limit should be modifiable and can only be disabled by the contract owner at their discretion. Note that the interfaces for ERC20, Ownable, and any other dependencies should be assumed as already imported and do not need to be included in your code response.'

prompt = f"""### Instruction:
Use the Task below and the Input given to write the Response, which is a programming code that can solve the following Task:

### Task:
{input}

### Solution:
"""

input_ids = tokenizer(prompt, return_tensors="pt", truncation=True).input_ids.cuda()
outputs = model.generate(
    input_ids=input_ids, 
    max_new_tokens=2048, 
    do_sample=True, 
    top_p=0.9, 
    temperature=0.001, 
    pad_token_id=1
)

output_text = tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True)[0]
output_text_without_prompt = output_text[len(prompt):]

file_path = './smart_contract.sol'

with open(file_path, 'w') as file:
    file.write(output_text_without_prompt)

print(f"Output written to {file_path}")

Training Details

Training Data

The model was trained on a dataset consisting of pairs of natural language instructions and their corresponding Solidity code implementations. This dataset includes over 6000 input and outputs.

Training Procedure

Training Hyperparameters

• Number of train epochs: 30
• Double quant: true
• Quant type: nf4
• Bits: 4
• Lora r: 64
• Lora aplha: 16
• Lora dropout: 0.0
• Per device train batch size: 1
• Gradient accumulation steps: 1
• Max steps: 10000
• Weight decay: 0.0 #use lora dropout instead for regularization if needed
• Learning rate: 2e-4
• Max gradient normal: 0.3
• Gradient checkpointing: true
• FP16: false
• FP16 option level: O1
• BF16: false
• Optimizer: paged AdamW 32-bit
• Learning rate scheduler type: constant
• Warmup ratio: 0.03

Speeds, Sizes, Times [optional]

Results

Summary

Initial evaluations show promising results in generating Solidity code, with further testing planned.

Environmental Impact

• Hardware Type: NVIDIA A40 GPU, 48GB VRAM, 48GB RAM, 9vCPU
• Hours used: 18
• Cloud Provider: runpod.io
• Compute Region: [More Information Needed]
• Carbon Emitted: [More Information Needed]

Citation [optional]

BibTeX:

@misc{lozhkov2024starcoder,
      title={StarCoder 2 and The Stack v2: The Next Generation}, 
      author={Anton Lozhkov and Raymond Li and Loubna Ben Allal and Federico Cassano and Joel Lamy-Poirier and Nouamane Tazi and Ao Tang and Dmytro Pykhtar and Jiawei Liu and Yuxiang Wei and Tianyang Liu and Max Tian and Denis Kocetkov and Arthur Zucker and Younes Belkada and Zijian Wang and Qian Liu and Dmitry Abulkhanov and Indraneil Paul and Zhuang Li and Wen-Ding Li and Megan Risdal and Jia Li and Jian Zhu and Terry Yue Zhuo and Evgenii Zheltonozhskii and Nii Osae Osae Dade and Wenhao Yu and Lucas Krauß and Naman Jain and Yixuan Su and Xuanli He and Manan Dey and Edoardo Abati and Yekun Chai and Niklas Muennighoff and Xiangru Tang and Muhtasham Oblokulov and Christopher Akiki and Marc Marone and Chenghao Mou and Mayank Mishra and Alex Gu and Binyuan Hui and Tri Dao and Armel Zebaze and Olivier Dehaene and Nicolas Patry and Canwen Xu and Julian McAuley and Han Hu and Torsten Scholak and Sebastien Paquet and Jennifer Robinson and Carolyn Jane Anderson and Nicolas Chapados and Mostofa Patwary and Nima Tajbakhsh and Yacine Jernite and Carlos Muñoz Ferrandis and Lingming Zhang and Sean Hughes and Thomas Wolf and Arjun Guha and Leandro von Werra and Harm de Vries},
      year={2024},
      eprint={2402.19173},
      archivePrefix={arXiv},
      primaryClass={cs.SE}
}

APA:

Starcoder2-3B: BigCode Team. (2024). Starcoder2-3B [Software]. Available from https://huggingface.co/bigcode/starcoder2-3b

AlfredPros Smart Contracts Instructions: AlfredPros. (2023). Smart Contracts Instructions [Data set]. Available from https://huggingface.co/datasets/AlfredPros/smart-contracts-instructions

Model Card Contact

[email protected]