quantcost 0.2.0__py3-none-any.whl

edgellm/validate.py

@@ -0,0 +1,274 @@
+"""Validate a submitted result card.
+
+What this can and cannot do, stated plainly, because a leaderboard that overclaims
+its own rigour is worse than one that is honest about being trust-based:
+
+**It can** reject cards that are malformed, internally inconsistent, scored
+against a different corpus, or run with settings that make them incomparable to
+everyone else's — and it can flag numbers that are physically implausible.
+
+**It cannot** prove a number came from real hardware. Nothing short of attested
+execution could, and this is a benchmark run on strangers' laptops. The defence
+is that the inputs are pinned (model revision, artifact bytes, corpus hash,
+prompt hash, token budget), so a fabricated card has to be *internally
+consistent* across every one of those to pass — and a reviewer can re-run the
+exact configuration from the card itself. Cards are reviewed, not trusted.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+from edgellm.card import CARD_SCHEMA_VERSION
+from edgellm.eval_lite import EVAL_CORPUS_SHA256
+from edgellm.hub import PRECISION_FILES
+from edgellm.sweep import prompt_sha256
+
+#: A card whose settings differ from these is still valid, but is not comparable
+#: with the main leaderboard, so it is listed separately rather than ranked.
+COMPARABLE_GEN_TOKENS = 32
+COMPARABLE_EVAL_WINDOWS = 8
+
+REQUIRED_TOP_LEVEL = {
+    "schema_version",
+    "model_id",
+    "revision",
+    "created_utc",
+    "tool_version",
+    "machine",
+    "rows",
+    "eval_windows",
+    "eval_corpus_sha256",
+    "warmup_runs",
+    "gen_tokens",
+    "prompt_sha256",
+}
+
+REQUIRED_MACHINE = {
+    "cpu",
+    "arch",
+    "physical_cores",
+    "logical_cores",
+    "ram_gb",
+    "os",
+    "os_release",
+    "python",
+    "onnxruntime",
+    "provider",
+    "intra_op_threads",
+    "thread_policy",
+}
+
+REQUIRED_ROW = {
+    "precision",
+    "size_mb",
+    "latency_s_mean",
+    "latency_s_std",
+    "tokens_per_second",
+    "peak_ram_mb",
+    "perplexity",
+    "generated_tokens",
+    "measured_runs",
+}
+
+#: Loose physical bounds. Deliberately wide — the point is to catch a typo or a
+#: fabricated order of magnitude, not to second-guess unusual but real hardware.
+MAX_PLAUSIBLE_TOK_S = 100_000.0
+MAX_PLAUSIBLE_PERPLEXITY = 1e6
+
+
+@dataclass
+class ValidationReport:
+    path: Path
+    errors: list[str]
+    warnings: list[str]
+    comparable: bool
+
+    @property
+    def ok(self) -> bool:
+        return not self.errors
+
+    def render(self) -> str:
+        status = "PASS" if self.ok else "FAIL"
+        flag = "" if self.comparable else "  (not comparable — will be listed, not ranked)"
+        lines = [f"[{status}] {self.path.name}{flag}"]
+        lines += [f"    error:   {e}" for e in self.errors]
+        lines += [f"    warning: {w}" for w in self.warnings]
+        return "\n".join(lines)
+
+
+def validate_card(path: Path) -> ValidationReport:
+    """Check one card file. Never raises for bad content — it reports."""
+    errors: list[str] = []
+    warnings: list[str] = []
+
+    try:
+        card = json.loads(path.read_text())
+    except (OSError, json.JSONDecodeError) as exc:
+        return ValidationReport(path, [f"unreadable JSON: {exc}"], [], False)
+
+    if not isinstance(card, dict):
+        return ValidationReport(path, ["top level must be a JSON object"], [], False)
+
+    missing = REQUIRED_TOP_LEVEL - set(card)
+    if missing:
+        errors.append(f"missing field(s): {', '.join(sorted(missing))}")
+
+    if card.get("schema_version") != CARD_SCHEMA_VERSION:
+        errors.append(
+            f"schema_version is {card.get('schema_version')!r}, expected {CARD_SCHEMA_VERSION}. "
+            "Re-run with the current quantcost."
+        )
+
+    machine = card.get("machine")
+    if not isinstance(machine, dict):
+        errors.append("'machine' must be an object")
+    else:
+        missing_machine = REQUIRED_MACHINE - set(machine)
+        if missing_machine:
+            errors.append(f"machine missing: {', '.join(sorted(missing_machine))}")
+        if machine.get("intra_op_threads") in (0, None):
+            errors.append(
+                "machine.intra_op_threads is 0/null — thread count must be pinned, "
+                "or throughput is not comparable. Re-run with the current version."
+            )
+        for leak in ("hostname", "user", "username", "mac", "ip", "serial"):
+            if leak in machine:
+                errors.append(f"machine.{leak} must not be submitted (identifying information)")
+
+    rows = card.get("rows")
+    if not isinstance(rows, list) or not rows:
+        errors.append("'rows' must be a non-empty list")
+        rows = []
+
+    seen: set[str] = set()
+    scores_perplexity = False
+    for index, row in enumerate(rows):
+        where = f"rows[{index}]"
+        if not isinstance(row, dict):
+            errors.append(f"{where} must be an object")
+            continue
+
+        missing_row = REQUIRED_ROW - set(row)
+        if missing_row:
+            errors.append(f"{where} missing: {', '.join(sorted(missing_row))}")
+            continue
+
+        precision = row["precision"]
+        if precision not in PRECISION_FILES:
+            errors.append(f"{where}: unknown precision {precision!r}")
+        if precision in seen:
+            errors.append(f"{where}: duplicate precision {precision!r}")
+        seen.add(precision)
+
+        for field in ("size_mb", "latency_s_mean", "tokens_per_second", "peak_ram_mb"):
+            value = row[field]
+            if not isinstance(value, (int, float)) or value <= 0:
+                errors.append(f"{where}.{field} must be a positive number, got {value!r}")
+
+        if isinstance(row.get("tokens_per_second"), (int, float)):
+            if row["tokens_per_second"] > MAX_PLAUSIBLE_TOK_S:
+                errors.append(
+                    f"{where}.tokens_per_second = {row['tokens_per_second']} is not physically "
+                    f"plausible (cap {MAX_PLAUSIBLE_TOK_S:.0f})"
+                )
+
+        # Throughput must agree with latency and the token count it claims.
+        lat, tps, gen = row["latency_s_mean"], row["tokens_per_second"], row["generated_tokens"]
+        if all(isinstance(v, (int, float)) and v > 0 for v in (lat, tps, gen)):
+            implied = gen / lat
+            if abs(implied - tps) / max(implied, tps) > 0.02:
+                errors.append(
+                    f"{where}: tokens_per_second ({tps}) disagrees with "
+                    f"generated_tokens/latency_s_mean ({implied:.2f}). "
+                    "These are derived from the same measurement and must match."
+                )
+
+        if row.get("generated_tokens") != card.get("gen_tokens"):
+            errors.append(
+                f"{where}.generated_tokens ({row.get('generated_tokens')}) does not match "
+                f"the card's gen_tokens ({card.get('gen_tokens')})"
+            )
+
+        if row.get("perplexity") is not None:
+            scores_perplexity = True
+            ppl = row["perplexity"]
+            if not isinstance(ppl, (int, float)) or ppl <= 1.0:
+                errors.append(f"{where}.perplexity must be > 1.0, got {ppl!r}")
+            elif ppl > MAX_PLAUSIBLE_PERPLEXITY:
+                errors.append(f"{where}.perplexity = {ppl} is implausible")
+
+        if isinstance(row.get("latency_s_std"), (int, float)) and isinstance(lat, (int, float)):
+            if lat > 0 and row["latency_s_std"] > lat * 0.5:
+                warnings.append(
+                    f"{where}: latency varied by more than 50% of the mean — the machine was "
+                    "probably busy. Consider re-running on an idle system."
+                )
+
+    if scores_perplexity and card.get("eval_corpus_sha256") != EVAL_CORPUS_SHA256:
+        errors.append(
+            f"eval_corpus_sha256 {card.get('eval_corpus_sha256')!r} does not match the bundled "
+            f"corpus {EVAL_CORPUS_SHA256!r}. Perplexity scored against different text is not "
+            "comparable."
+        )
+
+    if card.get("prompt_sha256") != prompt_sha256():
+        errors.append(
+            "prompt_sha256 does not match the pinned benchmark prompt. Latency depends on "
+            "prompt length, so a different prompt is not comparable."
+        )
+
+    if "fp32" not in seen and rows:
+        warnings.append("no fp32 baseline in this card, so speedups cannot be computed for it")
+
+    comparable = (
+        not errors
+        and card.get("gen_tokens") == COMPARABLE_GEN_TOKENS
+        and (not scores_perplexity or card.get("eval_windows") == COMPARABLE_EVAL_WINDOWS)
+    )
+    if not comparable and not errors:
+        warnings.append(
+            f"settings differ from the comparable defaults "
+            f"(gen_tokens={COMPARABLE_GEN_TOKENS}, eval_windows={COMPARABLE_EVAL_WINDOWS}); "
+            "this card will be listed but not ranked"
+        )
+
+    return ValidationReport(path, errors, warnings, comparable)
+
+
+def validate_all(paths: list[Path]) -> list[ValidationReport]:
+    return [validate_card(p) for p in sorted(paths)]
+
+
+def _main(argv: list[str] | None = None) -> int:
+    """``python -m edgellm.validate results/community/*.json`` — the CI entry point."""
+    import argparse
+
+    parser = argparse.ArgumentParser(prog="python -m edgellm.validate")
+    parser.add_argument("paths", nargs="+", type=Path)
+    parser.add_argument("--strict", action="store_true", help="Treat warnings as failures as well.")
+    args = parser.parse_args(argv)
+
+    files: list[Path] = []
+    for path in args.paths:
+        files.extend(sorted(path.glob("*.json")) if path.is_dir() else [path])
+
+    reports = validate_all(files)
+    for report in reports:
+        print(report.render())
+
+    failed = [r for r in reports if not r.ok]
+    warned = [r for r in reports if r.warnings]
+    print(
+        f"\n{len(reports) - len(failed)}/{len(reports)} card(s) passed"
+        + (f", {len(warned)} with warnings" if warned else "")
+    )
+    if failed:
+        return 1
+    return 1 if (args.strict and warned) else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(_main())

quantcost-0.2.0.dist-info/METADATA

@@ -0,0 +1,265 @@
+Metadata-Version: 2.5
+Name: quantcost
+Version: 0.2.0
+Summary: Measure what quantization actually costs on your own hardware: speed, size, memory and quality.
+Project-URL: Homepage, https://github.com/vijay-kapse/EdgeLLM
+Project-URL: Leaderboard, https://github.com/vijay-kapse/EdgeLLM/blob/main/results/LEADERBOARD.md
+Project-URL: Issues, https://github.com/vijay-kapse/EdgeLLM/issues
+Author: Vijay Kapse
+License: MIT
+License-File: LICENSE
+Keywords: benchmark,edge,inference,int4,int8,llm,npu,onnx,onnxruntime,perplexity,qualcomm,quantization
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: System :: Benchmark
+Requires-Python: >=3.10
+Requires-Dist: huggingface-hub>=0.23
+Requires-Dist: numpy>=1.24
+Requires-Dist: onnxruntime>=1.18
+Requires-Dist: psutil>=5.9
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: tokenizers>=0.19
+Requires-Dist: typer>=0.12
+Provides-Extra: aihub
+Requires-Dist: qai-hub>=0.9; extra == 'aihub'
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Provides-Extra: quantize
+Requires-Dist: datasets>=2.19; extra == 'quantize'
+Requires-Dist: onnx-ir>=0.2; extra == 'quantize'
+Requires-Dist: onnx>=1.16; extra == 'quantize'
+Requires-Dist: optimum[onnxruntime]>=1.20; extra == 'quantize'
+Requires-Dist: torch>=2.2; extra == 'quantize'
+Requires-Dist: transformers>=4.44; extra == 'quantize'
+Provides-Extra: report
+Requires-Dist: matplotlib>=3.8; extra == 'report'
+Description-Content-Type: text/markdown
+
+# quantcost
+
+**Find out what quantization actually costs you — on your machine, not someone else's.**
+
+[![CI](https://github.com/vijay-kapse/EdgeLLM/actions/workflows/ci.yml/badge.svg)](https://github.com/vijay-kapse/EdgeLLM/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/quantcost)](https://pypi.org/project/quantcost/)
+[![Python](https://img.shields.io/pypi/pyversions/quantcost)](https://pypi.org/project/quantcost/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+
+```bash
+pip install quantcost
+quantcost run
+```
+
+That's it. Two to three minutes later you get speed, size, memory and *quality*
+for fp32 / int8 / int4 on your own CPU, with a plain-language verdict.
+
+No PyTorch. No GPU. No quantizing anything yourself — the pre-quantized ONNX
+already published on the Hugging Face Hub gets downloaded and measured, so the
+whole install is ONNX Runtime, NumPy and a tokenizer, and finishes in about ten
+seconds.
+
+---
+
+## What quantization actually costs
+
+"Quantize it, it'll be smaller and faster" is half right. Two models, one Apple
+M4, measured with `quantcost run` at its defaults:
+
+**SmolLM2-135M-Instruct**
+
+| Precision | Size (MB) | tok/s | Speedup | Peak RAM (MB) | Perplexity | PPL change |
+| --- | --- | --- | --- | --- | --- | --- |
+| fp32 | 515 | 83.65 | baseline | 1360 | 23.07 | baseline |
+| int8 | 131 | 39.36 | **0.47x** | 1002 | 25.02 | +8.5% |
+| q4 | 174 | 57.40 | **0.69x** | 906 | 28.35 | +22.9% |
+
+**Qwen2.5-0.5B-Instruct**
+
+| Precision | Size (MB) | tok/s | Speedup | Peak RAM (MB) | Perplexity | PPL change |
+| --- | --- | --- | --- | --- | --- | --- |
+| fp32 | 1901 | 21.49 | baseline | 3282 | 19.26 | baseline |
+| int8 | 488 | 10.17 | **0.47x** | 3052 | 21.19 | +10.0% |
+| q4 | 750 | 18.37 | **0.85x** | 2303 | 22.28 | +15.7% |
+
+Smaller: reliably, 3–4x. Less memory: yes, 25–30% off the peak. Faster: **no** —
+int8 generates tokens at 0.47x the fp32 rate on *both* models. That the figure
+lands on 0.47 twice, across a 135M and a 500M model, is what makes it look like
+a property of the runtime rather than an accident of one benchmark.
+
+### Why, and why it is not "quantized maths is slow"
+
+Run the same artifacts over a 512-token prefill instead of one token at a time:
+
+| | prefill (512 tok) | decode (1 tok/step) |
+| --- | --- | --- |
+| SmolLM2 int8 | 0.79x | 0.43x |
+| SmolLM2 q4 | 0.31x | 0.68x |
+| Qwen int8 | 0.97x | 0.59x |
+| Qwen q4 | 0.36x | 1.02x |
+
+The int8 penalty roughly **halves** once there is a batch to amortise over
+(0.43 → 0.79, 0.59 → 0.97). That is the signature of a fixed per-step cost:
+ONNX Runtime unpacks the weights back to float inside each matmul, and a single
+token cannot amortise unpacking a whole weight matrix. fp32 decode is
+bandwidth-bound on *reading* weights; int8 decode is compute-bound on
+*unpacking* them, so it does strictly more work despite being 4x smaller.
+
+Note also that **int8 and q4 invert**: q4 is the better choice for decode
+(0.68x / 1.02x vs int8's 0.43x / 0.59x) and much the worse for prefill
+(0.31x / 0.36x vs 0.79x / 0.97x). They use different kernels —
+`MatMulNBits` for q4, dynamic-quantize + `MatMulInteger` for int8 — with
+opposite strengths. Which format is right depends on whether your workload is
+prompt-heavy or generation-heavy.
+
+### One number that is easy to get wrong
+
+Pin threads to your machine's **performance** cores, not every physical core.
+On this M4 (4 performance + 6 efficiency) pinning all ten cost int8 66% of its
+throughput — 24.1 vs 40.0 tok/s — and doubled run-to-run spread, because an ONNX
+Runtime parallel region ends on a barrier and one thread on an efficiency core
+gates the whole thing. `quantcost` does this by default and records how it
+decided in every card. It is the single easiest way to publish a wrong number,
+and it is how the first draft of this README got the figures above wrong.
+
+So the honest answer to "should I quantize?" is **measure it on your hardware**,
+which is why this is a tool rather than a blog post. On this machine you quantize
+to fit in memory, not to go faster. On yours it may differ — that is the thing
+worth finding out.
+
+**[See what other machines measured →](results/LEADERBOARD.md)**
+
+## Add your machine
+
+```bash
+quantcost run
+quantcost submit
+```
+
+`submit` validates your result, forks this repo, commits the card and opens the
+pull request for you. No GitHub CLI? It prints a prefilled link instead.
+
+Unusual hardware is the most valuable kind: Raspberry Pi, old ThinkPads,
+Snapdragon laptops, bare-metal ARM. The interesting question is not who has the
+fastest laptop — it is *where quantization pays off and where it backfires*, and
+that only becomes visible across many real machines.
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for what makes a good submission and
+exactly what a card contains (no hostname, no username, no paths — the
+fingerprint is one auditable function).
+
+## Usage
+
+```bash
+# A different model — anything with ONNX on the Hub works
+quantcost run --model onnx-community/Qwen2.5-0.5B-Instruct
+
+# Which precisions does a model actually publish?
+quantcost models --model onnx-community/Qwen2.5-0.5B-Instruct
+
+# Speed and size only; skips the perplexity pass and is much faster
+quantcost run --precisions fp32,int8 --skip-perplexity
+
+# Pin threads to compare against a specific configuration
+quantcost run --threads 4
+
+# Rebuild the leaderboard from every submitted card
+quantcost leaderboard
+```
+
+Any Hub repo following the `onnx-community` / `transformers.js` layout works
+unchanged — that is thousands of models, including everything under
+[onnx-community](https://huggingface.co/onnx-community).
+
+## How the numbers are produced
+
+The headline claim of this project is that its numbers are real, so the
+methodology is worth stating plainly.
+
+**Every precision is measured in its own subprocess.** Peak RSS is a per-process
+high-water mark and an ONNX Runtime session does not return all of its arenas
+when dropped, so measuring several precisions in one process reports the *union*
+of their footprints and blames whichever ran last. Isolation is the only way the
+peak-RAM column means what it says.
+
+**The file cache is warmed before anything is timed.** ONNX Runtime mmaps
+weights and faults them in lazily. Measured cold — straight after the download —
+an fp32 baseline came in at 17 tok/s; warm, the same machine and build measured
+64. A 4x error on the number every other row is divided by is not a rounding
+detail, so the model file is read through once before the session is built.
+
+**Throughput is total tokens over total time**, derived from the same mean
+latency that is reported, never the average of each run's own rate. Those are
+different statistics (ratio of means vs. mean of ratios) and they disagree by a
+few percent, which would make two columns of the same card contradict each other.
+
+**Decoding is greedy and fixed-length.** No sampling, no early EOS stop, so every
+precision does exactly the same amount of work and throughput does not depend on
+the RNG.
+
+**Perplexity is scored against a corpus pinned inside the package** — a fixed
+65,342-byte slice of WikiText-2, hash-checked on load and recorded in every card.
+A leaderboard where machines score different text is not a leaderboard, and this
+also removes a heavy `datasets` dependency. Method: non-overlapping 512-token
+windows, summed next-token cross-entropy, `exp(total_nll / total_tokens)`. The
+NumPy implementation is tested against the uniform-distribution case, where the
+right answer is analytically the vocabulary size, and agrees with PyTorch's
+`cross_entropy` to 4e-07 relative.
+
+**Thread count is always pinned** to physical cores (SMT siblings contend for the
+same vector units) and recorded, because leaving it at ORT's default stores "0 —
+decide for me" and makes two very different runs look identical.
+
+**Instability is reported, not hidden.** If run-to-run latency varies by more
+than 15%, the report says the machine was too busy and asks you to re-run.
+
+### What validation can and cannot do
+
+CI rejects cards that are malformed, internally inconsistent, scored against a
+modified corpus, run with an unpinned thread count, or carrying identifying
+information. It **cannot** prove a number came from real silicon — nothing short
+of attested execution could. The defence is that every input is pinned, so a
+fabricated card must be self-consistent across all of them, and anyone can re-run
+the exact configuration recorded in the card. Cards are reviewed, not trusted.
+
+## Authoring quantized artifacts yourself
+
+Everything above *consumes* pre-quantized ONNX. The original project also
+*produces* it — export, quantize, a C++ inference harness, a SIMD INT8 GEMM
+kernel, an Android app and a Qualcomm Snapdragon NPU path. That path needs the
+heavy dependencies:
+
+```bash
+pip install -e ".[quantize]"
+edgellm export --help
+edgellm quantize --help
+edgellm bench --help      # the original torch + Optimum harness
+```
+
+See [docs/AUTHORING.md](docs/AUTHORING.md) for the full pipeline, the C++ harness
+and the Snapdragon notes.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+ruff check . && ruff format --check . && pytest
+```
+
+CI asserts that importing the CLI pulls in no heavy dependency. If you need
+torch, import it inside the function that uses it — the fast install is what
+makes a one-command benchmark viable for someone who has never heard of this
+project.
+
+## License
+
+MIT — see [LICENSE](LICENSE). The bundled eval corpus is WikiText-2, CC BY-SA 4.0;
+see [edgellm/data/SOURCE.md](edgellm/data/SOURCE.md).

quantcost-0.2.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+edgellm/__init__.py,sha256=WEF4Psnkp-LKq1B5VNPpWb7gcuv4Whh_Gjk9cd9R5IU,166
+edgellm/base.py,sha256=hMVqPbnZFV9rymRfX6CtKQ4UPWGxZb_zEqVgqaIU7fs,1294
+edgellm/benchmark.py,sha256=BYzMzcTv3gcTraajBBAW2JAzjDueCe_7BoXbctFM2V4,8181
+edgellm/card.py,sha256=ev-3LJHimFf14OyKC1_ARZYSEfb7ozJJqBFa3Qd4lYM,7972
+edgellm/cli.py,sha256=u131oDKUgm1ucZeS2LRU923qyaIIHLw_gHGeGNGI_G4,13706
+edgellm/cli_bench.py,sha256=grLG-iRsBnMD8uSeTrzIBZMvUZYQdB2deSpkjzxGTtU,7849
+edgellm/config.py,sha256=GuuloueR0y5_8drBYyOj-oLj2PN5D6Z_g_wiJ9fHVjc,3570
+edgellm/eval_lite.py,sha256=eNM_EGMFr7O10l2xtYbkFTMGnPsARfK_aJeovpMzI8I,4806
+edgellm/export.py,sha256=EaI3gWNJqL0KL1-Eso-FgcMmdqlN0oN1SWpRR8JfDp0,2344
+edgellm/hub.py,sha256=djTbeoUryiRqqoKaFtMtke6VWN9UDMCu5xU-PY7ixLk,4598
+edgellm/leaderboard.py,sha256=9zPUnarUzzGM8rciDu54r-2FPgpgf9NTpvxYTp92vAY,8443
+edgellm/models.py,sha256=JmmQRjR3t1sNl8Kz-SX9NLf5bX1iJdbWNLJKusTDXjE,2745
+edgellm/ort_lite.py,sha256=vw71IqlIUQ8AfKA2gtVbWVFXdHPEqcD79n2QHOxNITU,9564
+edgellm/quantize.py,sha256=gxC0YxxQaXX_c1uq9h1HT94EgMyQvofk9nFWkmPZ7a0,5075
+edgellm/render.py,sha256=Nu6iUBnhKueXEmiSk0eVs7hRPl_txAGFlnv5NWxklis,6998
+edgellm/report.py,sha256=YSp5_3xAeWgKUCIz0xeZYxBKobXZsRu3RKlPDNok0j4,1807
+edgellm/runners.py,sha256=D7ICj5PIsWj6ExCmyllon7VyNgrT92aCbjWzVLRMK7g,6227
+edgellm/submit.py,sha256=dSmzvIseg3hCckxyvzANJBRNuwcnGDIG9YX1Grv1jDs,8118
+edgellm/sweep.py,sha256=kaBCIsKwm_xM2_i2kYLoIp9O0JO9do6SiYLy2zzpCfI,11540
+edgellm/validate.py,sha256=7GYm7gYhn15bxgOVGcEG10HujaVtv5PP0CWpo7TIkgU,10068
+edgellm/data/SOURCE.md,sha256=9fv2dBtucKis_UjyYF2yZh_puSqyc9JDHWD0iHez-bI,919
+edgellm/data/eval_wikitext2.txt,sha256=NKKkP89JIX96QhM_lhkw2MgwrH_jzHkn9CP0Qwg_l78,65342
+quantcost-0.2.0.dist-info/METADATA,sha256=ND-s2JTWgdrg0WQmtTNXRsJTz9-qQj9WR1cTo8qdbow,11582
+quantcost-0.2.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+quantcost-0.2.0.dist-info/entry_points.txt,sha256=1Hv957MAOBjb0MT3nJdko_Cqhrtfsxxxf7Oax4DQNBs,74
+quantcost-0.2.0.dist-info/licenses/LICENSE,sha256=jBAq79ONijdbPnqSEEL9fDEzsZp8TCOxNdvmMhT6EzU,1068
+quantcost-0.2.0.dist-info/RECORD,,

quantcost-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

quantcost-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+edgellm = edgellm.cli:main
+quantcost = edgellm.cli:main

quantcost-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vijay Kapse
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.