---

1. Model Introduction

We introduce Alpie-Core, our first-generation reasoning model. It is a 32B-parameter system built on the DeepSeek-32B family and fine-tuned in 4-bit precision. By using quantization techniques like QLoRA, combined with parameter-efficient fine-tuning methods such as LoRA, and leveraging synthetic dataset distillation, Alpie-Core achieves high efficiency in reasoning, mathematics, and coding tasks. It operates with significantly lower computational and memory costs. Even with strong quantization, the model consistently outperforms 16-bit and 32-bit baselines. It achieves results such as 81.28% on MMLU, 92.75% on GSM8K, and 57.8% on SWE-Bench Verified. Notably, Alpie-Core can be trained using just 8 NVIDIA Hopper GPUs, requiring only 25% of the memory used by full-precision models. This repository covers the model's architecture, quantization strategy, training methods, benchmark results, technical innovations, use cases, safety and alignment features, limitations, and roadmap.

Key Features

• 4-bit Quantization: NF4 quantization with double quantization for strong compression.
• Parameter-Efficient Training: LoRA/QLoRA techniques allow fine-tuning with low resource needs.
• Extended Context: 65K token context length for managing large inputs and conversations.
• Streaming Support: Real-time, token-level response generation.
• Resource Optimized: Needs only about 16GB VRAM for deployment on standard hardware.

Model Highlights

• First 4-bit reasoning model from India and one of the first globally at a 32B scale.
• Trained on just 8 NVIDIA Hopper GPUs showing efficient training methods.
• Carbon footprint: Just 298-835 kg CO₂e, much lower than full-precision options.
• Improved content access: Offers balanced responses to geopolitically sensitive topics.

2. Model Summary

Base Architecture	DeepSeek-R1-Distill-Qwen-32B
Total Parameters	32B
Quantization	4-bit NF4 with double quantization
Training Method	LoRA/QLoRA fine-tuning
Memory Footprint	~16GB (75% reduction vs FP16)
Context Length	65K tokens
Max Output Length	16,384 tokens
Training Hardware	8× NVIDIA Hopper GPUs
License	Apache 2.0
Specialization	Reasoning, Mathematics, Coding, Science

3. Evaluation Results

SWE-Bench Verified Performance

Humanity's Last Exam Leaderboard Performance

AIME (Advanced Mathematics)

BBH (Big-Bench Hard)

GSM8K (Grade School Math)

4. Deployment

Our model checkpoints are stored in 4-bit quantized format, you can find it on Hugging Face.

Currently, it is recommended to run Alpie-Core on the following inference engines:

• vLLM

Deployment examples for vLLM can be found in this Model Deployment Guide.

---

5. Model Usage

Non-Streaming Inference

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

# Load LoRA adapter configuration to find the base model
peft_model_id = "169Pi/Alpie-Core"
config = PeftConfig.from_pretrained(peft_model_id)

# Load the base model
base_model = AutoModelForCausalLM.from_pretrained(
    config.base_model_name_or_path,
    torch_dtype=torch.float16,
    device_map="auto"
)

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(config.base_model_name_or_path)

# Load LoRA weights
model = PeftModel.from_pretrained(base_model, peft_model_id)

# Ensure evaluation mode
model.eval()

# Sample inference
prompt = "Solve the Riemann Hypothesis and provide a final answer?"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model.generate(**inputs, max_new_tokens=1000)
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)

print("Response:\n", response)

Streaming Inference

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

# Load LoRA adapter configuration to find the base model
peft_model_id = "169Pi/Alpie-Core"
config = PeftConfig.from_pretrained(peft_model_id)

# Load the base model
base_model = AutoModelForCausalLM.from_pretrained(
    config.base_model_name_or_path,
    torch_dtype=torch.float16,
    device_map="auto"
)

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(config.base_model_name_or_path)

# Load LoRA weights
model = PeftModel.from_pretrained(base_model, peft_model_id)

# Ensure evaluation mode
model.eval()

# Initialize streamer
streamer = TextStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)

# Sample streaming inference
prompt = "Solve the Riemann Hypothesis and provide a final answer?"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

