Xerv-AI

MAXWELL

README

License: apache-2.0

1. Model Details

1.1 Overview

MAXWELL is a fine-tuned, specialized variant of the Qwen2.5-Math-1.5B-Instruct architecture. It is optimized for high-precision analytical reasoning, mathematical computation, and physics problem-solving. The model was trained using 4-bit quantization via the Unsloth framework and subsequently merged into a 16-bit format for deployment stability.

1.2 Core Specifications

Table with columns: Specification, Value
Specification	Value
Developer	Xerv-AI
Model Name	MAXWELL
Base Architecture	Qwen2.5-Math-1.5B-Instruct
Parameter Count	~1.5 Billion
Training Precision	4-bit (BitsAndBytes)
Deployment Precision	Merged FP16 (merged_16bit)
Max Context Length	4096 Tokens (via RoPE Scaling)
Training Iterations	6500 Checkpoints
Hardware Used	Dual Tesla T4 GPUs (16GB VRAM each)

2. Inference Architecture: STSS

MAXWELL is uniquely designed to operate within a custom inference framework defined as Systematic Temperature-Sweep Synthesis (STSS). This method replaces standard single-shot autoregressive generation with a two-phase meta-reasoning protocol to empirically reduce hallucination rates.

2.1 Phase I: Spectrum Generation

Instead of sampling at a fixed temperature, the framework forces the model to generate a set of candidate responses \mathcal{S} across a defined temperature grid G_\tau:

Low Entropy (T \in [0.1, 0.3]): Enforces high-probability token selection, isolating learned training priors and rigid formulaic structures.
High Entropy (T \in [0.7, 0.9]): Increases the probability distribution tail, forcing the exploration of alternative logical branches.

2.2 Phase II: Neural Aggregation

The model is re-prompted using the entire generated set \mathcal{S} as its context window. It acts as an aggregator function f_{agg} to synthesize the final output R_{final}: This aggregation is explicitly executed at T=0.1 to strictly enforce logical cross-referencing, calculation verification, and anomaly filtering based on empirical STEM constraints.

3. Empirical Performance Observations

Based on inference testing logs, the model exhibits the following data-driven characteristics:

Pattern-Recognition Override: In cognitive reflection tests (e.g., the "5 machines, 5 minutes" problem), MAXWELL maintains logical consistency across all temperature thresholds, successfully returning a deterministic "5 minutes" response even at T=0.9.
Triboelectric Physics Accuracy: Requires explicit anchoring prompts during aggregation to override common dataset biases regarding electrostatic charge polarities (e.g., explicitly defining Glass + Silk = Positive).
Zero-Shot Consensus: When presented with non-complex strings (e.g., "hi"), the STSS framework achieves 100% consensus across the spectrum, successfully bypassing the aggregation complexity to return a standardized string.

4. Limitations & Computational Overhead

4.1 Token Saturation

Because the STSS framework requires injecting five complete reasoning paths into the Phase II prompt, long-form calculus or multi-step proofs will trigger a context truncation limit. The max_seq_length must be initialized to a minimum of 4096 to support the required RoPE scaling.

4.2 Compute Multiplier

Standard LLM inference processes one generation pass. The MAXWELL STSS architecture requires six passes (five spectrum sweeps + one neural aggregation). This results in a 6\times multiplier on compute latency and token generation costs compared to standard baseline queries.

5. Official Implementation Code

To reproduce the optimal STSS inference loop without context truncation, utilize the following exact pipeline.

python

from unsloth import FastLanguageModelfrom transformers import TextStreamerimport torch# ConfigurationMODEL_NAME = "Xerv-AI/MAXWELL"MAX_CONTEXT = 4096 # Load Basemodel, tokenizer = FastLanguageModel.from_pretrained(    model_name = MODEL_NAME,    max_seq_length = MAX_CONTEXT,    load_in_4bit = True,)FastLanguageModel.for_inference(model)streamer = TextStreamer(tokenizer, skip_prompt=True)def maxwell_stss_inference(question):    # Phase I: Spectrum    temperatures = [0.1, 0.3, 0.5, 0.7, 0.9]    solution_pool = []        for t in temperatures:        inputs = tokenizer(            [f"<|im_start|>system\nYou are a highly analytical STEM assistant.<|im_end|>\n<|im_start|>user\n{question}<|im_end|>\n<|im_start|>assistant\n"],            return_tensors = "pt"        ).to("cuda")                output = model.generate(            **inputs,             max_new_tokens=450,             temperature=t,             use_cache=True        )        decoded = tokenizer.batch_decode(output)[0].split("<|im_start|>assistant\n")[-1].replace("<|im_end|>", "").strip()        solution_pool.append(f"[Temp {t}]: {decoded}")    # Phase II: Aggregation    agg_prompt = f"""<|im_start|>systemYou are a STEM Professor. Compare the 5 solutions below.Even if they all agree, you must:1. Explain WHY the consensus is correct.2. Formulate a final, perfect response using LaTeX.<|im_end|><|im_start|>userPROBLEM: {question}SOLUTIONS:{chr(10).join(solution_pool)}<|im_end|><|im_start|>assistant<reasoning>Based on the provided candidates, there is a 100% consensus. Here is the final verification:"""    final_inputs = tokenizer([agg_prompt], return_tensors="pt").to("cuda")        final_output = model.generate(        **final_inputs,         max_new_tokens=1024,         temperature=0.1,         streamer=streamer,        use_cache=True    )    return "Generation Complete."

Available on FriendliAI

Dedicated Endpoints

Run this model inference on single tenant GPU with unmatched speed and reliability at scale.

Learn more

Model Details

Model Provider

Xerv-AI

Model Tree

Base

unsloth/Qwen2.5-Math-1.5B-Instruct-bnb-4bit

Fine-tuned

this model

Input Modalities

Text

Output Modalities