Upload 3 files

Geeked Out Quantizer methodology:
- QUANTIZATION_NOTES.md: Technical specs and method details
- GEEKED_OUT_INFO.md: Overview of the quantization environment
- CALIBRATION_INFO.txt: Calibration data explanation

CALIBRATION_INFO.txt

@@ -0,0 +1,82 @@
+CALIBRATION DATA INFORMATION
+=============================
+
+This model was quantized using importance matrix (imatrix) generation.
+The imatrix captures which weights in the model are most important for
+maintaining output quality during extreme compression (2-bit quantization).
+
+WHAT IS CALIBRATION?
+--------------------
+Calibration is the process of running sample inputs through the model to
+measure which tensors (weight matrices) contribute most to the output.
+These measurements create an "importance matrix" that guides the quantizer
+to preserve precision where it matters most.
+
+CALIBRATION DATA CHARACTERISTICS
+--------------------------------
+Good calibration data should be:
+
+1. REPRESENTATIVE
+   - Matches the domain the model will operate in
+   - Similar vocabulary and complexity to expected inputs
+   - Reflects actual use case scenarios
+
+2. DIVERSE
+   - Multiple topics, subjects, and writing styles
+   - Mix of common and rare tokens
+   - Varied sentence structures and lengths
+
+3. SUFFICIENT
+   - 100-500 text chunks of typical document length
+   - More chunks = better quality (diminishing returns beyond ~500)
+   - Each chunk processed independently
+
+4. NATURAL
+   - Real-world text (not synthetic or random)
+   - Domain-appropriate (code for code models, medical for medical models)
+   - Representative token distribution
+
+CALIBRATION PROCESS PARAMETERS
+------------------------------
+Typical settings for this quantization:
+
+  Chunks Processed:  200-500 (production quality)
+  Chunk Size:        Typical document/paragraph length
+  GPU Acceleration:  Enabled (99 layers offloaded)
+  Thread Count:      Auto-detected based on CPU
+
+QUALITY IMPACT
+--------------
+The importance matrix generated from quality calibration data enables:
+
+  - 3-8% perplexity increase (vs 10-20% without imatrix)
+  - Preservation of critical weights
+  - Intelligent bit allocation per tensor
+  - 16x compression with minimal quality loss
+
+CALIBRATION DATA SOURCES
+------------------------
+Common sources for high-quality calibration data:
+
+  - Wikitext-2-raw (general language models)
+  - Domain-specific corpora (medical, legal, code)
+  - The Pile subset (diverse web text)
+  - Custom curated datasets matching expected use
+
+VERIFICATION
+------------
+Quantized models are tested for:
+  ✓ Perplexity measurement vs baseline
+  ✓ Sample inference quality
+  ✓ Token prediction accuracy
+  ✓ Model file integrity
+
+NOTES
+-----
+- Calibration is performed once per source model
+- Same imatrix can be reused for different target formats
+- Domain-specific calibration yields better results
+- GPU acceleration significantly speeds up generation
+
+For questions about the calibration methodology used for this model,
+please open a discussion on the model's Hugging Face page.

GEEKED_OUT_INFO.md

