Fyodor-Q3-8B-Instruct

<div align="center">

🤖 Fyodor-Q3-8B-Instruct

The "God Mode" Agentic Coder

</div>

---

📝 Model Overview

Fyodor-Q3-8B-Instruct is a high-fidelity instruction-tuned model designed for Agentic Reasoning and Robust Code Generation.

Unlike standard fine-tunes, Fyodor was trained using a "God Mode" LoRA configuration (Rank 128) on a curated curriculum of 60% Coding, 20% Instruction Following, and 20% Reasoning/Tool use. It excels at planning before coding, making it suitable for complex software engineering tasks.

• Base Model: Qwen/Qwen3-8B
• Developer: Kiy-K
• Language(s): Python, JavaScript, TypeScript, C++, Rust, Go, and 80+ programming languages
• Architecture: Dense Transformer (32k context window)
• Training Precision: bfloat16
• Training Framework: Unsloth + PyTorch

---

🧠 Training Strategy

Fyodor-Q3-8B utilizes a high-rank adaptation strategy to enable deep knowledge retention without the memory footprint of a full fine-tune.

The "Golden Ratio" Data Mix

The model was trained on a strategic blend of datasets to balance syntax proficiency with logic:

Hyperparameters ("God Mode" Config)

We utilized a significantly higher rank than standard LoRA implementations to allow the model to learn complex reasoning patterns.

{
    "lora_r": 128,          # High capacity adaptation
    "lora_alpha": 256,      # Strong update scaling (2x rank)
    "lora_dropout": 0.05,
    "target_modules": ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    "batch_size": 4,
    "gradient_accumulation_steps": 8,  # Effective batch: 32
    "learning_rate": 2e-4,
    "max_seq_length": 4096,
    "warmup_steps": 100,
    "num_train_epochs": 3,
    "scheduler": "linear",
    "optimizer": "adamw_8bit"
}

---

🚀 Usage

Installation

pip install transformers torch accelerate

Basic Inference

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# Load model and tokenizer
model_name = "Kiy-K/Fyodor-Q3-8B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

# Prepare prompt
prompt = """Write a Python function that implements binary search with detailed comments."""

messages = [
    {"role": "system", "content": "You are Fyodor, an expert programming assistant. You write clean, efficient code with clear explanations."},
    {"role": "user", "content": prompt}
]

# Generate
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

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

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

Advanced Usage with Streaming

from transformers import TextIteratorStreamer
from threading import Thread

streamer = TextIteratorStreamer(tokenizer, skip_special_tokens=True)

generation_kwargs = dict(
    inputs=inputs.input_ids,
    streamer=streamer,
    max_new_tokens=1024,
    temperature=0.7,
    top_p=0.9,
    do_sample=True
)

thread = Thread(target=model.generate, kwargs=generation_kwargs)
thread.start()

print("Assistant: ", end="")
for new_text in streamer:
    print(new_text, end="", flush=True)
print()

Function Calling Example

prompt = """I need to create a REST API endpoint that fetches user data. 
Available tools:
- fetch_user(user_id: int) -> dict
- validate_token(token: str) -> bool

Write the endpoint handler."""

messages = [
    {"role": "system", "content": "You are an expert at API development and tool orchestration."},
    {"role": "user", "content": prompt}
]

# Apply chat template and generate
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

outputs = model.generate(
    **inputs,
    max_new_tokens=1024,
    temperature=0.7,
    do_sample=True
)

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

Quantization (4-bit)

from transformers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4"
)

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=quantization_config,
    device_map="auto"
)

---

🎯 Key Capabilities

• Multi-Language Proficiency: Python, JavaScript, TypeScript, C++, Rust, Go, Java, and more
• Agentic Reasoning: Plans multi-step solutions before implementation
• Function Calling: Native understanding of tool use and API integration
• Code Review: Can analyze and critique existing code with constructive feedback
• Documentation: Generates comprehensive docstrings and comments
• Debugging: Identifies and fixes bugs with clear explanations

---

📊 Prompt Format

Fyodor uses the ChatML format from Qwen3:

<|im_start|>system
You are Fyodor, an expert programming assistant.<|im_end|>
<|im_start|>user
{your prompt here}<|im_end|>
<|im_start|>assistant

---

⚡ Performance Tips

1. Temperature: Use 0.1-0.3 for precise code generation, 0.7-0.9 for creative solutions
2. Context: Provide clear requirements and constraints upfront
3. System Prompt: Customize the system message for domain-specific tasks
4. Max Tokens: Allow 512-2048 tokens for complex implementations
5. Top-p: Keep at 0.9 for balanced diversity and coherence

---

🔧 Hardware Requirements

---

🏆 Official Benchmark Results

Code Generation Performance

Fyodor v1 (8B) demonstrates state-of-the-art efficiency, significantly outperforming models with comparable parameter counts.

> Evaluated using BigCode Evaluation Harness (Greedy Decoding, T=0.2)

General Reasoning & Knowledge

Current evaluation shows the model retains "Senior Dev" knowledge but experiences reduced mathematical precision due to the lacking presence of mathematics datasets

> Evaluated using LM Evaluation Harness on NVIDIA A100 GPUs

Key Takeaways:

• Knowledge & Reasoning: Minimal degradation from base model, excellent for software engineering tasks
• Common Sense: Strong performance in contextual understanding
• Mathematical Reasoning: Q3 quantization significantly impacts pure arithmetic tasks, but practical coding logic remains strong

Tool Use

---

🤝 Contributing

Found a bug or have a suggestion? Open an issue or submit a PR!

---

📄 License

This model is released under the Apache 2.0 license, inheriting from the Qwen3 base model.

---

🙏 Acknowledgments

• Qwen Team for the exceptional Qwen3 base model
• Unsloth for efficient training infrastructure
• HuggingFace for dataset hosting and model hub
• Team Mradermacher for GGUF conversions and local hosting accessibilities

---

📮 Citation

@misc{fyodor-q3-8b-instruct,
  author = {Kiy-K},
  title = {Fyodor-Q3-8B-Instruct: God Mode Agentic Coder},
  year = {2025},
  publisher = {HuggingFace},
  howpublished = {\url{https://huggingface.co/Kiy-K/Fyodor-Q3-8B-Instruct}}
}

---

<div align="center">

Made with ❤️ by Kiy-K | Powered by Qwen3

</div>