Update README.md

README.md

@@ -1,15 +1,21 @@
-Here is a complete, professional, and well-structured Hugging Face model card (README.md) designed specifically for WithinUsAI/Gemini3.5-Code.Reasoner-2b-Distilled.
-You can copy and paste the raw Markdown block below directly into your repository’s README.md file.
 ---
 license: apache-2.0
 tags:
 - text-generation
 - code
 - reasoning
+- codegemma
 - gemma
 - safe-tensors
-- text-generation-inference
-base_model: google/gemma-2-2b
+- distillation
+- synthetic-dataset
+base_model: google/codegemma-1.1-2b
+datasets:
+- WithinUsAI/GeminiPro3.2_max_distill_god_seed_25k
+- WithinUsAI/gemini_3.5_flash_distilled_25k
+- WithinUsAI/Gemini_3.2_Pro_Distilled
+- WithinUsAI/codegemma_gemini_pro_32_distilled_25k
+- WithinUsAI/DEEPMIND_Alpha_Distilled
 pipeline_tag: text-generation
 library_name: transformers
 language:
@@ -18,47 +24,43 @@ language:
 
 # Gemini3.5-Code.Reasoner-2b-Distilled
 
-Gemini3.5-Code.Reasoner-2b-Distilled is a lightweight, high-performance reasoning model designed for code generation, debugging, and complex logical workflows. Built on top of the robust **Gemma 2 2B (`GemmaForCausalLM`)** architecture, this model integrates a specialized low-rank adaptation (LoRA) layer to embed advanced chain-of-thought (CoT) reasoning paths.
+Gemini3.5-Code.Reasoner-2b-Distilled is a highly efficient, reasoning-dense model tailored for advanced coding tasks, algorithmic problem-solving, and logical chain-of-thought workflows. 
 
-The model is distilled from larger frontier reasoning pipelines, bringing complex multi-step code planning capabilities into an efficient 2-billion parameter footprint that can easily run locally or on edge devices.
+By applying a specialized Low-Rank Adaptation (LoRA) layer over **CodeGemma 1.1 2B**, this model infuses frontier-level reasoning mechanics into a compact, 2-billion parameter architecture. It bridges the gap between massive cloud-hosted models and local, edge-compute hardware.
 
 ## Model Details
 
 - **Developed by:** WithinUsAI