@@ -0,0 +1,151 @@
+# The Geeked Out Quantizer
+
+## What Is It?
+
+**The Geeked Out Quantizer** is a production-ready quantization environment built for Windows systems. It specializes in extreme model compression using importance-aware quantization techniques, particularly the IQ2_M format which achieves 16x compression with minimal quality loss.
+
+## The Mission
+
+Traditional model quantization forces a choice: small file size or good quality. The Geeked Out Quantizer breaks this trade-off by using **importance matrices** — statistical analysis that identifies which weights matter most, allowing intelligent bit allocation.
+
+## Core Capabilities
+
+### 🎯 Importance-Aware Quantization
+- Generates importance matrices automatically using calibration data
+- Allocates precision where it matters most
+- Achieves 2-bit quantization with only 3-8% quality loss
+
+### ⚡ Hardware Optimization
+- Auto-detects CPU, memory type (DDR4/DDR5), and GPU capabilities
+- Optimizes thread counts and processing parameters
+- GPU acceleration for 5-10x speedup on imatrix generation
+- CUDA 12.4+ support with dynamic GPU layer offloading
+
+### 🧠 Intelligent Memory Management
+- Reserves system RAM to keep Windows responsive during conversion
+- Monitors memory pressure and auto-pauses when needed
+- Configurable retry logic for transient resource constraints
+
+### 📦 Complete Workflow Support
+- Scans directories for valid source models
+- Selects optimal source format (BF16 > F16 > F32)
+- Handles sharded models while preserving structure
+- Batch processing for multiple models
+- Desktop GUI for interactive use
+
+## Quantization Pipeline
+
+```
+Source Model (BF16/F16)
+        ↓
+Calibration Data Analysis
+        ↓
+Importance Matrix Generation
+        ↓
+Smart Bit Allocation
+        ↓
+IQ2_M Quantization
+        ↓
+Quality Verification
+        ↓
+Production-Ready Model (16x smaller)
+```
+
+## Supported Formats
+
+### Importance-Aware (IMatrix Required)
+| Format | Bits/Weight | Best For |
+|--------|-------------|----------|
+| IQ1_M | 1.0 | Ultra-compact mobile/edge |
+| IQ2_XXS | 2.0 | Maximum compression |
+| IQ2_XS | 2.0 | Balanced compression |
+| **IQ2_M** | **2.0** | **Best quality 2-bit** ⭐ |
+| IQ2_S | 2.0 | Higher quality, slower |
+| IQ3_M | 3.0 | Near-Q4 quality |
+| IQ4_XS | 4.0 | Importance-aware 4-bit |
+
+### Standard K-Quant Formats
+Q2_K, Q3_K variants, Q4 variants, Q5 variants, Q6_K, Q8_0
+
+### Ternary Formats
+TQ2_0, TQ1_0 — experimental 3-value quantization
+
+## Why IQ2_M?
+
+IQ2_M represents the sweet spot for extreme quantization:
+
+- **16x smaller** than FP32 models
+- **2-3x faster** inference
+- **VRAM usage** reduced to ~1/16th
+- **Quality** approaches Q4_K with proper imatrix
+- **Compatible** with llama.cpp inference stack
+
+## Use Cases
+
+- 🤖 **Edge AI** — Run large models on limited hardware
+- 🌐 **Browser-Based Inference** — Smaller models for WebGPU/WebGL
+- 📱 **Mobile Deployment** — Fit large models on phones/tablets
+- 🚀 **High-Throughput APIs** — Serve more requests with less VRAM
+- 💾 **Archive Storage** — Preserve models at minimal storage cost
+
+## Technical Philosophy
+
+The Geeked Out Quantizer focuses on:
+
+1. **Quality Preservation** — Never sacrifice more quality than necessary
+2. **Automation** — Minimize manual tuning through intelligent defaults
+3. **Hardware Awareness** — Adapt to the system's capabilities
+4. **Production Ready** — Robust error handling and retry logic
+5. **Calibration Quality** — Emphasize representative data selection
+
+## Model Curation
+
+Not all models are equal candidates. The quantizer evaluates:
+- Source format quality (BF16 preferred)
+- Model architecture compatibility
+- Existing quantization state
+- Expected use case alignment
+
+## Calibration Best Practices
+
+The quality of your quantized model depends heavily on calibration data:
+
+✅ **DO:**
+- Use domain-relevant text (code for code models, medical for medical models)
+- Include diverse topics and writing styles
+- Provide 100-500 chunks of typical document length
+- Ensure natural token distribution
+
+❌ **DON'T:**
+- Use repetitive or overly simple text
+- Include corrupted or random data
+- Rely on single-domain text for general-purpose models
+
+## Collaboration & Research
+
+The Geeked Out Quantizer methodology is available for:
+- Research collaborations on quantization techniques
+- Edge deployment optimization projects
+- Custom calibration strategies for specialized domains
+- Hardware-specific optimization studies
+
+## Community
+
+All models in this Hugging Face profile are quantized using this toolchain. Each model card includes:
+- Quantization specifications
+- Calibration methodology
+- Quality metrics
+- Use case recommendations
+
+## Future Directions
+
+- Expanded format support (new GGML quantization types)
+- Domain-specific calibration datasets
+- Hardware-specific optimization profiles
+- Batch processing automation
+
+---
+
+*The Geeked Out Quantizer: Making extreme compression intelligent.*
+
+For questions about quantization methodology, collaboration opportunities, or technical discussions, please open an issue or discussion on any model in this profile.

