hyperglyph-codec 0.1.0__tar.gz → 0.2.0__tar.gz

hyperglyph_codec-0.2.0/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## 0.2.0
+
+- Added int8 sparse residual quantization.
+- Added prototype scale modes for per-block, per-tensor, and per-channel scaling.
+- Added benchmark reports with FP32, FP16 estimate, INT8 estimate, and Hyper Glyph comparisons.
+- Added markdown benchmark export through the Python API and CLI.
+- Added an example compressed `.hwz` artifact and benchmark report.
+- Improved `.hwz` serialization so prototype arrays are stored once in `prototypes.npz`.
+- Preserved skipped tensors when restoring PyTorch state dicts with a reference state dict.
+
+## 0.1.0
+
+- Initial public release.
+- Added NumPy compression path.
+- Added optional PyTorch adapter.
+- Added CLI and .hwz serialization.

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperglyph-codec
-Version: 0.1.0
+Version: 0.2.0
 Summary: Hyperdimensional symbolic residual compression for neural network weights
 Author: Robert McMenemy
 License-Expression: MIT
@@ -60,11 +60,14 @@ Description-Content-Type: text/markdown
 - **Block-level tensor compression** for NumPy arrays and neural network weights.
 - **Symbolic prototype assignment** to represent repeated weight patterns compactly.
 - **Sparse residual repair** to preserve reconstruction fidelity after prototype decoding.
+- **Int8 residual quantization** to reduce sparse repair payload size.
+- **Per-block, per-tensor, and per-channel prototype scales** for tuning reconstruction behavior.
 - **Configurable compression controls** for block size, prototype count, residual size, and tensor filtering.
 - **State dict compression** for model-like parameter dictionaries.
 - **Optional PyTorch support** for loading, compressing, restoring, and benchmarking `.pt` state dicts.
 - **`.hwz` serialization** for saving compressed models as portable archives.
 - **Compression reports** with size ratio, tensor counts, and reconstruction error metrics.
+- **Markdown benchmark export** with FP32, FP16 estimate, INT8 estimate, and Hyper Glyph comparisons.
 - **A small CLI** for compressing, decompressing, inspecting, and benchmarking model archives.
 - **Typed Python API** designed for research, experimentation, and extension.
 
@@ -114,10 +117,22 @@ That is the core job: encode large weight tensors as reusable symbolic
 prototypes plus a small residual correction, then report the size and
 reconstruction tradeoff.
 
-Hyper Glyph v0.1.0 is an experimental research codec. It is intended for
+Hyper Glyph v0.2.0 is an experimental research codec. It is intended for
 testing ideas around hyperdimensional and symbolic weight compression rather
 than guaranteed production compression.
 
+Sample v0.2.0 benchmark from `examples/artifacts/sample-v0.2-benchmark.md`:
+
+| Representation | Bytes | Ratio vs FP32 | MSE | MAE | Max abs error |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| FP32 | 24576 | 1.00x | 0 | 0 | 0 |
+| FP16 estimate | 12288 | 2.00x | - | - | - |
+| INT8 estimate | 6144 | 4.00x | - | - | - |
+| Hyper Glyph | 22032 | 1.12x | 0.00266153 | 0.0405458 | 0.197096 |
+
+The matching compressed artifact is `examples/artifacts/sample-v0.2.hwz`
+and is 26,318 bytes on disk in the current zip-based archive format.
+
 ---
 
 ## Why Hyperdimensional Weight Compression?
@@ -132,7 +147,7 @@ Weight tensors
   -> Learn reusable prototype blocks
   -> Assign each block to a prototype
   -> Store per-block scales
-  -> Store sparse top-k residual corrections
+  -> Store sparse top-k residual corrections as int8 or float32
 
   -> Save compressed archive
   -> Restore approximate tensors
@@ -145,6 +160,7 @@ tradeoff directly:
 - **Large weight matrices** that can be split into repeated local blocks.
 - **Prototype-based compression** where blocks share learned representatives.
 - **Sparse residual repair** where only the largest reconstruction corrections are stored.
+- **Scale modes** for per-block, per-tensor, or per-channel prototype scaling.
 - **Approximate reconstruction** with measurable MSE, MAE, and max absolute error.
 - **State dict workflows** that match common PyTorch model storage patterns.
 - **Portable archive output** for saving and inspecting compressed runs.
@@ -177,7 +193,7 @@ Compression
   - prototype learning
   - prototype assignment
   - scale calculation
-  - sparse residual encoding
+  - int8 or float32 sparse residual encoding
     |
     v
 CompressedModel
@@ -270,6 +286,8 @@ config = HyperGlyphConfig(
     block_size=16,
     n_prototypes=16,
     residual_k=4,
+    residual_dtype="int8",
+    scale_mode="block",
 )
 
 codec = HyperGlyphCodec(config)
@@ -323,6 +341,8 @@ hyperglyph compress model.pt model.hwz \
   --n-buckets 16 \
   --n-prototypes 128 \
   --residual-k 8 \
+  --residual-dtype int8 \
+  --scale-mode channel \
   --min-tensor-size 256
 ```
 
@@ -344,6 +364,12 @@ Benchmark compression and reconstruction:
 hyperglyph benchmark model.pt
 ```
 
+Export the benchmark as markdown:
+
+```bash
+hyperglyph benchmark model.pt --markdown-output benchmark.md
+```
+
 ---
 
 ## Benchmark Example
@@ -354,17 +380,14 @@ A small practical benchmark is enough to see the current codec behavior:
 hyperglyph benchmark model.pt
 ```
 
-Example report fields:
+Example markdown output:
 
 ```text