-- **Model Type:** Causal Language Model (Fine-tuned / Distilled)
-- **Base Model:** `google/gemma-2-2b`
-- **Architecture:** GemmaForCausalLM with LoRA Adapters
-- **Language(s):** English (Primary), Code languages (Python, JavaScript, C++, Go, etc.)
+- **Model Type:** Causal Language Model (Fine-tuned / Knowledge Distilled)
+- **Base Model:** [google/codegemma-1.1-2b](https://huggingface.co/google/codegemma-1.1-2b)
+- **Architecture:** GemmaForCausalLM (CodeGemma variant) + LoRA Adapters
 - **License:** Apache 2.0
 
-## Intended Uses & Limitations
+## Training & Dataset Recipe
 
-### Ideal Use Cases
-- **Local Code Assistance:** Fast autocompletion, code translation, and docstring generation on consumer-grade hardware.
-- **Reasoning-focused Scripting:** Handling multi-step software logic tasks where the model must think step-by-step before writing out a block of code.
-- **Mobile & Edge Deployments:** Thanks to its 2B parameter scale, it is optimal for low-latency setups.
+The "Reasoner" capabilities of this model are distilled from a multi-source synthetic pipeline focusing on complex coding logic, algorithmic optimization, and step-by-step thinking patterns. The training mixture leverages approximately 100K+ high-quality reasoning examples across five core datasets:
 
-### Limitations
-- **Parameter Constraints:** Being a 2B model, it may struggle with highly architectural software design patterns compared to massive 70B+ or closed-source models.
-- **Hallucinations:** Like all LLMs, it can occasionally generate syntax errors or deprecations. Always test generated code in a secure sandboxed environment.
+| Dataset Name | Source / Focus | Approx. Size |
+| :--- | :--- | :--- |
+| `WithinUsAI/GeminiPro3.2_max_distill_god_seed_25k` | High-quality frontier seed prompts for code generation. | ~25k samples |
+| `WithinUsAI/gemini_3.5_flash_distilled_25k` | Fast, iterative logical steps and multi-turn debugging data. | ~25k samples |
+| `WithinUsAI/Gemini_3.2_Pro_Distilled` | Heavy math logic, structural coding, and system design patterns. | Premium corpus |
+| `WithinUsAI/codegemma_gemini_pro_32_distilled_25k` | Target-aligned distillation data optimized for the CodeGemma vocabulary. | ~25k samples |
+| `WithinUsAI/DEEPMIND_Alpha_Distilled` | Deep algorithmic competitive programming and math reasoning. | Premium corpus |
 
-## Quickstart Guide
-
-### Using Transformers Pipeline
+## Intended Use
 
-```python
-from transformers import pipeline
+- **Local Code Assistants:** Ideal for IDE plugins requiring fast, low-latency code completion and instruction following.
+- **Logical Chain-of-Thought:** Designed to output its reasoning process before writing the final code block, minimizing syntax and logical errors.
+- **Resource-Constrained Environments:** Can easily be deployed on mobile devices, single-GPU setups, or local laptops using frameworks like `vLLM`, `Ollama`, or `SGLang`.
 
-pipe = pipeline("text-generation", model="WithinUsAI/Gemini3.5-Code.Reasoner-2b-Distilled", device_map="auto")
+## Quickstart Guide
 
-prompt = """<bos>Answer the following coding problem by thinking step-by-step:
-Write a Python function to find the longest palindromic substring in a string.
-"""
+### Inference with Hugging Face Transformers
 
-outputs = pipe(prompt, max_new_tokens=512, temperature=0.3)
-print(outputs[0]["generated_text"])
+Because CodeGemma utilizes specialized tokens for coding workflows, it's recommended to structure your prompts cleanly to prompt the model's inner chain-of-thought.
 
-Direct Model Load (AutoModelForCausalLM)
+```python
 from transformers import AutoTokenizer, AutoModelForCausalLM
 import torch
 
@@ -71,31 +73,12 @@ model = AutoModelForCausalLM.from_pretrained(
     device_map="auto"
 )
 
-inputs = tokenizer("<bos>Write a quick bash script to parse logs for 404 errors.", return_tensors="pt").to("cuda")
-outputs = model.generate(**inputs, max_new_tokens=256)
-print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+# Prompt the model to think step-by-step before delivering code
+prompt = """<bos>Analyze the problem and think step-by-step before writing any code.
+Problem: Write a Python generator function that yields the Fibonacci sequence up to n elements.
+Answer:"""
 
-High-Performance Deployment via vLLM
-For production setups or fast local servers, you can serve the model using vLLM:
-# Install vLLM from pip
-pip install vllm
-
-# Start the OpenAI-compatible vLLM server
-vllm serve "WithinUsAI/Gemini3.5-Code.Reasoner-2b-Distilled"
-
-You can then query it via curl:
-curl -X POST "http://localhost:8000/v1/completions" \
-	-H "Content-Type: application/json" \
-	--data '{
-		"model": "WithinUsAI/Gemini3.5-Code.Reasoner-2b-Distilled",
-		"prompt": "<bos>Explain the time complexity of QuickSort.",
-		"max_tokens": 512,
-		"temperature": 0.2
-	}'
-
-Repository Structure
-The weight distribution includes both the base model layers and structural adapter targets for easy loading:
- * model.safetensors (~5.01 GB) - The primary model weights.
- * adapter_model.safetensors (~49.9 MB) & adapter_config.json - LoRA configuration fine-tuned for code extraction and reasoning properties.
- * tokenizer.json & tokenizer_config.json - Tokenizer structures mapped to the base Gemma profile.
----
+inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
+outputs = model.generate(**inputs, max_new_tokens=512, temperature=0.2)
+
+print(tokenizer.decode(outputs[0], skip_special_tokens=True))