You can deploy this model and start earning money today!

Aswith77/
gemma-2-2b-it-finetune-codeforces-cots

Name: gemma-2-2b-it-finetune-codeforces-cots
Availability: InStock

Views

No views yet

Gemma-2-2b Fine-tuned for Competitive Programming

This model is a fine-tuned version of google/gemma-2-2b-it on the open-r1/codeforces-cots dataset for competitive programming problem solving.

Model Details

Model Description

This model has been fine-tuned using LoRA (Low-Rank Adaptation) on competitive programming problems from Codeforces. It's designed to help generate solutions for algorithmic and data structure problems commonly found in competitive programming contests.

Developed by: Aswith77
Model type: Causal Language Model (Code Generation)
Language(s): Python, C++, Java (primarily Python)
License: MIT
Finetuned from model: google/gemma-2-2b-it
Fine-tuning method: LoRA (Low-Rank Adaptation)

Model Sources

Repository: Hugging Face Model
Base Model: google/gemma-2-2b-it
Dataset: open-r1/codeforces-cots

Uses

Direct Use

This model is intended for generating solutions to competitive programming problems, particularly those similar to Codeforces problems. It can:

Generate algorithmic solutions for given problem statements
Help with code completion for competitive programming
Assist in learning algorithmic problem-solving patterns

Downstream Use

The model can be further fine-tuned on:

Specific programming languages
Domain-specific algorithmic problems
Educational coding platforms

Out-of-Scope Use

This model should not be used for:

Production code without thorough testing
Security-critical applications
General-purpose software development without validation
Problems requiring real-world system design

How to Get Started with the Model

python

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel
import torch

# Load the base model
base_model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-2-2b-it",
    torch_dtype=torch.float16,
    device_map="auto"
)

# Load the fine-tuned LoRA adapters
model = PeftModel.from_pretrained(
    base_model,
    "Aswith77/gemma-2-2b-it-finetune-codeforces-cots"
)

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained("google/gemma-2-2b-it")

# Generate code for a problem
problem = """
Given an array of integers, find the maximum sum of a contiguous subarray.
Input: [-2,1,-3,4,-1,2,1,-5,4]
Output: 6 (subarray [4,-1,2,1])
"""

inputs = tokenizer(problem, return_tensors="pt")
outputs = model.generate(
    **inputs,
    max_length=512,
    temperature=0.7,
    do_sample=True,
    pad_token_id=tokenizer.eos_token_id
)

solution = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(solution)

Training Details

Training Data

The model was trained on the open-r1/codeforces-cots dataset, specifically using 1,000 competitive programming problems and their solutions from Codeforces.

Training Procedure

Training Hyperparameters

Training regime: fp16 mixed precision
Learning rate: 2e-4
Batch size: 1 (per device)
Gradient accumulation steps: 2
Max steps: 100
Warmup steps: 5
Optimizer: AdamW 8-bit
Weight decay: 0.01
LoRA rank (r): 16
LoRA alpha: 32
LoRA dropout: 0.1
Target modules: q_proj, v_proj, k_proj, o_proj, gate_proj, up_proj, down_proj

Speeds, Sizes, Times

Training time: ~20 minutes
Hardware: Tesla T4 GPU (16GB)
Model size: ~30MB (LoRA adapters only)
Final training loss: 0.3715
Training samples per second: 0.338

Evaluation

The model achieved a training loss of 0.3715, showing good convergence from an initial loss of 0.9303. The loss curve demonstrated steady improvement throughout training without signs of overfitting.

Training Loss Progression

Initial loss: 0.9303
Final loss: 0.3715
Loss reduction: ~60%

Bias, Risks, and Limitations

Limitations

Dataset bias: Trained primarily on Codeforces problems, may not generalize well to other competitive programming platforms
Language bias: Solutions may favor certain programming patterns common in the training data
Size limitations: Being a 2B parameter model, it may struggle with very complex algorithmic problems
Code correctness: Generated code should always be tested and validated before use

Recommendations

Always test generated solutions with multiple test cases
Use the model as a starting point, not a final solution
Verify algorithmic correctness and time complexity
Consider the model's suggestions as one approach among many possible solutions

Environmental Impact

Training was conducted on a single Tesla T4 GPU for approximately 20 minutes, resulting in minimal environmental impact compared to larger scale training runs.

Hardware Type: Tesla T4 GPU
Hours used: 0.33 hours
Cloud Provider: Kaggle
Compute Region: Not specified
Carbon Emitted: Minimal (estimated < 0.1 kg CO2eq)

Technical Specifications

Model Architecture and Objective

Base Architecture: Gemma-2 (2B parameters)
Fine-tuning Method: LoRA (Low-Rank Adaptation)
Objective: Causal language modeling with supervised fine-tuning
Quantization: 4-bit quantization during training

Compute Infrastructure

Hardware

GPU: Tesla T4 (16GB VRAM)
Platform: Kaggle Notebooks

Software

Framework: PyTorch, Transformers, PEFT, TRL
Quantization: bitsandbytes 4-bit
Training: Supervised Fine-Tuning (SFT)

Model Card Authors

Created by Aswith77 during fine-tuning experiments with competitive programming datasets.

Model Card Contact

For questions or issues regarding this model, please open an issue in the model repository.