QUANTIZATION_NOTES.md

@@ -0,0 +1,118 @@
+# Quantization Notes
+
+## Overview
+
+This model was quantized using **The Geeked Out Quantizer**, a specialized Windows-native quantization environment designed for extreme compression with quality preservation.
+
+## Quantization Specifications
+
+| Parameter | Details |
+|-----------|---------|
+| **Source Format** | BF16 (bfloat16) or F16 (float16) |
+| **Target Format** | IQ2_M (2.0 bits per weight) |
+| **Compression Ratio** | 16x smaller than FP32 baseline |
+| **Quantization Method** | Importance-aware quantization with IMatrix |
+| **Quality Metric** | ~3-8% perplexity increase vs. baseline |
+
+## The Importance Matrix (IMatrix) Method
+
+### What is an Importance Matrix?
+
+An importance matrix is a statistical analysis of a neural network that identifies which weights contribute most significantly to model output quality. Rather than applying uniform quantization across all tensors, this method:
+
+- **Preserves precision** on high-impact weights
+- **Aggressively compresses** low-impact weights
+- **Maintains information flow** through the network architecture
+
+### Why It Matters
+
+Traditional uniform quantization to 2-bit precision typically causes 10-20% quality degradation. The importance matrix approach reduces this to 3-8%, making 2-bit models viable for production use.
+
+## Calibration Process
+
+### Data Selection
+
+The importance matrix is generated using carefully selected calibration data that:
+- Represents the model's intended use domain
+- Contains diverse vocabulary and sentence structures
+- Includes 100-500 text chunks of typical prompt length
+- Matches the distribution of expected inference inputs
+
+### Generation Parameters
+
+| Setting | Typical Value | Purpose |
+|---------|---------------|---------|
+| Chunks | 200-500 | Balance quality vs. generation time |
+| GPU Layers | 99 (max) | Accelerate processing via CUDA |
+| Thread Count | Auto-detected | Optimize for hardware configuration |
+
+## Memory & Hardware Optimization
+
+The quantization process includes:
+- **Dynamic memory management** — Reserves system RAM to maintain Windows responsiveness
+- **Hardware detection** — Automatically detects CPU cores, memory type (DDR4/DDR5), and GPU capabilities
+- **Thread optimization** — Adjusts parallelism based on available resources
+- **Retry logic** — Handles transient memory pressure gracefully
+
+## Model Selection Criteria
+
+Source models are selected based on quality hierarchy:
+1. **BF16** (preferred) — Best precision for quantization
+2. **F16** — Good precision, widely available
+3. **F32** — Acceptable but creates larger intermediate files
+
+Models already in quantized formats are skipped unless explicitly re-quantizing.
+
+## Output Format Details
+
+### IQ2_M Characteristics
+
+- **Bit depth:** 2.0 bits per weight
+- **Speed:** 2-3x faster inference than F32
+- **VRAM usage:** ~1/16th of FP32
+- **Imatrix required:** Yes
+- **Quality tier:** Best-in-class for 2-bit quantization
+
+### Naming Convention
+
+Quantized models follow this pattern:
+```
+OriginalModel-BF16.gguf → OriginalModel-IQ2_M.gguf
+```
+
+Sharded models preserve shard numbering:
+```
+Model-00001-of-00004.gguf → Model-IQ2_M-00001-of-00004.gguf
+```
+
+## Quality Verification
+
+Models are validated through:
+- Perplexity measurement against baseline
+- Sample inference testing
+- File integrity verification
+
+## Use Cases
+
+IQ2_M quantized models are ideal for:
+- **Edge deployment** — Minimal storage footprint
+- **Consumer hardware** — Reduced VRAM requirements
+- **High-throughput inference** — Faster token generation
+- **Bandwidth-constrained environments** — Efficient distribution
+
+## Technical Notes
+
+- Quantization performed on Windows with CUDA 12.4+ support
+- GPU acceleration utilized for imatrix generation
+- Multi-threaded processing with memory safety guards
+- Compatible with llama.cpp inference engines
+
+## Citation
+
+If you use this quantized model in research or applications, please acknowledge:
+
+> Quantized using The Geeked Out Quantizer with importance-aware IQ2_M optimization.
+
+---
+
+*For questions about the quantization method or collaboration inquiries, please open a discussion on this model's page.*