pbhappliedsystems/qwen-2.5-32B-instruct-gguf-F16

Qwen2.5-32B-Instruct · GGUF F16

Converted and evaluated by [PBH Applied Systems, LLC](https://pbhappliedsystems.com) — Applied AI/ML Consulting · LLM Optimization & Deployment · Quantized AI Infrastructure

🔬 This repository is part of a production-oriented evaluation series. Every model published under `pbhappliedsystems` has been independently evaluated using quant_eval v7.22.21/v7.22.22 — a behavioral evaluation harness developed by PBH Applied Systems. Scores measure real agent-adjacent task performance across structured output, tool dispatch, multi-turn state retention, and multi-step planning families — not perplexity or benchmark leaderboard proxies.

📌 This is the full-precision F16 baseline repository. The evaluated quantized variant is published separately: `Q4_K_M`. This card documents reference behavior. The quantized card shows how Q4KM compression impacts behavioral fidelity — on this model, no family differs significantly from F16 (McNemar p < 0.05: 0 of 8).

Try the Live AI Agent Demo & Compare Models

Two complementary interfaces, both free:

1. Quick Demo — Single Model Testing

**Launch the PBH Applied Systems AI Agent Demo →**

Free · 3 example queries per agent type · No account required · No document upload

Test this model (or others) against three agent workflow templates:

• —Reasoning & Analysis — Chain-of-thought decomposition and structured problem-solving Example queries: Should a startup build on cloud LLMs or self-host quantized models? · Analyze the trade-offs between model quantization and inference latency. · What are the cost implications of running 32B parameter models on edge devices?

• —Document Intelligence — Long-context information extraction and Q&A Example queries: Extract key clauses from a contract and summarize legal risks. · Analyze a research paper and identify the novel contributions. · Compare market analysis reports and highlight strategic differences.

• —Code & Automation — API scaffolding, data transformation, and task completion Example queries: Build a REST API endpoint for user authentication and include rate limiting. · Transform CSV data into a production-ready database schema. · Write a Python script to validate and clean messy customer records.

Every query runs on private GPU infrastructure — your prompts, reasoning traces, and outputs never leave the system and are never sent to Frontier model providers or cloud vendors. This matters for organizations with sensitive data, compliance requirements, or internal knowledge that cannot leave the building.

2. Model Comparison Arena — Side-by-Side Evaluation

**Launch the quant_eval Agent Arena Space →**

Compare two models in real-time across all three agent types.

The Agent Arena lets you:

• —Select any two evaluated models (F16 or quantized variants) and test them side-by-side on the same queries
• —View execution traces for both agents, showing chain-of-thought reasoning and tool dispatch
• —Check the Model Leaderboard — a ranked table of all evaluated models with scores across four behavioral dimensions: Task Completion, Reasoning, Coherence, Instruction Following
• —Read the Methodology tab — explanation of quant_eval, the 8 test families, and how to request a full evaluation report for models not yet in the series

Why compare in the Arena:

The demo shows what this model can do. The Arena shows how this model compares to others. If you're deciding between F16 and Q4KM, or between different model sizes in the series, run the same query in the Arena with both selected. You'll see the exact differences in reasoning quality, tool dispatch, and output coherence — not benchmark scores, but real agent behavior.

Evaluation-backed leaderboard: Every score in the Arena comes from quant_eval runs published to Zenodo (DOI `10.5281/zenodo.22009419`). The numbers are not opinionated; they're measured.

Model Description

This repository contains the full-precision F16 GGUF of `Qwen/Qwen2.5-32B-Instruct`, a 32-billion parameter instruction-tuned model developed by Alibaba Qwen Team (2024). Qwen2.5-32B-Instruct features a 32,768-token context window and exceptional multilingual instruction-following capability.

The F16 format preserves all original float16 weights without quantization. In the PBH Applied Systems evaluation pipeline, the F16 variant serves as the reference baseline: it is evaluated first, then the quantized variant is evaluated against the same fixture set, enabling direct measurement of quantization impact on behavioral fidelity.

For production deployments, the quantized variant (Q4KM) is typically the better choice — delivering 70% footprint reduction with negligible behavioral loss. The F16 is the right choice only when maximum output fidelity is non-negotiable and hardware is plentiful.

Key Characteristics

• —Parameters: 32B
• —Format: GGUF F16 (full precision)
• —File size: 65.54 GB
• —SHA256: 02e264f0273624b39b0650f8c0583c6d04c320c777780ca5be839999912adf3c
• —Context window: 32,768 tokens
• —Minimum VRAM (GPU inference): ~66 GB
• —Recommended GPU tier: A100 80GB (eval hardware) · H100 80GB · 2× RTX 6000 Ada (48 GB each)
• —Inference speed (eval hardware): avg 18.73 tokens/sec on Modal A100-80GB
• —Multilingual: English, Chinese, and other languages

PBH Applied Systems Evaluation — quant_eval v7.22.22

Evaluation conducted by PBH Applied Systems, LLC using quant_eval v7.22.22 Run ID: Qwen2.5_32B_Instruct_20260815_081051 · Fixtures: v7.22.22 (SHA256: 0673b5e5...) Evaluation date: August 15, 2026 · Seed: unsupported (Modal); topk=40, topp=0.95 · Hardware: Modal GPU cluster · Published: August 15, 2026

Evaluation Data Published to Zenodo

All evaluation artifacts are published under the quant_eval Public Corpus (DOI: `10.5281/zenodo.22009419`):

• —Run Provenance (D4): `10.5281/zenodo.22010462` — Selected run manifest and rollup fields, artifact SHA-256 hashes, runner and decoding configurations
• —Golden Oracle Fixtures (D3): `10.5281/zenodo.22010278` — Test case specifications and fixture version crosswalk
• —Family Pass Rates (D6): `10.5281/zenodo.22010623` — Aggregate pass rates per family, both runners, 95% Wilson confidence intervals
• —Per-Case Behavioral Results (D1): `10.5281/zenodo.22009799` — 19,200 per-case rows, both precisions, all signals, case-level pass/fail
• —Throughput Telemetry (D2): `10.5281/zenodo.22009987` — Per-call generation metrics, wall-time, token counts
• —Efficiency & Footprint (D7): `10.5281/zenodo.22010723` — Stored artifact size, compression ratio, tokens/sec, observed wall-time ratios with hardware scope

Evaluation Contract: canonical_agentic_contract_v7.22.18:evaluation

Comparability & Fixture Methodology

Fixtures Enable Valid Variant Comparison

The quanteval evaluation harness uses a consistent fixture set to measure both full-precision and quantized variants. The F16 and Q4K_M variants were evaluated under the same fixture set, enabling direct comparison.

Fixture Generation:

What this means: Results are directly comparable. Both runners used identical fixtures, enabling precise measurement of Q4KM behavioral change relative to F16.

Per-Family Pass Rates — Full-Weight Baseline

All rates include 95% Wilson score confidence intervals. N = 200 cases per family.

Source: quant_eval Family Pass Rates, DOI `10.5281/zenodo.22010623`

Key Findings

Finding 1: Three Perfect Families — Baseline Mastery

Qwen2.5-32B at full precision achieves 100% pass rate on stateful execution, hybrid responses, and multiple-choice extraction (200/200 each). For comparison, the Qwen2.5-14B-Instruct-1M run — same fixtures, substrate, and decoding — scored 0.780 on hybrid responses and 0.970 on MCQ.

Finding 2: Tool Dispatch — 99% on Schema Parsing

Toolcall_only reaches 99% on bare schema extraction, and end-to-end toolcall reaches 94.5%. All failures in both families are tool-selection errors — argument construction passes on all 200 cases. This is strong performance for tool-adjacent workflows.

Finding 3: Planning and Regression — Mid-Range Performance

JSON multistep (60%) and fuzz (63%) sit in the mid-range, indicating this model still struggles with autonomous multi-step planning and regression-style property checks. Planning tasks benefit from external scaffolding at this size.

Quantization Variants Comparison

See how this model performs across the quantized variant. All evaluated under the same fixture set.

\* Generation throughput ratio (16.31 vs 18.73 tokens/sec; observed wall-time ratio 0.85×), measured on unmatched hardware: F16 on a Modal A100-80GB, Q4KM on a Modal A10G. The ratio reflects an accelerator change, not a precision comparison; on the same hardware as its F16 baseline, the quantized model would have smaller inference times.

See the full Q4_K_M card:

• —`Q4_K_M` — 69.7% smaller, no statistically significant difference from F16 in any family, identical perfect performance on all three perfect families

Artifact Provenance

The artifact was produced from Qwen/Qwen2.5-32B-Instruct using a custom-built llama.cpp conversion pipeline developed by PBH Applied Systems, without modification to model weights.

Artifact verification: SHA256 hashes are recorded in the run manifest (DOI `10.5281/zenodo.22010462`). Download the F16 GGUF and verify:

sha256sum qwen-2.5-32B-instruct-gguf-F16.gguf
# Should output: 02e264f0273624b39b0650f8c0583c6d04c320c777780ca5be839999912adf3c

Evaluation Methodology

quant_eval v7.22.22 is a behavioral evaluation harness developed by PBH Applied Systems. The two-run architecture evaluates the full-precision (F16) model first, then evaluates the quantized variant against the same fixture set, enabling direct measurement of behavioral degradation or improvement.

Fixture set: v7.22.22 evaluation split

• —Total unique cases: 1,600 (200 per family × 8 families)
• —Per-family test families and pass signals:

Evaluation infrastructure: Modal A100-80GB GPU cluster (nvidia/cuda:12.4.1) Runner: full_weight_modal_llama_cpp (llama.cpp via Python binding, version 0.3.20) Decoding: temperature 0.7, topk=40, topp=0.95 (seed unsupported on Modal) Context: 8,192-token context window (common Modal cap) Reproducibility: Run manifest, fixtures, and per-case results published to Zenodo under the quant_eval Public Corpus

Deployment Recommendations

✅ Deploy F16 when:

• —You have A100 or H100 availability. 66 GB VRAM is expensive; only justify if fidelity gain is measurable.
• —Research, not production. Study the model's maximum capability before optimizing.

⚠️ Avoid F16 if:

• —Production performance matters. Q4KM showed no statistically significant difference from F16 in any family. Its observed 0.87× throughput ratio was measured on a smaller GPU (A10G vs F16's A100-80GB); on matched hardware, Q4KM would be expected to run faster (not measured in this run).
• —Hardware is constrained. Q4KM fits in 21 GB; F16 requires 66 GB.
• —Cost drives decisions. 70% footprint reduction in Q4KM translates directly to lower inference infrastructure cost.

About PBH Applied Systems

**PBH Applied Systems, LLC** is an Oklahoma City–based applied machine learning and AI systems company specializing in production-grade model evaluation, quantization pipelines, agentic AI infrastructure, and scalable AI-driven application development. The organization emphasizes engineering rigor, reproducibility, and real-world deployment constraints — particularly in environments where performance, cost efficiency, and reliability must be balanced against available hardware and budget.

Founder & Principal AI/ML Systems Architect — Patrick Hill, M.S.

Patrick Hill is the Founder & Principal AI/ML Systems Architect of PBH Applied Systems with 10+ years of experience delivering advanced analytics, predictive modeling, and decision-support solutions across high-stakes operational environments. Patrick holds a Master of Science in Software Engineering with concentrations in Artificial Intelligence and Machine Learning and a B.S. in Business Finance.

Technical expertise spans: Python, SQL, Linux, Pandas, NumPy, scikit-learn, PyTorch, TensorFlow/Keras, HuggingFace Transformers, GGUF, llama.cpp, BitsAndBytes, PEFT, QLoRA, Flask APIs, Docker, CI/CD, Jupyter, Databricks, and quantization strategies.

Published Author: Patrick is the author of [Applied Machine Learning: Concepts, Tools, and Case Studies](https://a.co/d/05qat7Xz) — a 1,200+ page practitioner-oriented textbook adopted as required reading for CSC 373 – Machine Learning at the University of Advancing Technology.

Core Service Areas: LLM optimization & deployment · AI evaluation frameworks · Agentic AI infrastructure · Scalable AI application development · ML pipeline design & analytics · Model & agent cataloging.

🔬 About quant_eval & This Evaluation Series

**quant_eval** is a behavioral evaluation harness developed by PBH Applied Systems, LLC. It measures real agent-adjacent task performance across structured output, tool dispatch, multi-turn state retention, and multi-step planning — not perplexity or leaderboard proxies. Every model published under `pbhappliedsystems` has been independently evaluated using quant_eval before being recommended for any production role.

See it in action: **Live AI Agent Demo →**

📋 Interested in Deeper Engagement?

This model card documents behavioral evidence under quant_eval. If you're evaluating this model for production deployment, need guidance on quantization impact for your specific workload, or want to understand deployment tradeoffs under your infrastructure constraints, PBH Applied Systems offers several paths:

Async Intake Form — https://pbhappliedsystems.com/contact.html

Describe your use case, infrastructure, and evaluation needs. Responses are reviewed asynchronously.

Available Services:

• —Evaluation Report — A written behavioral audit: per-family pass rates, F16 vs. quantized delta analysis, failure cluster diagnostics, deployment recommendation, and a quantization-level suggestion for your hardware and latency constraints. Evidence-standard numbers only. Typical engagements: $2,500–$5,000.

• —Starter-Kit Recommender — Configured agent templates (reasoning, document intelligence, code automation) with proof metrics from your specific workload. Includes model selection, quantization strategy, and deployment architecture guidance tied to your infrastructure.

• —Community — Join discussions on quantization confounds, model comparisons, and evaluation priorities. Active in Hugging Face org discussions, Discord, and Reddit threads.

Submit your details via the form above, and we'll route you to the appropriate engagement.

License

This GGUF repository inherits the license of the base model: Apache 2.0 — `Qwen/Qwen2.5-32B-Instruct`

The quanteval evaluation harness, fuzz prompt builder, and scoring implementation are proprietary to PBH Applied Systems, LLC and are not included in this repository. The golden oracle fixture set used in this evaluation is published under CC BY 4.0 as part of the quanteval Public Corpus (D3, DOI `10.5281/zenodo.22010278`).

GGUF conversion and behavioral evaluation performed by [PBH Applied Systems, LLC](https://pbhappliedsystems.com) · quant_eval v7.22.22 · Run ID: `Qwen2.5_32B_Instruct_20260815_081051` · Published 2026-08-15