print("Streaming Response:")
with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=1000,
        streamer=streamer,
        do_sample=True,
        temperature=0.7,
        top_p=0.9
    )

---

6. License

Apache 2.0 License – Permissive, allowing free use, modification, and distribution for both research and commercial purposes.

---

7. Citation

@misc{169pi2025alpiecore,
  title     = {Alpie-Core: A 4-Bit Quantized Reasoning Model from India that Outperforms Full-Precision Models},
  author    = {169Pi AI},
  year      = {2025},
  url       = {https://huggingface.co/169Pi/Alpie-Core}
}

---

8. Acknowledgements / Credits

We want to thank DeepSeek for their original model, which was the basis for this work. Our team fine tuned the model and used 4-bit quantization. This resulted in better efficiency and accuracy for our tasks. This model respects the contributions of the original authors and aims to provide a safe, high-performance solution for reasoning and inference.

We also appreciate the Hugging Face ecosystem (Transformers, PEFT, vLLM, bitsandbytes), the open-source community datasets (MMLU, GSM8K, SWE-Bench, and others), and the help from various cloud providers. Finally, we recognize the broader AI research community and companies whose innovations and insights keep inspiring our work.

---

9. Contributing

We welcome contributions from the community! Whether you're fixing bugs, improving documentation, adding new features, or sharing insights, your contributions help make Alpie-Core better for everyone.

How to Contribute

Reporting Issues

If you encounter any bugs, have feature requests, or face deployment challenges:

1. Check existing issues to avoid duplicates
2. Open a new issue with a clear title and description
3. Include the following information:
   • Environment details (GPU, OS, Python version)
   • Steps to reproduce the issue
   • Expected vs. actual behavior
   • Error messages or logs (if applicable)
   • Code snippets demonstrating the issue

Submitting Pull Requests

We follow a standard GitHub workflow for contributions:

1. Fork the repository to your GitHub account

2. Clone your fork locally:

   git clone https://github.com/YOUR_USERNAME/Alpie-Core.git
   cd Alpie-Core

3. Create a new branch for your feature or fix:

   git checkout -b feature/your-feature-name
   # or
   git checkout -b fix/issue-description

4. Make your changes:

   • Write clean, documented code
   • Follow existing code style and conventions
   • Add comments where necessary
   • Update documentation if needed

5. Test your changes thoroughly:

   • Ensure existing functionality isn't broken
   • Add tests for new features when applicable
   • Verify on your hardware setup

6. Commit your changes with clear, descriptive messages:

   git add .
   git commit -m "Add: Brief description of your changes"

7. Push to your fork:

   git push origin feature/your-feature-name

8. Open a Pull Request:

   • Go to the original repository
   • Click "New Pull Request"
   • Select your fork and branch
   • Provide a clear description of your changes
   • Reference any related issues (e.g., "Fixes #123")

Contribution Guidelines

• Code Quality: Follow PEP 8 for Python code
• Documentation: Update README or docs for any user-facing changes
• Commit Messages: Use clear, descriptive commit messages
• Testing: Test your changes before submitting
• Scope: Keep PRs focused on a single feature or fix
• Communication: Be responsive to feedback and questions

🎯 Areas Where We Need Help

• Performance Optimization: Improving inference speed and memory efficiency
• Documentation: Tutorials, examples, and use case guides
• Testing: Expanding test coverage and benchmark evaluations
• Deployment: Support for additional inference engines and platforms
• Bug Fixes: Addressing issues reported by the community
• Examples: Real-world application examples and notebooks

🌟 Recognition

Contributors will be acknowledged in our:

• README Contributors section
• Release notes
• Technical reports (for significant contributions)

Code of Conduct

We are committed to providing a welcoming and inclusive environment. Please:

• Be respectful and constructive in all interactions
• Focus on what is best for the community
• Show empathy towards other community members
• Accept constructive criticism gracefully

Questions?

If you have questions about contributing, feel free to:

• Open a discussion in the Issues tab
• Reach out to us at contact@169pi.com
• Connect with us on LinkedIn or X

---

Thank you for helping make Alpie-Core better!