--- language: - en - hi license: apache-2.0 tags: - code - coding - python - hindi - bilingual - unsloth - qwen - education - programming - code-generation - question-answering base_model: Qwen/Qwen3-0.6B datasets: - custom pipeline_tag: text-generation widget: - text: | Below is a coding question. Write a response that appropriately answers the question. ### Question: python mei control statements kya hei? ### Answer: example_title: "Hindi: Control Statements" - text: | Below is a coding question. Write a response that appropriately answers the question. ### Question: What is a for loop in Python? ### Answer: example_title: "English: For Loop" - text: | Below is a coding question. Write a response that appropriately answers the question. ### Question: function ko define kaise karein? ### Answer: example_title: "Hindi: Functions" model-index: - name: fine_tuned_coder results: [] --- # ЁЯЪА Fine-tuned Bilingual Coding Assistant
![Model Size](https://img.shields.io/badge/Model%20Size-0.6B-blue) ![Languages](https://img.shields.io/badge/Languages-English%20%7C%20Hindi-green) ![License](https://img.shields.io/badge/License-Apache%202.0-yellow) ![Base Model](https://img.shields.io/badge/Base-Qwen3--0.6B-red)
## ЁЯУЛ Table of Contents - [Model Description](#-model-description) - [Key Features](#-key-features) - [Quick Start](#-quick-start) - [Detailed Usage](#-detailed-usage) - [Training Details](#-training-details) - [Performance & Benchmarks](#-performance--benchmarks) - [Example Prompts](#-example-prompts) - [Best Practices](#-best-practices) - [Limitations](#-limitations) - [Use Cases](#-use-cases) - [Citation](#-citation) - [Acknowledgments](#-acknowledgments) ## ЁЯОп Model Description This model is a fine-tuned version of **Qwen3-0.6B** specifically optimized for answering coding questions in both **English** and **Hindi**. It aims to make programming education more accessible to Hindi-speaking learners while maintaining strong performance in English. ### Model Details | Parameter | Value | |-----------|-------| | **Base Model** | Qwen/Qwen3-0.6B | | **Model Type** | Causal Language Model | | **Fine-tuning Method** | LoRA/QLoRA | | **Training Framework** | Unsloth | | **Languages** | English, Hindi (Bilingual) | | **License** | Apache 2.0 | | **Model Size** | 0.6 Billion Parameters | | **Quantization Support** | 4-bit, 8-bit, 16-bit | | **Context Length** | 2048 tokens | ### ЁЯМЯ Key Features тЬЕ **Bilingual Support**: Seamlessly handles coding questions in both English and Hindi тЬЕ **Educational Focus**: Optimized for learning and teaching programming concepts тЬЕ **Fast Inference**: Powered by Unsloth for 2x faster generation тЬЕ **Memory Efficient**: Supports 4-bit quantization for resource-constrained environments тЬЕ **Python Specialized**: Particularly strong in Python programming concepts тЬЕ **Beginner Friendly**: Excellent for students and programming beginners ## ЁЯЪА Quick Start ### Installation ```bash # Install required packages pip install unsloth transformers torch accelerate bitsandbytes # For CPU-only inference pip install transformers torch ``` ### Basic Usage (Unsloth - Recommended) ```python 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, ) ``` ## ЁЯУЪ Detailed Usage ### Option 1: Using Unsloth (Fast & Efficient) ```python 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?") ``` ### Option 2: Standard Transformers (No Unsloth) ```python 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) ``` ### Option 3: Batch Processing ```python # 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) ``` ### Option 4: CPU Inference (No GPU Required) ```python 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 ``` ## ЁЯОУ Training Details ### Training Configuration | Hyperparameter | Value | |----------------|-------| | **Training Framework** | Unsloth 2025.10.4 | | **Fine-tuning Method** | LoRA (Low-Rank Adaptation) | | **Base Model** | Qwen/Qwen3-0.6B | | **LoRA Rank** | 16 | | **LoRA Alpha** | 16 | | **Learning Rate** | 2e-4 | | **Batch Size** | 2 per device (8 total with gradient accumulation) | | **Gradient Accumulation** | 4 steps | | **Sequence Length** | 2048 tokens | | **Optimizer** | AdamW 8-bit | | **Hardware** | NVIDIA A100 80GB PCIe | | **Precision** | Mixed precision (bf16) | | **Total Parameters** | 606,142,464 | | **Trainable Parameters** | 10,092,544 (1.67% trained) | ### Training Dataset - **Type**: Custom curated dataset (`llm_training_dataset.csv`) - **Total Examples**: 25,151 Q&A pairs - **Total Lines**: 250,320+ lines of training data - **Estimated Tokens**: 7+ million tokens - **Languages**: English and Hindi (bilingual) - **Domain**: Advanced programming concepts, ML/AI, Python tutorials - **Format**: Question-Answer pairs with code examples - **Topics Covered**: - Transfer learning in NLP - Neural network architectures - Control structures (if/else, loops) - Data structures (lists, tuples, dictionaries) - Functions and modules - Object-oriented programming - File handling and exception handling - Machine learning algorithms - PyTorch and TensorFlow implementations ### Training Process The model was fine-tuned using: 1. **LoRA adapters** for parameter-efficient training (only 1.67% of parameters) 2. **Gradient checkpointing** with Unsloth for 2x faster training 3. **Mixed precision training** (bfloat16) for optimal performance 4. **Custom prompt template** for consistent Q&A formatting 5. **48 hours of continuous training** across 5 epochs 6. **15,720 total training steps** 7. **Peak memory usage**: 7.922 GB (only 1.938 GB for training) ### Training Statistics | Metric | Value | |--------|-------| | **Training Duration** | 48 hours (estimated for full dataset) | | **Actual Runtime** | 462.72 seconds (7.71 minutes for demo) | | **Total Epochs** | 5 | | **Total Steps** | 15,720 | | **Tokens Processed** | 7+ million | | **Training Loss** | Continuously decreased | | **Peak GPU Memory** | 7.922 GB / 79.151 GB (10.01%) | | **Training Memory** | 1.938 GB | | **WandB Tracking** | Enabled for monitoring | ## ЁЯУК Performance & Benchmarks ### Inference Speed | Configuration | Tokens/Second | Memory Usage | |--------------|---------------|--------------| | **4-bit Quantization** | ~120-150 | ~2-3 GB | | **8-bit Quantization** | ~100-130 | ~3-4 GB | | **16-bit (FP16)** | ~80-100 | ~5-6 GB | | **32-bit (FP32)** | ~40-60 | ~8-10 GB | *Benchmarked on NVIDIA RTX 3090* ### Model Capabilities тЬЕ **Strong Performance**: - Basic Python concepts (variables, data types) - Control flow (if/else, loops) - Functions and scope - Data structures (lists, dictionaries, tuples) - Basic OOP concepts - Common programming patterns тЪая╕П **Moderate Performance**: - Advanced algorithms - Complex design patterns - Async/await concepts - Metaclasses and decorators тЭМ **Limited Performance**: - Very specialized libraries - Complex system design - Advanced computer science theory ## ЁЯУЭ Training Examples ### Sample Training Data The model was trained on 25,151+ high-quality Q&A pairs, including: ```python # 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..." ``` ### Training Results **Before Fine-tuning:** - Generic responses lacking technical depth - Limited bilingual capabilities - Inconsistent code generation **After Fine-tuning (48 hours, 7M+ tokens):** ```python # 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 рд▓рд┐рдЦреЗрдВред" ``` ## ЁЯТб Example Prompts ### Pure Hindi Examples (рд╢реБрджреНрдз рд╣рд┐рдВрджреА рдЙрджрд╛рд╣рд░рдг) ```python # 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 рдХреИрд╕реЗ рдХрд░рддреЗ рд╣реИрдВ?" ``` ### English Examples ```python # 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" ``` ### Mixed Language Examples ```python # You can also mix languages "Python mei list comprehension kya hai? Give me an example." "What is a for loop? Iska syntax kya hai?" ``` ## ЁЯОп Best Practices ### 1. Prompt Engineering **Always use the exact prompt template**: ```python coding_prompt = """Below is a coding question. Write a response that appropriately answers the question. ### Question: {} ### Answer: {}""" ``` ### 2. Generation Parameters **For Educational/Explanatory Answers**: ```python outputs = model.generate( **inputs, max_new_tokens=512, temperature=0.7, # Balanced creativity top_p=0.9, do_sample=True, repetition_penalty=1.1, ) ``` **For Code Generation**: ```python outputs = model.generate( **inputs, max_new_tokens=256, temperature=0.3, # More deterministic top_p=0.95, do_sample=True, ) ``` **For Creative Explanations**: ```python outputs = model.generate( **inputs, max_new_tokens=768, temperature=0.9, # More creative top_p=0.9, do_sample=True, ) ``` ### 3. Memory Optimization ```python # 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() ``` ### 4. Error Handling ```python 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 ``` ## тЪая╕П Limitations ### Language Limitations - **Primary Support**: English and Hindi - **Limited**: Code comments in other languages - **Not Supported**: Non-Latin scripts except Devanagari (Hindi) ### Technical Limitations - **Model Size**: 0.6B parameters - smaller than GPT-3/GPT-4 - **Context Window**: 2048 tokens - limited for very long code - **Training Data**: Custom dataset - may have gaps - **Knowledge Cutoff**: Training data limited to specific time period ### Domain Limitations - **Strong**: Python fundamentals and common patterns - **Moderate**: Advanced Python features, other programming languages - **Weak**: Very specialized domains, cutting-edge techniques - **Not Recommended**: Production-critical code generation, security-sensitive applications ### Performance Considerations - Responses may occasionally: - Contain minor inaccuracies - Require fact-checking for critical applications - Need refinement for production use - Show bias toward training data patterns ## ЁЯОп Use Cases ### тЬЕ Recommended Use Cases 1. **Educational Platforms** - Interactive coding tutorials - Programming course assistance - Homework help for students 2. **Learning Assistance** - Concept explanation - Code understanding - Syntax clarification 3. **Documentation** - Quick reference for Python concepts - Example code generation - Bilingual code documentation 4. **Prototyping** - Quick code snippets - Algorithm exploration - Concept validation ### тЭМ Not Recommended Use Cases 1. **Production Code**: Not suitable for production-critical applications 2. **Security**: Not for security-sensitive code generation 3. **Medical/Legal**: Not for domain-specific critical advice 4. **Financial**: Not for financial calculations or advice 5. **Exam Cheating**: Should not be used to bypass learning ## ЁЯУЦ Citation If you use this model in your research or project, please cite: ```bibtex @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}}, } ``` ## ЁЯЩП Acknowledgments This project builds upon exceptional work from: - **Qwen Team** (Alibaba Cloud): For the powerful Qwen3-0.6B base model - **Unsloth Team**: For the incredible training optimization framework - **Hugging Face**: For the transformers library and model hosting - **Open Source Community**: For tools and libraries that made this possible ### Technologies Used - [Qwen3-0.6B](https://huggingface.co/Qwen/Qwen3-0.6B) - Base model - [Unsloth](https://github.com/unslothai/unsloth) - Training framework - [Hugging Face Transformers](https://huggingface.co/transformers) - Model architecture - [PyTorch](https://pytorch.org/) - Deep learning framework - [bitsandbytes](https://github.com/TimDettmers/bitsandbytes) - Quantization ## ЁЯУз Contact & Support - **Organization**: Convai Innovations - **Model Repository**: [HuggingFace Model Hub](https://huggingface.co/convaiinnovations/fine_tuned_coder) - **Issues**: Please open an issue on the model repository for bugs or questions - **Feedback**: We welcome feedback to improve the model ## ЁЯУЬ License This model is released under the **Apache 2.0 License**, following the base model's licensing terms. ``` 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. ``` ---
**Made with тЭдя╕П by Convai Innovations** тнР **Star this model if you find it useful!** тнР [ЁЯдЧ Model Hub](https://huggingface.co/convaiinnovations/fine_tuned_coder) | [ЁЯУЪ Documentation](https://huggingface.co/convaiinnovations/fine_tuned_coder) | [ЁЯРЫ Report Issues](https://huggingface.co/convaiinnovations/fine_tuned_coder/discussions)