-original_bytes
-compressed_bytes
-compression_ratio
-tensors_compressed
-tensors_skipped
-total_mse
-total_mae
-max_abs_error
+| Representation | Bytes | Ratio vs FP32 | MSE | MAE | Max abs error |
+| FP32 | 24576 | 1.00x | 0 | 0 | 0 |
+| FP16 estimate | 12288 | 2.00x | - | - | - |
+| INT8 estimate | 6144 | 4.00x | - | - | - |
+| Hyper Glyph | 22032 | 1.12x | 0.00266153 | 0.0405458 | 0.197096 |
 ```
 
 The current package focuses on transparent compression experiments rather than
@@ -388,6 +411,8 @@ config = HyperGlyphConfig(
     n_buckets=16,
     n_prototypes=128,
     residual_k=8,
+    residual_dtype="int8",
+    scale_mode="channel",
     seed=42,
     min_tensor_size=256,
     compress_bias=False,
@@ -434,6 +459,9 @@ block ~= prototype[prototype_id] * scale + sparse_residual
 Increase `residual_k` for better reconstruction fidelity, or reduce it for a
 smaller compressed representation.
 
+Set `residual_dtype="int8"` to quantize sparse residual values. Use
+`residual_dtype="float32"` when you want unquantized residual repairs.
+
 ### 5. **Serialization**
 
 Save compressed models as `.hwz` zip archives:
@@ -485,6 +513,8 @@ config = HyperGlyphConfig(
     n_buckets=16,
     n_prototypes=128,
     residual_k=8,
+    residual_dtype="int8",
+    scale_mode="block",
     seed=42,
     min_tensor_size=256,
     compress_bias=False,
@@ -498,6 +528,8 @@ Key settings:
 - **`block_size`** controls how many flattened weights are grouped together.
 - **`n_prototypes`** controls how many reusable block representatives are learned.
 - **`residual_k`** controls how many residual correction values are stored per block.
+- **`residual_dtype`** controls whether sparse residual values are stored as `int8` or `float32`.
+- **`scale_mode`** controls whether prototype scales are calculated per `block`, per `tensor`, or per `channel`.
 - **`min_tensor_size`** skips tensors too small to benefit from compression.
 - **`compress_bias`** enables compression for bias tensors, which are skipped by default.
 - **`seed`** makes prototype selection deterministic.
@@ -521,6 +553,8 @@ codec = HyperGlyphCodec(
         block_size=16,
         n_prototypes=64,
         residual_k=8,
+        residual_dtype="int8",
+        scale_mode="channel",
     )
 )
 
@@ -568,6 +602,9 @@ examples/
   compress_mlp.py         # PyTorch MLP compression example
   compress_state_dict.py  # NumPy state dict compression example
   mnist_demo.py           # MNIST-oriented demo
+  artifacts/
+    sample-v0.2.hwz       # Example compressed archive
+    sample-v0.2-benchmark.md # Markdown benchmark report
 hyperglyph.png            # Project logo
 pyproject.toml            # Package metadata and dependencies
 CHANGELOG.md              # Release history
@@ -621,7 +658,6 @@ If you use Hyper Glyph in research, please cite:
   title={Hyper Glyph: Hyperdimensional Symbolic Residual Compression for Neural Network Weights},
   author={Robert McMenemy},
   year={2026},
-  version={0.1.0},
+  version={0.2.0},
 }
 ```
-

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/README.md

@@ -25,11 +25,14 @@
 - **Block-level tensor compression** for NumPy arrays and neural network weights.
 - **Symbolic prototype assignment** to represent repeated weight patterns compactly.
 - **Sparse residual repair** to preserve reconstruction fidelity after prototype decoding.
+- **Int8 residual quantization** to reduce sparse repair payload size.
+- **Per-block, per-tensor, and per-channel prototype scales** for tuning reconstruction behavior.
 - **Configurable compression controls** for block size, prototype count, residual size, and tensor filtering.
 - **State dict compression** for model-like parameter dictionaries.
 - **Optional PyTorch support** for loading, compressing, restoring, and benchmarking `.pt` state dicts.
 - **`.hwz` serialization** for saving compressed models as portable archives.
 - **Compression reports** with size ratio, tensor counts, and reconstruction error metrics.
+- **Markdown benchmark export** with FP32, FP16 estimate, INT8 estimate, and Hyper Glyph comparisons.
 - **A small CLI** for compressing, decompressing, inspecting, and benchmarking model archives.
 - **Typed Python API** designed for research, experimentation, and extension.
 
@@ -79,10 +82,22 @@ That is the core job: encode large weight tensors as reusable symbolic
 prototypes plus a small residual correction, then report the size and
 reconstruction tradeoff.
 
-Hyper Glyph v0.1.0 is an experimental research codec. It is intended for
+Hyper Glyph v0.2.0 is an experimental research codec. It is intended for
 testing ideas around hyperdimensional and symbolic weight compression rather
 than guaranteed production compression.
 
+Sample v0.2.0 benchmark from `examples/artifacts/sample-v0.2-benchmark.md`:
+
+| Representation | Bytes | Ratio vs FP32 | MSE | MAE | Max abs error |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| FP32 | 24576 | 1.00x | 0 | 0 | 0 |
+| FP16 estimate | 12288 | 2.00x | - | - | - |
+| INT8 estimate | 6144 | 4.00x | - | - | - |
+| Hyper Glyph | 22032 | 1.12x | 0.00266153 | 0.0405458 | 0.197096 |
+
+The matching compressed artifact is `examples/artifacts/sample-v0.2.hwz`
+and is 26,318 bytes on disk in the current zip-based archive format.
+
 ---
 
 ## Why Hyperdimensional Weight Compression?
@@ -97,7 +112,7 @@ Weight tensors
   -> Learn reusable prototype blocks
   -> Assign each block to a prototype
   -> Store per-block scales
-  -> Store sparse top-k residual corrections
+  -> Store sparse top-k residual corrections as int8 or float32
 
   -> Save compressed archive
   -> Restore approximate tensors
@@ -110,6 +125,7 @@ tradeoff directly:
 - **Large weight matrices** that can be split into repeated local blocks.
 - **Prototype-based compression** where blocks share learned representatives.
 - **Sparse residual repair** where only the largest reconstruction corrections are stored.
+- **Scale modes** for per-block, per-tensor, or per-channel prototype scaling.
 - **Approximate reconstruction** with measurable MSE, MAE, and max absolute error.
 - **State dict workflows** that match common PyTorch model storage patterns.
 - **Portable archive output** for saving and inspecting compressed runs.
@@ -142,7 +158,7 @@ Compression
   - prototype learning
   - prototype assignment
   - scale calculation
-  - sparse residual encoding
+  - int8 or float32 sparse residual encoding
     |
     v
 CompressedModel
@@ -235,6 +251,8 @@ config = HyperGlyphConfig(
     block_size=16,
     n_prototypes=16,
     residual_k=4,
+    residual_dtype="int8",
+    scale_mode="block",
 )
 
 codec = HyperGlyphCodec(config)
@@ -288,6 +306,8 @@ hyperglyph compress model.pt model.hwz \
   --n-buckets 16 \
   --n-prototypes 128 \
   --residual-k 8 \
