convaiinnovations/fine_tuned_coder

# Install required packages
pip install unsloth transformers torch accelerate bitsandbytes

# For CPU-only inference
pip install transformers torch

from unsloth import FastLanguageModel
import torch

# Load model with 4-bit quantization
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "convaiinnovations/fine_tuned_coder",
    max_seq_length = 2048,
    dtype = None,
    load_in_4bit = True,  # Use 4-bit for memory efficiency
)

# Enable fast inference mode
FastLanguageModel.for_inference(model)

# Define prompt template
coding_prompt = """Below is a coding question. Write a response that appropriately answers the question.

### Question:
{}

### Answer:
{}"""

# Ask a question
question = "python mei control statements kya hei?"
inputs = tokenizer(
    [coding_prompt.format(question, "")],
    return_tensors = "pt"
).to("cuda")

# Generate response with streaming
from transformers import TextStreamer
text_streamer = TextStreamer(tokenizer, skip_prompt=True)

outputs = model.generate(
    **inputs,
    streamer = text_streamer,
    max_new_tokens = 512,
    temperature = 0.7,
    top_p = 0.9,
    do_sample = True,
)

from unsloth import FastLanguageModel
from transformers import TextStreamer
import torch

# Configuration
MODEL_NAME = "convaiinnovations/fine_tuned_coder"
MAX_SEQ_LENGTH = 2048
LOAD_IN_4BIT = True  # Set False for full precision

# Load model and tokenizer
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = MODEL_NAME,
    max_seq_length = MAX_SEQ_LENGTH,
    dtype = None,
    load_in_4bit = LOAD_IN_4BIT,
)

# Enable inference mode
FastLanguageModel.for_inference(model)

# Prompt template
coding_prompt = """Below is a coding question. Write a response that appropriately answers the question.

### Question:
{}

### Answer:
{}"""

def ask_coding_question(question, max_tokens=512, temp=0.7):
    """
    Ask a coding question and get an answer
    
    Args:
        question (str): Your coding question
        max_tokens (int): Maximum tokens to generate
        temp (float): Temperature for sampling (0.1-1.5)
    """
    inputs = tokenizer(
        [coding_prompt.format(question, "")],
        return_tensors="pt"
    ).to("cuda")
    
    text_streamer = TextStreamer(tokenizer, skip_prompt=True)
    
    outputs = model.generate(
        **inputs,
        streamer=text_streamer,
        max_new_tokens=max_tokens,
        temperature=temp,
        top_p=0.9,
        do_sample=True,
        repetition_penalty=1.1,
    )
    
    return tokenizer.decode(outputs[0], skip_special_tokens=True)

# Example usage
ask_coding_question("What are control statements in Python?")
ask_coding_question("for loop kaise use karte hain?")

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Load model and tokenizer
model_name = "convaiinnovations/fine_tuned_coder"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto",
    load_in_4bit=True,  # Optional: for memory efficiency
)

# Prompt template
coding_prompt = """Below is a coding question. Write a response that appropriately answers the question.

### Question:
{}

### Answer:
{}"""

# Generate function
def generate_answer(question, max_length=512):
    inputs = tokenizer(
        coding_prompt.format(question, ""),
        return_tensors="pt"
    ).to(model.device)
    
    outputs = model.generate(
        **inputs,
        max_new_tokens=max_length,
        temperature=0.7,
        top_p=0.9,
        do_sample=True,
        pad_token_id=tokenizer.eos_token_id,
    )
    
    answer = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return answer

# Example
answer = generate_answer("Explain list comprehension in Python")
print(answer)

# Process multiple questions efficiently
questions = [
    "python mei control statements kya hei?",
    "What is a for loop?",
    "function ko define kaise karein?",
    "Explain decorators in Python",
]

for i, question in enumerate(questions, 1):
    print(f"\n{'='*60}")
    print(f"Question {i}: {question}")
    print('='*60)
    
    inputs = tokenizer(
        [coding_prompt.format(question, "")],
        return_tensors="pt"
    ).to("cuda")
    
    outputs = model.generate(
        **inputs,
        max_new_tokens=512,
        temperature=0.7,
        top_p=0.9,
    )
    
    answer = tokenizer.decode(outputs[0], skip_special_tokens=True)
    print(answer)

from transformers import AutoModelForCausalLM, AutoTokenizer

# Load on CPU
model_name = "convaiinnovations/fine_tuned_coder"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float32,  # Use float32 for CPU
    device_map="cpu",
)

# Rest of the code remains the same

# Example from training dataset
Question: "What's the deal with transfer learning in NLP models?"
Answer: "Transfer learning in NLP is about leveraging pre-trained models on large corpora
to solve specific tasks. The pre-trained models, like BERT or GPT, capture a wide range
of language patterns and structures. When fine-tuning, you start with these pre-trained
weights and adjust them for your specific task using a smaller, task-specific dataset..."

