🌌 Quasar-1-0.8B Official Release

🚀 Model Overview

Quasar-1-0.8B is an ultra-lightweight, high-efficiency generative language model optimized for local computation pipelines. Featuring a dense 800-million parameter setup, Quasar-1 balances compact VRAM footprints with specialized native Chain-of-Thought (CoT) tracking capabilities to excel at arithmetic execution patterns without requiring compute-heavy infrastructure layers.

📊 Evaluation Benchmarks

All metrics represent raw, clean evaluation runs executed locally via standard automated verification harnesses. To ensure rigorous tracking metrics, numbers map strictly to verified computational checks.

Note: A 19.70% score on GPQA Diamond represents an authentic, scientifically transparent validation layer for a sub-1B architecture architecture, illustrating real-world resistance profiles against complex logical distractor loops.

💻 Hardware Execution Profile

Operational baselines and token throughput bounds were structurally verified inside our active laboratory infrastructure using accessible hardware configurations to ensure open-source reproducibility:

• Operating Substrate: Microsoft Windows 10 Pro (64-bit)
• Central Processor Unit: Intel(R) Pentium(R) CPU G4560 @ 3.50GHz
• Graphics Processing Unit: 1x NVIDIA GeForce GTX 1050 Ti
• Execution Pipeline Target: PyTorch 2.6.0 + CUDA 12.4 / Transformers 5.10.2
• Compute Precision: float16 half-precision layers

⚙️ Quickstart Pipeline Hook

You can directly hook into and prompt Quasar-1-0.8B utilizing the native Hugging Face pipeline architecture. Ensure your active python environment is updated:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "Axiom-AI/Quasar-1-0.8B"

print(f"[STATUS] Synchronizing tracking matrices for {model_id}...")

# Initialize token configuration layer
tokenizer = AutoTokenizer.from_pretrained(model_id)

# Load model weights efficiently onto available hardware VRAM mapping
model = AutoModelForCausalLM.from_pretrained(
    model_id, 
    torch_dtype=torch.float16, 
    device_map="auto"
)

# Construct input reasoning task array
prompt = "Solve step-by-step: A logic gate array processes 120 cycles/sec. If an operation takes 3 cycles, how many run in 5 seconds?"
inputs = tokenizer(prompt, return_tensors="pt").to("cuda" if torch.cuda.is_available() else "cpu")

# Initialize tensor execution stream pass
with torch.no_grad():
    outputs = model.generate(
        **inputs, 
        max_new_tokens=2048, 
        temperature=0.4,
        do_sample=True,
        eos_token_id=tokenizer.eos_token_id
    )

print("\n=== Generation Output ===")
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

🛡️ Use Cases & Constraints

Intended Domain: Local testing environments, low-latency text-generation parsing, specific algorithmic problem solving, and lightweight embedded helper automation scripts.

Technical Boundaries: As an 800M architecture parameter deployment, deep, heavily recursive abstraction loops may encounter coherence performance degradation bounds relative to massive foundational networks (7B+ scale parameter layers).