+  --residual-dtype int8 \
+  --scale-mode channel \
   --min-tensor-size 256
 ```
 
@@ -309,6 +329,12 @@ Benchmark compression and reconstruction:
 hyperglyph benchmark model.pt
 ```
 
+Export the benchmark as markdown:
+
+```bash
+hyperglyph benchmark model.pt --markdown-output benchmark.md
+```
+
 ---
 
 ## Benchmark Example
@@ -319,17 +345,14 @@ A small practical benchmark is enough to see the current codec behavior:
 hyperglyph benchmark model.pt
 ```
 
-Example report fields:
+Example markdown output:
 
 ```text
-original_bytes
-compressed_bytes
-compression_ratio
-tensors_compressed
-tensors_skipped
-total_mse
-total_mae
-max_abs_error
+| Representation | Bytes | Ratio vs FP32 | MSE | MAE | Max abs error |
+| FP32 | 24576 | 1.00x | 0 | 0 | 0 |
+| FP16 estimate | 12288 | 2.00x | - | - | - |
+| INT8 estimate | 6144 | 4.00x | - | - | - |
+| Hyper Glyph | 22032 | 1.12x | 0.00266153 | 0.0405458 | 0.197096 |
 ```
 
 The current package focuses on transparent compression experiments rather than
@@ -353,6 +376,8 @@ config = HyperGlyphConfig(
     n_buckets=16,
     n_prototypes=128,
     residual_k=8,
+    residual_dtype="int8",
+    scale_mode="channel",
     seed=42,
     min_tensor_size=256,
     compress_bias=False,
@@ -399,6 +424,9 @@ block ~= prototype[prototype_id] * scale + sparse_residual
 Increase `residual_k` for better reconstruction fidelity, or reduce it for a
 smaller compressed representation.
 
+Set `residual_dtype="int8"` to quantize sparse residual values. Use
+`residual_dtype="float32"` when you want unquantized residual repairs.
+
 ### 5. **Serialization**
 
 Save compressed models as `.hwz` zip archives:
@@ -450,6 +478,8 @@ config = HyperGlyphConfig(
     n_buckets=16,
     n_prototypes=128,
     residual_k=8,
+    residual_dtype="int8",
+    scale_mode="block",
     seed=42,
     min_tensor_size=256,
     compress_bias=False,
@@ -463,6 +493,8 @@ Key settings:
 - **`block_size`** controls how many flattened weights are grouped together.
 - **`n_prototypes`** controls how many reusable block representatives are learned.
 - **`residual_k`** controls how many residual correction values are stored per block.
+- **`residual_dtype`** controls whether sparse residual values are stored as `int8` or `float32`.
+- **`scale_mode`** controls whether prototype scales are calculated per `block`, per `tensor`, or per `channel`.
 - **`min_tensor_size`** skips tensors too small to benefit from compression.
 - **`compress_bias`** enables compression for bias tensors, which are skipped by default.
 - **`seed`** makes prototype selection deterministic.
@@ -486,6 +518,8 @@ codec = HyperGlyphCodec(
         block_size=16,
         n_prototypes=64,
         residual_k=8,
+        residual_dtype="int8",
+        scale_mode="channel",
     )
 )
 
@@ -533,6 +567,9 @@ examples/
   compress_mlp.py         # PyTorch MLP compression example
   compress_state_dict.py  # NumPy state dict compression example
   mnist_demo.py           # MNIST-oriented demo
+  artifacts/
+    sample-v0.2.hwz       # Example compressed archive
+    sample-v0.2-benchmark.md # Markdown benchmark report
 hyperglyph.png            # Project logo
 pyproject.toml            # Package metadata and dependencies
 CHANGELOG.md              # Release history
@@ -586,7 +623,6 @@ If you use Hyper Glyph in research, please cite:
   title={Hyper Glyph: Hyperdimensional Symbolic Residual Compression for Neural Network Weights},
   author={Robert McMenemy},
   year={2026},
-  version={0.1.0},
+  version={0.2.0},
 }
 ```
-

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/docs/algorithm.md

@@ -11,4 +11,9 @@ The reconstruction is:
 
 $$W \approx \text{Decode}(\text{prototype}) + \text{sparse residual}$$
 
-The implementation is intentionally simple for v0.1 and leaves room for learned decoders and richer codecs later.
+In v0.2, prototype scales can be calculated per block, per tensor, or per
+channel. Sparse residual values can be stored as float32 or quantized to int8
+with a residual scale for decoding.
+
+The implementation is intentionally simple and leaves room for learned decoders
+and richer codecs later.

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/docs/api.md

@@ -4,6 +4,9 @@
 
 Configuration for the codec.
 
+- `residual_dtype`: `int8` or `float32` sparse residual storage.
+- `scale_mode`: `block`, `tensor`, or `channel` prototype scaling.
+
 ## HyperGlyphCodec
 
 - compress_array(name, array)
@@ -12,6 +15,11 @@ Configuration for the codec.
 - decompress_state_dict(compressed_model)
 - report(compressed_model, original_state_dict, restored_state_dict)
 
+## Benchmark helpers
+
+- benchmark_state_dict(state_dict, codec=None)
+- BenchmarkReport.to_markdown()
+
 ## Serialization helpers
 
 - save_compressed(compressed_model, path)

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/docs/cli.md

@@ -5,7 +5,9 @@
 Compress a PyTorch state dict into a .hwz archive.
 
 ```bash
-hyperglyph compress model.pt model.hwz
+hyperglyph compress model.pt model.hwz \
+  --residual-dtype int8 \
+  --scale-mode channel
 ```
 
 ## decompress
@@ -31,3 +33,10 @@ Benchmark compression and reconstruction for a state dict.
 ```bash
 hyperglyph benchmark model.pt
 ```
+
+Write a markdown benchmark report with FP32, FP16 estimate, INT8 estimate, and
+Hyper Glyph comparisons:
+
+```bash
+hyperglyph benchmark model.pt --markdown-output benchmark.md
+```

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/docs/index.md

@@ -1,6 +1,6 @@
 # Hyper Glyph
 
-Hyper Glyph is an experimental package for compressing neural network weights with symbolic hyperdimensional prototypes and sparse residual repair.
+Hyper Glyph is an experimental package for compressing neural network weights with symbolic hyperdimensional prototypes, configurable prototype scales, and sparse residual repair.
 
 ## Installation
 