# Test Question (Pure Hindi)
"python mei control statements kya hei?"

# Model Output (Pure Hindi Response)
"Python में Control Statements वो शब्द होते हैं जो किसी कार्य को एक बार में या
अलग-अलग बार में आगे या बाहर भेजने की क्षमता देते हैं। उदाहरण के लिए, एक बेसिक
ग्राफिकल एप्लिकेशन में, आप अपने कोड में input() और output() फंक्शन्स का उपयोग
कर सकते हैं। यह अक्सर विभिन्न प्रकार के लाइव डेवलपमेंट और ऑटो-रेग्रेशन के लिए
उपयोगी होते हैं।"

# Another Example (Hindi Question → Hindi Response)
Question: "function ko define kaise karein?"
Answer: "Python में function को define करने के लिए def keyword का उपयोग करें।
उसके बाद function का नाम, parentheses में parameters, और colon लगाएं। फिर
indented block में function का code लिखें।"

# Control Statements (नियंत्रण कथन)
"Python में control statements क्या होते हैं?"
"if-else statement का उपयोग कैसे करें?"
"conditional statements को समझाइए"

# Loops (लूप्स)
"for loop कैसे काम करता है?"
"while loop का सिंटैक्स क्या है?"
"nested loops को उदाहरण सहित समझाइए"

# Functions (फंक्शन)
"Python में function कैसे बनाते हैं?"
"function में parameters कैसे पास करते हैं?"
"return statement का क्या काम है?"

# Data Structures (डेटा संरचना)
"list और tuple में क्या अंतर है?"
"dictionary में key-value pairs कैसे स्टोर करते हैं?"
"set का उपयोग कब करना चाहिए?"

# File Handling (फाइल हैंडलिंग)
"Python में file को कैसे पढ़ते हैं?"
"file में डेटा कैसे लिखते हैं?"
"with statement का क्या फायदा है?"

# Error Handling (एरर हैंडलिंग)
"try-except block कैसे काम करता है?"
"exception को कैसे handle करें?"
"finally block का उपयोग कब करते हैं?"

# OOP (ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग)
"class और object में क्या अंतर है?"
"inheritance का मतलब क्या है?"
"constructor क्या होता है और कैसे बनाते हैं?"

# Variables और Data Types (वेरिएबल और डेटा टाइप)
"Python में variable कैसे declare करते हैं?"
"data types कितने प्रकार के होते हैं?"
"type conversion कैसे करते हैं?"

# Basics
"What are variables in Python?"
"Explain data types in Python"

# Control Flow
"What are control statements in Python?"
"How do if-else statements work?"

# Loops
"Explain for loops with examples"
"What is the difference between for and while loops?"

# Functions
"How to define a function in Python?"
"What are lambda functions?"

# Data Structures
"What is the difference between list and tuple?"
"Explain dictionary comprehension"

# Advanced
"What are decorators in Python?"
"Explain generators and iterators"

# You can also mix languages
"Python mei list comprehension kya hai? Give me an example."
"What is a for loop? Iska syntax kya hai?"

coding_prompt = """Below is a coding question. Write a response that appropriately answers the question.

### Question:
{}

### Answer:
{}"""

outputs = model.generate(
    **inputs,
    max_new_tokens=512,
    temperature=0.7,        # Balanced creativity
    top_p=0.9,
    do_sample=True,
    repetition_penalty=1.1,
)

outputs = model.generate(
    **inputs,
    max_new_tokens=256,
    temperature=0.3,        # More deterministic
    top_p=0.95,
    do_sample=True,
)

outputs = model.generate(
    **inputs,
    max_new_tokens=768,
    temperature=0.9,        # More creative
    top_p=0.9,
    do_sample=True,
)

# For limited GPU memory
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="convaiinnovations/fine_tuned_coder",
    max_seq_length=2048,
    load_in_4bit=True,     # 4-bit quantization
    dtype=None,
)

# Clear cache after generation
import torch
torch.cuda.empty_cache()

try:
    inputs = tokenizer(
        [coding_prompt.format(question, "")],
        return_tensors="pt",
        max_length=2048,
        truncation=True,
    ).to("cuda")
    
    outputs = model.generate(**inputs, max_new_tokens=512)
    answer = tokenizer.decode(outputs[0], skip_special_tokens=True)
    
except Exception as e:
    print(f"Error during generation: {e}")
    # Fallback or error handling

@misc{convai_fine_tuned_coder_2025,
  author = {Convai Innovations},
  title = {Fine-tuned Bilingual Coding Assistant: A Qwen3-0.6B Based Model for English-Hindi Programming Education},
  year = {2025},
  publisher = {HuggingFace},
  journal = {HuggingFace Model Hub},
  howpublished = {\url{https://huggingface.co/convaiinnovations/fine_tuned_coder}},
}

Copyright 2025 Convai Innovations

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.