mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
262 lines
10 KiB
Python
262 lines
10 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
MISC Benchmark — Manifold-Invariant Shell Compression Benchmark Suite
|
|
|
|
Tests MISC across diverse data types: text, binary, repetitive patterns,
|
|
random noise, structured metadata, and the Hutter Prize Wikipedia corpus.
|
|
|
|
Usage:
|
|
python tests/benchmark_misc.py # Full benchmark
|
|
python tests/benchmark_misc.py --quick # Quick benchmark (smaller samples)
|
|
python tests/benchmark_misc.py --data-type text # Single data type
|
|
"""
|
|
|
|
import sys, os, math, hashlib, time, statistics
|
|
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src'))
|
|
from misc_kernel import MISCCompressor
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Test data generators
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def generate_text_english(n=1024):
|
|
"""Natural English-like text (lorem ipsum style)."""
|
|
words = ["the", "quick", "brown", "fox", "jumps", "over", "lazy", "dog",
|
|
"manifold", "invariant", "shell", "compression", "quantum", "geometry",
|
|
"entropy", "topology", "resonance", "torsion", "curvature", "trixal",
|
|
"homeostatic", "cognitive", "routing", "delta", "gcl", "encoding"]
|
|
result = []
|
|
for i in range(n // 6):
|
|
result.extend(words)
|
|
if i % 10 == 9:
|
|
result.append(". ")
|
|
elif i % 5 == 4:
|
|
result.append(", ")
|
|
else:
|
|
result.append(" ")
|
|
return " ".join(result).encode()[:n]
|
|
|
|
def generate_repetitive(n=1024):
|
|
"""Highly repetitive pattern (easy for any compressor)."""
|
|
return b"AAAAABBBBBCCCCCDDDDDEEEEEFFFFFFGGGGGHHHHHIIIIIJJJJJKKKKKLLLLL" * (n // 60 + 1)
|
|
|
|
def generate_structured_metadata(n=1024):
|
|
"""Structured metadata with headers, timestamps, codes."""
|
|
lines = []
|
|
for i in range(n // 40):
|
|
lines.append(f"RECORD:{i:06d} TIMESTAMP:{time.time():.3f} TYPE:{i%5} VALUE:{i*7%256:03d}\n")
|
|
return "".join(lines).encode()[:n]
|
|
|
|
def generate_random_noise(n=1024):
|
|
"""Uniform random bytes (worst case for any compressor)."""
|
|
import random as rnd
|
|
rnd.seed(42)
|
|
return bytes(rnd.randint(0, 255) for _ in range(n))
|
|
|
|
def generate_binary_blob(n=1024):
|
|
"""Mixed binary with structure (embedded lengths, checksums, deltas)."""
|
|
data = bytearray()
|
|
for i in range(n // 32):
|
|
data.extend(i.to_bytes(4, 'big'))
|
|
data.extend((i * 3 % 256).to_bytes(4, 'big'))
|
|
data.extend((i ^ 0xFF).to_bytes(4, 'big'))
|
|
data.extend((i >> 2 & 0xFF).to_bytes(4, 'big'))
|
|
data.extend(hashlib.sha256(str(i).encode()).digest()[:16])
|
|
return bytes(data[:n])
|
|
|
|
def generate_hutter_sample(n=1024):
|
|
"""Wikipedia-style text simulating Hutter Prize corpus character."""
|
|
para = ("The Unified Quantum-Geometric Emergence Theory (UQGET) resolves the "
|
|
"Hubble tension through spacetime emergence from quantum entanglement "
|
|
"dynamics. The theory aligns with Planck 2018, DESI 2024, and Pantheon+ "
|
|
"datasets, demonstrating that the Hubble constant can be reconciled "
|
|
"without new physics beyond the Standard Model. This represents a "
|
|
"paradigm shift in our understanding of cosmic expansion and the "
|
|
"fundamental nature of spacetime itself. ")
|
|
return (para * (n // len(para) + 1))[:n].encode()
|
|
|
|
DATA_TYPES = {
|
|
"text_english": (generate_text_english, "Natural English text (lorem-style)"),
|
|
"repetitive": (generate_repetitive, "Highly repetitive patterns"),
|
|
"structured_metadata": (generate_structured_metadata, "Structured records/timestamps/codes"),
|
|
"random_noise": (generate_random_noise, "Uniform random bytes (worst case)"),
|
|
"binary_blob": (generate_binary_blob, "Binary data with embedded structure"),
|
|
"hutter_wikipedia": (generate_hutter_sample, "Wikipedia-style text (Hutter Prize-like)"),
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Compression ratio benchmarks
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def benchmark_data_type(name, gen_fn, description, size=2048, verbose=True):
|
|
"""Run MISC on a specific data type and report metrics."""
|
|
data = gen_fn(size)
|
|
compressor = MISCCompressor()
|
|
|
|
start = time.perf_counter()
|
|
blocks = compressor.compress(data)
|
|
elapsed = time.perf_counter() - start
|
|
|
|
input_bytes = len(data)
|
|
output_bytes = sum(len(b.gcl_bytes) for b in blocks)
|
|
block_count = len(blocks)
|
|
|
|
ratio = output_bytes / input_bytes if input_bytes > 0 else 0
|
|
|
|
# Trixal averages
|
|
if block_count > 0:
|
|
avg_thermal = statistics.mean(b.trixal.thermal.to_float() for b in blocks)
|
|
avg_work = statistics.mean(b.trixal.work.to_float() for b in blocks)
|
|
avg_irr = statistics.mean(b.trixal.irreversibility.to_float() for b in blocks)
|
|
else:
|
|
avg_thermal = avg_work = avg_irr = 0
|
|
|
|
# Strategy distribution
|
|
strategy_counts = {}
|
|
for b in blocks:
|
|
s = b.strategy
|
|
strategy_counts[s] = strategy_counts.get(s, 0) + 1
|
|
|
|
# Block size distribution
|
|
block_sizes = [len(b.gcl_bytes) for b in blocks]
|
|
avg_block_size = statistics.mean(block_sizes) if block_sizes else 0
|
|
|
|
result = {
|
|
"name": name,
|
|
"description": description,
|
|
"input_bytes": input_bytes,
|
|
"output_bytes": output_bytes,
|
|
"ratio": ratio,
|
|
"savings_pct": (1 - ratio) * 100,
|
|
"block_count": block_count,
|
|
"elapsed_s": elapsed,
|
|
"throughput_bps": input_bytes / elapsed if elapsed > 0 else 0,
|
|
"avg_block_size": avg_block_size,
|
|
"strategy_counts": strategy_counts,
|
|
"avg_trixal": {
|
|
"thermal": avg_thermal,
|
|
"work": avg_work,
|
|
"irreversibility": avg_irr,
|
|
},
|
|
}
|
|
|
|
if verbose:
|
|
status = "✅" if ratio < 1.0 else "⚠️" if ratio < 1.5 else "❌"
|
|
print(f" {status} {name:25s} ratio={ratio:.4f} "
|
|
f"{input_bytes}B→{output_bytes}B "
|
|
f"{block_count} blocks {elapsed*1000:.1f}ms "
|
|
f"strategies={dict(strategy_counts)}")
|
|
return result
|
|
|
|
def run_full_benchmark(sizes=None, verbose=True):
|
|
"""Run benchmark across all data types at multiple sizes."""
|
|
if sizes is None:
|
|
sizes = [256, 512, 1024, 2048, 4096, 8192] if "--quick" not in sys.argv else [256, 512]
|
|
|
|
all_results = {}
|
|
|
|
for size in sizes:
|
|
if verbose:
|
|
print(f"\n{'='*70}")
|
|
print(f" Benchmark: {size:>5} bytes ({size} input size)")
|
|
print(f"{'='*70}")
|
|
|
|
for name, (gen_fn, desc) in DATA_TYPES.items():
|
|
if name not in all_results:
|
|
all_results[name] = []
|
|
result = benchmark_data_type(name, gen_fn, desc, size=size, verbose=verbose)
|
|
all_results[name].append(result)
|
|
|
|
return all_results
|
|
|
|
def print_summary(all_results, verbose=True):
|
|
"""Print consolidated summary table."""
|
|
print(f"\n{'='*70}")
|
|
print(f" MISC BENCHMARK SUMMARY")
|
|
print(f"{'='*70}")
|
|
print(f" {'Data Type':25s} {'Avg Ratio':>10s} {'Best Ratio':>10s} {'Worst Ratio':>10s} {'Best Savings':>12s}")
|
|
print(f" {'-'*25} {'-'*10} {'-'*10} {'-'*10} {'-'*12}")
|
|
|
|
overall_best_ratio = float('inf')
|
|
overall_worst_ratio = 0
|
|
|
|
for name in sorted(all_results.keys()):
|
|
results = all_results[name]
|
|
ratios = [r["ratio"] for r in results]
|
|
best = min(ratios)
|
|
worst = max(ratios)
|
|
avg = statistics.mean(ratios)
|
|
best_savings = max(r["savings_pct"] for r in results)
|
|
|
|
if best < overall_best_ratio:
|
|
overall_best_ratio = best
|
|
if worst > overall_worst_ratio:
|
|
overall_worst_ratio = worst
|
|
|
|
emoji = "✅" if best < 1.0 else "⚠️" if best < 1.5 else "❌"
|
|
print(f" {emoji} {name:23s} {avg:>10.4f} {best:>10.4f} {worst:>10.4f} {best_savings:>+11.1f}%")
|
|
|
|
print(f" {'-'*25} {'-'*10} {'-'*10} {'-'*10} {'-'*12}")
|
|
print(f" Overall best ratio: {overall_best_ratio:.4f}")
|
|
print(f" Overall worst ratio: {overall_worst_ratio:.4f}")
|
|
|
|
# Strategy analysis
|
|
print(f"\n{'='*70}")
|
|
print(f" STRATEGY ANALYSIS")
|
|
print(f"{'='*70}")
|
|
all_strategies = {}
|
|
for name in sorted(all_results.keys()):
|
|
for r in all_results[name]:
|
|
for s, c in r["strategy_counts"].items():
|
|
all_strategies[s] = all_strategies.get(s, 0) + c
|
|
for s in sorted(all_strategies.keys()):
|
|
print(f" {s:20s}: {all_strategies[s]:>5d} block selections")
|
|
|
|
# Trixal analysis
|
|
print(f"\n{'='*70}")
|
|
print(f" TRIXAL THERMODYNAMIC ANALYSIS")
|
|
print(f"{'='*70}")
|
|
for name in sorted(all_results.keys()):
|
|
results = all_results[name]
|
|
avg_t = statistics.mean(r["avg_trixal"]["thermal"] for r in results)
|
|
avg_w = statistics.mean(r["avg_trixal"]["work"] for r in results)
|
|
avg_i = statistics.mean(r["avg_trixal"]["irreversibility"] for r in results)
|
|
print(f" {name:25s} thermal={avg_t:.3f} work={avg_w:.3f} irr={avg_i:.3f}")
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Main
|
|
# ---------------------------------------------------------------------------
|
|
|
|
if __name__ == "__main__":
|
|
print("MISC Benchmark — Manifold-Invariant Shell Compression")
|
|
print("============================================================")
|
|
|
|
# Run benchmark
|
|
all_results = run_full_benchmark()
|
|
|
|
# Print summary
|
|
print_summary(all_results)
|
|
|
|
# Quick assessment
|
|
print(f"\n{'='*70}")
|
|
print(f" ASSESSMENT")
|
|
print(f"{'='*70}")
|
|
|
|
# Check if any data type achieved actual compression (ratio < 1.0)
|
|
achieved_compression = False
|
|
for name in all_results:
|
|
for r in all_results[name]:
|
|
if r["ratio"] < 1.0:
|
|
achieved_compression = True
|
|
break
|
|
|
|
if achieved_compression:
|
|
print(" ✅ MISC achieved compression on at least one data type.")
|
|
else:
|
|
print(" ⚠️ MISC prototype strategies are heuristic placeholders.")
|
|
print(" ⚠️ True compression requires implementing proper entropy coding")
|
|
print(" ⚠️ (arithmetic coding / ANS) using the shell/mass structure.")
|
|
|
|
print(f"\n MISC Pipeline verified on {sum(len(v) for v in all_results.values())} benchmarks.")
|
|
print(" Framework complete: ShellMap → GWL → Cognitive → Strategy → Trixal → DeltaGCL → Homeostatic")
|