@@ -17,6 +17,10 @@ config = HyperGlyphConfig(block_size=16, n_prototypes=32, residual_k=4)
 codec = HyperGlyphCodec(config)
 ```
 
+v0.2 adds int8 residual quantization, per-block/per-tensor/per-channel scale
+modes, markdown benchmark reports, and baseline comparisons against FP32, FP16
+estimate, and INT8 estimate sizes.
+
 ## Notes
 
 The codec is intended for research and experimentation rather than guaranteed production compression.

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/docs/roadmap.md

@@ -1,6 +1,6 @@
 # Roadmap
 
-## Version 0.1.0 — Proof of concept
+## Version 0.1.0 - Proof of concept
 
 - src layout package
 - HyperGlyphConfig
@@ -14,17 +14,20 @@
 - CI
 - PyPI publish workflow
 
-## Version 0.2.0 — Better compression fidelity
+## Version 0.2.0 - Residual quantization and reports
 
-- per-channel scale support
+- per-block, per-tensor, and per-channel scale modes
 - residual quantization int8
-- optional int4 residual packing
-- entropy-coded residual indices
+- markdown benchmark export
+- baseline comparisons against FP32, FP16 estimate, and INT8 estimate
+- example compressed .hwz artifact
 - improved compression report
 
-## Version 0.3.0 — PyTorch integration
+## Version 0.3.0 - PyTorch integration
 
 - compress_model(model)
 - decompress_into_model(model, compressed)
 - calibration pass
 - layer include/exclude filters
+- optional int4 residual packing
+- entropy-coded residual indices

hyperglyph_codec-0.2.0/examples/artifacts/sample-v0.2-benchmark.md

@@ -0,0 +1,13 @@
+# Hyper Glyph Benchmark
+
+| Representation | Bytes | Ratio vs FP32 | MSE | MAE | Max abs error |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| FP32 | 24576 | 1.00x | 0 | 0 | 0 |
+| FP16 estimate | 12288 | 2.00x | - | - | - |
+| INT8 estimate | 6144 | 4.00x | - | - | - |
+| Hyper Glyph | 22032 | 1.12x | 0.00266153 | 0.0405458 | 0.197096 |
+
+## Tensor Summary
+
+- Tensors compressed: 2
+- Tensors skipped: 0

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hyperglyph-codec"
-version = "0.1.0"
+version = "0.2.0"
 description = "Hyperdimensional symbolic residual compression for neural network weights"
 readme = "README.md"
 requires-python = ">=3.10"

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/src/hyperglyph/__init__.py

@@ -1,5 +1,6 @@
 """Hyper Glyph package."""
 
+from .benchmark import BaselineComparison, BenchmarkReport, benchmark_state_dict
 from .codec import CompressedModel, CompressedTensor, CompressionReport, HyperGlyphCodec
 from .config import HyperGlyphConfig
 from .serialization import load_compressed, save_compressed
@@ -8,6 +9,8 @@ from .torch_adapter import compress_state_dict, decompress_state_dict
 __all__ = [
     "HyperGlyphCodec",
     "HyperGlyphConfig",
+    "BaselineComparison",
+    "BenchmarkReport",
     "CompressionReport",
     "CompressedModel",
     "CompressedTensor",
@@ -15,5 +18,6 @@ __all__ = [
     "decompress_state_dict",
     "save_compressed",
     "load_compressed",
+    "benchmark_state_dict",
 ]
-__version__ = "0.1.0"
+__version__ = "0.2.0"

hyperglyph_codec-0.2.0/src/hyperglyph/benchmark.py

@@ -0,0 +1,105 @@
+"""Benchmark reporting helpers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+from .codec import CompressionReport, HyperGlyphCodec
+
+
+@dataclass(slots=True)
+class BaselineComparison:
+    """A size comparison against a baseline representation."""
+
+    name: str
+    bytes: int
+    ratio_vs_fp32: float
+    mse: float | None = None
+    mae: float | None = None
+    max_abs_error: float | None = None
+
+
+@dataclass(slots=True)
+class BenchmarkReport:
+    """A benchmark report with baseline and Hyper Glyph metrics."""
+
+    compression: CompressionReport
+    baselines: list[BaselineComparison]
+
+    def to_markdown(self) -> str:
+        """Export the benchmark as a markdown table."""
+        lines = [
+            "# Hyper Glyph Benchmark",
+            "",
+            "| Representation | Bytes | Ratio vs FP32 | MSE | MAE | Max abs error |",
+            "| --- | ---: | ---: | ---: | ---: | ---: |",
+        ]
+        for baseline in self.baselines:
+            lines.append(
+                "| "
+                f"{baseline.name} | "
+                f"{baseline.bytes} | "
+                f"{baseline.ratio_vs_fp32:.2f}x | "
+                f"{_format_optional(baseline.mse)} | "
+                f"{_format_optional(baseline.mae)} | "
+                f"{_format_optional(baseline.max_abs_error)} |"
+            )
+        lines.extend(
+            [
+                "",
+                "## Tensor Summary",
+                "",
+                f"- Tensors compressed: {self.compression.tensors_compressed}",
+                f"- Tensors skipped: {self.compression.tensors_skipped}",
+            ]
+        )
+        return "\n".join(lines) + "\n"
+
+
+def benchmark_state_dict(
+    state_dict: Mapping[str, Any],
+    codec: HyperGlyphCodec | None = None,
+) -> BenchmarkReport:
+    """Compress a state dict and return baseline comparisons."""
+    active_codec = codec or HyperGlyphCodec()
+    compressed = active_codec.compress_state_dict(state_dict)
+    restored = active_codec.decompress_state_dict(compressed)
+    compression = active_codec.report(compressed, state_dict, restored)
+    fp32_bytes = compression.original_bytes
+    baselines = [
+        BaselineComparison("FP32", fp32_bytes, 1.0, 0.0, 0.0, 0.0),
+        BaselineComparison(
+            "FP16 estimate",
+            compression.fp16_estimate_bytes,
+            _ratio(fp32_bytes, compression.fp16_estimate_bytes),
+        ),
+        BaselineComparison(
+            "INT8 estimate",
+            compression.int8_estimate_bytes,
+            _ratio(fp32_bytes, compression.int8_estimate_bytes),
+        ),
+        BaselineComparison(
+            "Hyper Glyph",
+            compression.compressed_bytes,
+            compression.compression_ratio,
+            compression.total_mse,
+            compression.total_mae,
+            compression.max_abs_error,
+        ),
+    ]
+    return BenchmarkReport(compression=compression, baselines=baselines)
+
+
+def _ratio(original_bytes: int, compressed_bytes: int) -> float:
+    if compressed_bytes <= 0:
+        return float("inf")
+    return original_bytes / compressed_bytes
+
+
+def _format_optional(value: float | None) -> str:
+    if value is None:
+        return "-"
+    if value == 0.0:
+        return "0"
+    return f"{value:.6g}"

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/src/hyperglyph/cli.py

@@ -11,6 +11,7 @@ try:
 except ImportError:  # pragma: no cover - optional dependency path
     torch = None
 
+from .benchmark import benchmark_state_dict
 from .codec import HyperGlyphCodec
 from .config import HyperGlyphConfig
 from .serialization import load_compressed, save_compressed
@@ -29,6 +30,10 @@ def build_parser() -> argparse.ArgumentParser:
     compress_parser.add_argument("--n-buckets", type=int, default=16)
     compress_parser.add_argument("--n-prototypes", type=int, default=128)
     compress_parser.add_argument("--residual-k", type=int, default=8)
+    compress_parser.add_argument("--residual-dtype", choices=["float32", "int8"], default="int8")
+    compress_parser.add_argument(
+        "--scale-mode", choices=["block", "tensor", "channel"], default="block"
+    )
     compress_parser.add_argument("--seed", type=int, default=42)
     compress_parser.add_argument("--compress-bias", action="store_true")
     compress_parser.add_argument("--min-tensor-size", type=int, default=256)
@@ -42,6 +47,16 @@ def build_parser() -> argparse.ArgumentParser:
 
     benchmark_parser = subparsers.add_parser("benchmark")
     benchmark_parser.add_argument("input", help="Input torch state dict file (.pt)")
+    benchmark_parser.add_argument(
+        "--markdown-output", help="Write benchmark report to a markdown file"
+    )
+    benchmark_parser.add_argument("--block-size", type=int, default=16)
+    benchmark_parser.add_argument("--n-prototypes", type=int, default=128)
+    benchmark_parser.add_argument("--residual-k", type=int, default=8)
+    benchmark_parser.add_argument("--residual-dtype", choices=["float32", "int8"], default="int8")
+    benchmark_parser.add_argument(
+        "--scale-mode", choices=["block", "tensor", "channel"], default="block"
+    )
 
     return parser
 
@@ -61,6 +76,8 @@ def main(argv: Sequence[str] | None = None) -> int:
             n_buckets=args.n_buckets,
             n_prototypes=args.n_prototypes,
             residual_k=args.residual_k,
+            residual_dtype=args.residual_dtype,
+            scale_mode=args.scale_mode,
             seed=args.seed,
             compress_bias=args.compress_bias,
             min_tensor_size=args.min_tensor_size,
@@ -97,11 +114,21 @@ def main(argv: Sequence[str] | None = None) -> int:
         if torch is None:
             raise SystemExit("PyTorch is required for benchmark CLI commands")
         state_dict = torch.load(args.input, map_location="cpu")
-        codec = HyperGlyphCodec()
-        compressed = codec.compress_state_dict(state_dict)
-        restored = codec.decompress_state_dict(compressed)
-        report = codec.report(compressed, state_dict, restored)
-        print(report)
+        codec = HyperGlyphCodec(
+            HyperGlyphConfig(
+                block_size=args.block_size,
+                n_prototypes=args.n_prototypes,
+                residual_k=args.residual_k,
+                residual_dtype=args.residual_dtype,
+                scale_mode=args.scale_mode,
+            )
+        )
+        report = benchmark_state_dict(state_dict, codec)
+        markdown = report.to_markdown()
+        if args.markdown_output:
+            with open(args.markdown_output, "w", encoding="utf-8") as handle:
+                handle.write(markdown)
+        print(markdown)
         return 0
 
     parser.error("unknown command")

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/src/hyperglyph/codec.py

@@ -11,6 +11,7 @@ import numpy as np
 from .blocks import restore_tensor_shape, split_array_blocks
 from .config import HyperGlyphConfig
 from .metrics import (
+    baseline_size_bytes,
     compressed_size_bytes,
     compression_ratio,
     mae,
@@ -43,7 +44,7 @@ class CompressedModel:
 
     tensors: dict[str, CompressedTensor]
     payload: bytes = field(default_factory=bytes)
-    format_version: str = "0.1"
+    format_version: str = "0.2"
 
 
 @dataclass(slots=True)
@@ -53,6 +54,10 @@ class CompressionReport:
     original_bytes: int
     compressed_bytes: int
     compression_ratio: float
+    fp16_estimate_bytes: int
+    int8_estimate_bytes: int
+    fp16_compression_ratio: float
+    int8_compression_ratio: float
     tensors_compressed: int
     tensors_skipped: int
     total_mse: float
@@ -82,16 +87,18 @@ class HyperGlyphCodec:
         reconstructed_prototypes = reconstruct_from_prototypes(assignments, prototypes)
 
         prototype_ids: list[int] = [int(idx) for idx in assignments]
-        scales: list[float] = []
+        scales = self._block_scales(array, blocks, reconstructed_prototypes)
         residuals: list[dict[str, Any]] = []
         for idx, block in enumerate(blocks):
             proto = reconstructed_prototypes[idx]
-            block_norm = float(np.linalg.norm(block))
-            proto_norm = max(float(np.linalg.norm(proto)), 1e-6)
-            scale = block_norm / proto_norm
-            scales.append(scale)
+            scale = scales[idx]
             proto_scaled = proto * scale
-            residual = compute_topk_residual(block, proto_scaled, self.config.residual_k)
+            residual = compute_topk_residual(
+                block,
+                proto_scaled,
+                self.config.residual_k,
+                dtype=self.config.residual_dtype,
+            )
             residuals.append(serialize_residual(residual))
 
         return CompressedTensor(
@@ -109,6 +116,8 @@ class HyperGlyphCodec:
                 "n_buckets": self.config.n_buckets,
                 "n_prototypes": self.config.n_prototypes,
                 "residual_k": self.config.residual_k,
+                "residual_dtype": self.config.residual_dtype,
+                "scale_mode": self.config.scale_mode,
                 "seed": self.config.seed,
                 "dtype": self.config.dtype,
                 "device": self.config.device,
@@ -161,6 +170,8 @@ class HyperGlyphCodec:
         original_bytes = original_size_bytes(original_state_dict or {})
         compressed_bytes = compressed_size_bytes(compressed_model)
         ratio = compression_ratio(original_bytes, compressed_bytes)
+        fp16_bytes = baseline_size_bytes(original_state_dict or {}, bytes_per_value=2)
+        int8_bytes = baseline_size_bytes(original_state_dict or {}, bytes_per_value=1)
         tensors_compressed = len(compressed_model.tensors)
         tensors_skipped = 0
         if original_state_dict is not None:
@@ -183,6 +194,10 @@ class HyperGlyphCodec:
             original_bytes=original_bytes,
             compressed_bytes=compressed_bytes,
             compression_ratio=ratio,
+            fp16_estimate_bytes=fp16_bytes,
+            int8_estimate_bytes=int8_bytes,
+            fp16_compression_ratio=compression_ratio(original_bytes, fp16_bytes),
+            int8_compression_ratio=compression_ratio(original_bytes, int8_bytes),
             tensors_compressed=tensors_compressed,
             tensors_skipped=tensors_skipped,
             total_mse=total_mse,
@@ -198,3 +213,58 @@ class HyperGlyphCodec:
         return (
             "bias" not in name.lower() and int(np.prod(tensor.shape)) >= self.config.min_tensor_size
         )
+
+    def _block_scales(
+        self,
+        array: np.ndarray,
+        blocks: list[np.ndarray],
+        reconstructed_prototypes: np.ndarray,
+    ) -> list[float]:
+        """Calculate block, tensor, or channel scale values for prototype decoding."""
+        if self.config.scale_mode == "tensor":
+            block_matrix = np.stack(blocks, axis=0).astype(np.float32)
+            block_norm = float(np.linalg.norm(block_matrix))
+            proto_norm = max(float(np.linalg.norm(reconstructed_prototypes)), 1e-6)
+            return [block_norm / proto_norm for _ in blocks]
+
+        if self.config.scale_mode == "channel":
+            channel_scales = self._channel_scales(array, reconstructed_prototypes)
+            channel_ids = self._block_channel_ids(array.shape, len(blocks))
+            return [channel_scales[channel_id] for channel_id in channel_ids]
+
+        scales: list[float] = []
+        for idx, block in enumerate(blocks):
+            block_norm = float(np.linalg.norm(block))
+            proto_norm = max(float(np.linalg.norm(reconstructed_prototypes[idx])), 1e-6)
+            scales.append(block_norm / proto_norm)
+        return scales
+
+    def _channel_scales(
+        self, array: np.ndarray, reconstructed_prototypes: np.ndarray
+    ) -> list[float]:
+        if array.ndim == 0:
+            return [1.0]
+        channel_count = int(array.shape[0]) if array.ndim > 0 else 1
+        channel_size = int(np.prod(array.shape[1:])) if array.ndim > 1 else 1
+        flat_original = np.asarray(array, dtype=np.float32).reshape(-1)
+        flat_reconstructed = reconstructed_prototypes.reshape(-1)[: flat_original.size]
+        scales: list[float] = []
+        for channel in range(channel_count):
+            start = channel * channel_size
+            end = min(start + channel_size, flat_original.size)
+            original_norm = float(np.linalg.norm(flat_original[start:end]))
+            proto_norm = max(float(np.linalg.norm(flat_reconstructed[start:end])), 1e-6)
+            scales.append(original_norm / proto_norm)
+        return scales
+
+    def _block_channel_ids(self, shape: tuple[int, ...], block_count: int) -> list[int]:
+        if not shape:
+            return [0 for _ in range(block_count)]
+        channel_count = int(shape[0])
+        channel_size = int(np.prod(shape[1:])) if len(shape) > 1 else 1
+        ids: list[int] = []
+        for block_index in range(block_count):
+            flat_index = block_index * self.config.block_size
+            channel_id = min(flat_index // max(channel_size, 1), channel_count - 1)
+            ids.append(int(channel_id))
+        return ids

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/src/hyperglyph/config.py

@@ -14,6 +14,8 @@ class HyperGlyphConfig:
     n_buckets: int = 16
     n_prototypes: int = 128
     residual_k: int = 8
+    residual_dtype: str = "int8"
+    scale_mode: str = "block"
     seed: int = 42
     min_tensor_size: int = 256
     compress_bias: bool = False
@@ -31,6 +33,10 @@ class HyperGlyphConfig:
             raise ValueError("n_prototypes must be positive")
         if self.residual_k < 0:
             raise ValueError("residual_k must be non-negative")
+        if self.residual_dtype not in {"float32", "int8"}:
+            raise ValueError("residual_dtype must be 'float32' or 'int8'")
+        if self.scale_mode not in {"block", "tensor", "channel"}:
+            raise ValueError("scale_mode must be 'block', 'tensor', or 'channel'")
         if self.min_tensor_size <= 0:
             raise ValueError("min_tensor_size must be positive")
         if self.dtype not in {"float32", "float64"}:

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/src/hyperglyph/metrics.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Mapping
+from typing import Any, Mapping
 
 import numpy as np
 
@@ -15,13 +15,44 @@ def original_size_bytes(state_dict: Mapping[str, np.ndarray]) -> int:
     return total
 
 
+def baseline_size_bytes(state_dict: Mapping[str, Any], bytes_per_value: int) -> int:
+    """Estimate a dense baseline size with a fixed number of bytes per value."""
+    total = 0
+    for tensor in state_dict.values():
+        total += int(np.asarray(tensor).size) * bytes_per_value
+    return total
+
+
 def compressed_size_bytes(compressed_model: object) -> int:
     """Estimate the compressed size in bytes."""
     if isinstance(compressed_model, Mapping):
         return len(compressed_model.get("payload", b""))
+    tensors = getattr(compressed_model, "tensors", None)
+    if isinstance(tensors, Mapping):
+        total = 0
+        for tensor in tensors.values():
+            total += compressed_tensor_size_bytes(tensor)
+        return total
     return 0
 
 
+def compressed_tensor_size_bytes(tensor: object) -> int:
+    """Estimate the byte size of a compressed tensor payload."""
+    prototype_matrix = np.asarray(getattr(tensor, "prototype_matrix", np.asarray([])))
+    prototype_bytes = int(prototype_matrix.size) * 4
+    prototype_id_bytes = len(getattr(tensor, "prototype_ids", [])) * 4
+    scale_bytes = len(getattr(tensor, "scales", [])) * 4
+    shape_bytes = len(getattr(tensor, "shape", ())) * 4
+    residual_bytes = 0
+    for residual in getattr(tensor, "residuals", []):
+        indices = residual.get("indices", [])
+        values = residual.get("values", [])
+        residual_bytes += len(indices) * 2
+        residual_bytes += len(values) if residual.get("dtype") == "int8" else len(values) * 4
+        residual_bytes += 4
+    return prototype_bytes + prototype_id_bytes + scale_bytes + shape_bytes + residual_bytes
+
+
 def compression_ratio(original_bytes: int, compressed_bytes: int) -> float:
     """Compute compression ratio as original / compressed."""
     if compressed_bytes <= 0:

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/src/hyperglyph/residual.py

@@ -8,11 +8,16 @@ import numpy as np
 
 
 def compute_topk_residual(
-    original_block: np.ndarray, reconstructed_block: np.ndarray, k: int
+    original_block: np.ndarray,
+    reconstructed_block: np.ndarray,
+    k: int,
+    dtype: str = "int8",
 ) -> dict[str, Any]:
     """Return the indices and values of the top-k residual entries."""
     if k < 0:
         raise ValueError("k must be non-negative")
+    if dtype not in {"float32", "int8"}:
+        raise ValueError("dtype must be 'float32' or 'int8'")
     if original_block.shape != reconstructed_block.shape:
         raise ValueError("blocks must have the same shape")
 
@@ -20,24 +25,40 @@ def compute_topk_residual(
         reconstructed_block, dtype=np.float32
     )
     if k == 0:
-        return {"indices": [], "values": []}
+        return {"indices": [], "values": [], "dtype": dtype}
 
     if diff.size == 0:
-        return {"indices": [], "values": []}
+        return {"indices": [], "values": [], "dtype": dtype}
 
     flat = diff.reshape(-1)
     topk_idx = np.argsort(np.abs(flat))[-k:][::-1]
+    values: np.ndarray = np.asarray([float(flat[index]) for index in topk_idx], dtype=np.float32)
+    if dtype == "int8":
+        scale = float(np.max(np.abs(values)) / 127.0) if values.size else 1.0
+        if scale == 0.0:
+            scale = 1.0
+        quantized: np.ndarray = np.clip(np.rint(values / scale), -127, 127).astype(np.int8)
+        return {
+            "indices": [int(index) for index in topk_idx],
+            "values": [int(value) for value in quantized],
+            "scale": scale,
+            "dtype": "int8",
+        }
     return {
         "indices": [int(index) for index in topk_idx],
-        "values": [float(flat[index]) for index in topk_idx],
+        "values": [float(value) for value in values],
+        "dtype": "float32",
     }
 
 
 def apply_residual(block: np.ndarray, residual: dict[str, Any]) -> np.ndarray:
     """Apply sparse residual values to a block."""
     result = np.asarray(block, dtype=np.float32).reshape(-1).copy()
+    scale = float(residual.get("scale", 1.0))
+    dtype = str(residual.get("dtype", "float32"))
     for index, value in zip(residual.get("indices", []), residual.get("values", [])):
-        result[int(index)] += float(value)
+        decoded_value = float(value) * scale if dtype == "int8" else float(value)
+        result[int(index)] += decoded_value
     return result.reshape(block.shape)
 
 
@@ -46,4 +67,6 @@ def serialize_residual(residual: dict[str, Any]) -> dict[str, Any]:
     return {
         "indices": list(residual.get("indices", [])),
         "values": list(residual.get("values", [])),
+        "scale": float(residual.get("scale", 1.0)),
+        "dtype": str(residual.get("dtype", "float32")),
     }

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/src/hyperglyph/serialization.py

@@ -20,7 +20,8 @@ def save_compressed(compressed_model: CompressedModel, path: str | Path) -> None
         metadata = {
             "format_version": compressed_model.format_version,
             "tensors": {
-                name: tensor_to_dict(tensor) for name, tensor in compressed_model.tensors.items()
+                name: tensor_to_dict(tensor, include_prototype_matrix=False)
+                for name, tensor in compressed_model.tensors.items()
             },
         }
         archive.writestr("metadata.json", json.dumps(metadata, indent=2))
@@ -37,31 +38,45 @@ def load_compressed(path: str | Path) -> CompressedModel:
     archive_path = Path(path)
     with zipfile.ZipFile(archive_path, "r") as archive:
         metadata = json.loads(archive.read("metadata.json"))
+        prototype_arrays: Mapping[str, Any] = {}
+        if "prototypes.npz" in archive.namelist():
+            with archive.open("prototypes.npz") as handle:
+                prototype_arrays = dict(np.load(handle))
         tensors: dict[str, CompressedTensor] = {}
         for name, value in metadata.get("tensors", {}).items():
-            tensors[name] = dict_to_tensor(value)
+            prototype_key = f"{name}_prototypes"
+            tensors[name] = dict_to_tensor(value, prototype_arrays.get(prototype_key))
         return CompressedModel(
             tensors=tensors, payload=b"", format_version=metadata.get("format_version", "0.1")
         )
 
 
-def tensor_to_dict(tensor: CompressedTensor) -> dict[str, Any]:
+def tensor_to_dict(
+    tensor: CompressedTensor, include_prototype_matrix: bool = True
+) -> dict[str, Any]:
     """Convert a compressed tensor to a JSON-safe dictionary."""
-    return {
+    payload: dict[str, Any] = {
         "name": tensor.name,
         "shape": list(tensor.shape),
         "block_size": tensor.block_size,
         "prototype_ids": tensor.prototype_ids,
         "scales": tensor.scales,
         "residuals": tensor.residuals,
-        "prototype_matrix": tensor.prototype_matrix.tolist(),
         "seed": tensor.seed,
         "codec_config": tensor.codec_config,
     }
+    if include_prototype_matrix:
+        payload["prototype_matrix"] = tensor.prototype_matrix.tolist()
+    return payload
 
 
-def dict_to_tensor(payload: Mapping[str, Any]) -> CompressedTensor:
+def dict_to_tensor(
+    payload: Mapping[str, Any], prototype_matrix: np.ndarray | None = None
+) -> CompressedTensor:
     """Convert a JSON-safe dictionary back to a CompressedTensor."""
+    matrix = prototype_matrix
+    if matrix is None:
+        matrix = np.asarray(payload.get("prototype_matrix", []), dtype=np.float32)
     return CompressedTensor(
         name=str(payload["name"]),
         shape=tuple(int(value) for value in payload["shape"]),
@@ -69,7 +84,7 @@ def dict_to_tensor(payload: Mapping[str, Any]) -> CompressedTensor:
         prototype_ids=[int(value) for value in payload["prototype_ids"]],
         scales=[float(value) for value in payload["scales"]],
         residuals=[dict(value) for value in payload["residuals"]],
-        prototype_matrix=np.asarray(payload["prototype_matrix"], dtype=np.float32),
+        prototype_matrix=np.asarray(matrix, dtype=np.float32),
         seed=int(payload["seed"]),
         codec_config=dict(payload["codec_config"]),
     )

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/src/hyperglyph/torch_adapter.py

@@ -64,4 +64,7 @@ def decompress_state_dict(
     restored = codec.decompress_state_dict(compressed_model)
     if reference_state_dict is None:
         return restored
-    return {name: numpy_to_tensor(restored[name], reference_state_dict[name]) for name in restored}
+    merged: dict[str, Any] = dict(reference_state_dict)
+    for name, value in restored.items():
+        merged[name] = numpy_to_tensor(value, reference_state_dict[name])
+    return merged

hyperglyph_codec-0.2.0/tests/test_benchmark.py

@@ -0,0 +1,19 @@
+import numpy as np
+
+from hyperglyph import HyperGlyphCodec, HyperGlyphConfig, benchmark_state_dict
+
+
+def test_benchmark_report_exports_markdown_with_baselines() -> None:
+    state_dict = {"weight": np.arange(256, dtype=np.float32).reshape(16, 16)}
+    codec = HyperGlyphCodec(
+        HyperGlyphConfig(block_size=8, n_prototypes=8, residual_k=2, min_tensor_size=4)
+    )
+
+    report = benchmark_state_dict(state_dict, codec)
+    markdown = report.to_markdown()
+
+    assert "FP32" in markdown
+    assert "FP16 estimate" in markdown
+    assert "INT8 estimate" in markdown
+    assert "Hyper Glyph" in markdown
+    assert report.compression.compressed_bytes > 0

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/tests/test_cli.py

@@ -14,7 +14,7 @@ def test_inspect_command_exits_successfully(tmp_path) -> None:
 
     path = tmp_path / "model.hwz"
     save_compressed(
-        CompressedModel(tensors={"weight": compressed}, payload=b"", format_version="0.1"),
+        CompressedModel(tensors={"weight": compressed}, payload=b"", format_version="0.2"),
         path,
     )
 

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/tests/test_codec.py

@@ -22,6 +22,9 @@ def test_report_returns_valid_compression_fields() -> None:
         CompressedModelWrapper(compressed), {"weight": data}, {"weight": restored}
     )
     assert report.tensors_compressed == 1
+    assert report.compressed_bytes > 0
+    assert report.fp16_estimate_bytes == data.size * 2
+    assert report.int8_estimate_bytes == data.size
 
 
 def test_small_tensors_are_skipped_when_below_threshold() -> None:
@@ -34,8 +37,25 @@ def test_small_tensors_are_skipped_when_below_threshold() -> None:
         assert "too small" in str(exc)
 
 
+def test_tensor_and_channel_scale_modes_compress() -> None:
+    data = np.arange(64, dtype=np.float32).reshape(8, 8)
+    for scale_mode in ("tensor", "channel"):
+        config = HyperGlyphConfig(
+            block_size=8,
+            n_prototypes=4,
+            residual_k=2,
+            min_tensor_size=4,
+            scale_mode=scale_mode,
+        )
+        codec = HyperGlyphCodec(config)
+        compressed = codec.compress_array("weight", data)
+        restored = codec.decompress_array(compressed)
+        assert restored.shape == data.shape
+        assert compressed.codec_config["scale_mode"] == scale_mode
+
+
 class CompressedModelWrapper:
     def __init__(self, compressed: object) -> None:
         self.tensors = {"weight": compressed}
         self.payload = b""
-        self.format_version = "0.1"
+        self.format_version = "0.2"

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/tests/test_residual.py

@@ -20,4 +20,16 @@ def test_applying_residual_changes_reconstructed_block_correctly() -> None:
 
 def test_k_zero_works() -> None:
     residual = compute_topk_residual(np.ones(4), np.zeros(4), 0)
-    assert residual == {"indices": [], "values": []}
+    assert residual == {"indices": [], "values": [], "dtype": "int8"}
+
+
+def test_int8_residual_quantization_round_trips_close_values() -> None:
+    original = np.array([1.0, 2.0, 3.0], dtype=np.float32)
+    reconstructed = np.array([1.1, 1.8, 3.2], dtype=np.float32)
+    residual = compute_topk_residual(original, reconstructed, 2, dtype="int8")
+
+    assert residual["dtype"] == "int8"
+    assert all(isinstance(value, int) for value in residual["values"])
+
+    updated = apply_residual(reconstructed, residual)
+    assert np.max(np.abs(updated - original)) < 0.21

{hyperglyph_codec-0.1.0 → hyperglyph_codec-0.2.0}/tests/test_serialization.py

@@ -15,7 +15,7 @@ def test_save_and_load_hwz(tmp_path) -> None:
     save_compressed(compressed_model_from_tensor(compressed), path)
     loaded = load_compressed(path)
 
-    assert loaded.format_version == "0.1"
+    assert loaded.format_version == "0.2"
     assert "weight" in loaded.tensors
     assert loaded.tensors["weight"].name == "weight"
 
@@ -35,4 +35,4 @@ def test_metadata_format_version_exists(tmp_path) -> None:
 def compressed_model_from_tensor(compressed):
     from hyperglyph.codec import CompressedModel
 
-    return CompressedModel(tensors={"weight": compressed}, payload=b"", format_version="0.1")
+    return CompressedModel(tensors={"weight": compressed}, payload=b"", format_version="0.2")

hyperglyph_codec-0.1.0/CHANGELOG.md

@@ -1,8 +0,0 @@
-# Changelog
-
-## 0.1.0
-
-- Initial public release.
-- Added NumPy compression path.
-- Added optional PyTorch adapter.
-- Added CLI and .hwz serialization.