# Pruna's own table says the techniques that shrink a model cost quality

> Pruna is a model optimization framework that wraps caching, quantization, pruning, distillation and compilation behind one call and one configuration object, and its readme is unusually well organised for a research package. The interesting tension is internal: the introduction promises smaller models with quality maintained, while the framework's own overview table marks every size-reducing technique as a quality loss, with two separate row types existing to repair it.

**PrunaAI/pruna** — Pruna is a model optimization framework built for developers, enabling you to deliver faster, more efficient models with minimal overhead.

- Repository: https://github.com/PrunaAI/pruna
- Website: https://docs.pruna.ai
- Stars: 1,306 · Forks: 115
- Language: Python
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/prunaai-pruna

## The introduction promises quality, the table marks it as lost

The introduction lists four outcomes from one framework: faster inference, smaller model size while maintaining quality, lower computational cost, and less energy use. Three of those are aspirations. The second is contradicted two sections later by the framework's own overview table, where each technique carries a marker for speed, memory and quality. Every technique that reduces size is marked as worsening quality: the distiller that trains a smaller model to mimic a larger one, the quantizer that lowers weight and activation precision, and the pruner that removes connections. Two further rows exist whose only purpose is to put quality back, a recoverer that restores performance after compression and an enhancer that post-processes output with denoising or upscaling. The quick start's configuration names neither of them:

```python
smash_config = SmashConfig(["deepcache", "stable_fast"])
smashed_model = smash(model=base_model, smash_config=smash_config)
```

So the size claim, taken with the table, describes a compression followed by a repair.

## The table lists techniques, the quick start names algorithms

The overview presents itself as a high-level view of all methods available and organises them into eleven rows by technique: batcher, cacher, compiler, distiller, quantizer, pruner, recoverer, factorizer, enhancer, distributer and kernel. Each row carries a one line description and three markers. The configuration in the quick start, by contrast, names two things that appear nowhere in that table, a cache and a compiler with a product-sounding name. The practical consequence is that the table cannot be used to answer either of the two questions you are likely to have, whether a given algorithm is in the framework and whether it works on your platform, since the names you must type are not in it and the platform caveat is stated only in the installation section. That mapping lives in the documentation site, which is where the readme sends you for the detailed description of each algorithm. The claimed coverage is broad rather than narrow, naming large language models, diffusion and flow matching models, vision transformers and speech recognition models among the families it supports, so the table is a summary of a much larger surface than eleven rows.

## Two rows differ by two letters and do opposite things

One pair in the table deserves a warning. The distiller trains a smaller, simpler model to mimic a larger and more complex one, which is a training step that costs quality and memory. The distributer spreads inference, the model or certain calculations across multiple devices, which is an infrastructure step that improves speed and costs memory. The two names are adjacent to a typo of each other, they are separated by several rows in a table with ten other entries, and both appear as bare identifiers when you configure a run. The readme does not flag the collision, and a mistyped one produces an import error or, worse, a configuration that silently does something adjacent to what you meant. Two other rows are worth reading for what they promise: a batcher groups several inputs so they are processed simultaneously, marked as improving speed while worsening memory, and a factorizer folds several small matrix multiplications into one large fused operation, marked as improving speed at no stated cost to memory or quality.

## Two type checkers, with fourteen rules switched off for now

The tool configuration is the most detailed document in the repository. It configures one type checker, and then configures a second whose stricter rules are explicitly ignored during what the file calls a transition period, with the reason written beside each: unresolved imports, calling a non-callable, indexing out of bounds, unresolved attributes, redundant casts, unsupported operators, invalid return types, invalid parameter defaults, unmatched overloads, unresolved references, possibly missing imports, possibly missing attributes, missing arguments, and unused ignore comments. Each comment compares the two checkers directly, noting where one is stricter or more permissive than the other. Alongside that sit a linter with a 121 character line length, the numpy docstring convention, preview rules enabled for copyright checking, a security scanner with tests and documentation excluded, and coverage measured from the package source.

## A copyright header is a lint rule, with one file exempt from line length

The per-file exemptions are where the configuration becomes specific. Every source file is expected to carry a copyright header naming the company, and that is enforced by a linter plugin rather than by convention, which is why the preview rule set is switched on. Then the exemptions: notebooks drop the rules about commented-out code because tutorials are meant to contain it, test files are allowed to print because that is what tests are for, documentation is exempt from the header check, and exactly one module, the tags file in the algorithms base directory, is allowed to exceed the line length. Four exemptions in a small project is reasonable. A single file with a length exemption is the kind of thing that spreads, because the next long file has a precedent to point at.

## The minimal evaluation downloads a dataset and shows no number

The evaluation helper is where the readme's promise meets reality. The snippet builds a data module from a named public image dataset, limits it to ten items, wraps it in a task named for image generation quality, and calls evaluate on the optimized model:

```python
datamodule = PrunaDataModule.from_string("LAION256")
datamodule.limit_datasets(10)
task = Task("image_generation_quality", datamodule=datamodule)
eval_agent = EvaluationAgent(task)
eval_agent.evaluate(smashed_model)
```

Nothing in the snippet prints a result, and the dataset is fetched rather than bundled. So the documented path to finding out whether compression damaged anything requires a network download and leaves the reader to work out where the score comes from. For a framework whose entire pitch is preserving quality while going faster, that is the highest-weight step in the quick start carrying the least detail, and it is also the step most likely to matter to anyone about to ship the optimized model.

## A 2023 citation, a three month gap, and a Python 3.9 floor

Three housekeeping facts sit under the marketing. The suggested citation is a software entry dated 2023 pointing at the project website, for a package whose newest release is from June 2026 while the last push is dated 30 September 2026, so the record has not tracked the versions for three years. Installation asks for Python 3.9 or higher, which is below what much of the surrounding tooling now requires, and the platform claim of Linux, macOS and Windows is immediately qualified by the note that some algorithms restrict the operating system. In the other direction, the repository carries more governance than most research packages: an AI contribution policy next to the code of conduct, a security file, a contributing guide, a pre-commit configuration and a licence. The tooling investment is real, and it is pointed at a 0.3 release line.

## Conclusion

Pruna suits someone with a working model who needs it faster or cheaper on constrained hardware and who will measure the result rather than assume it. Read the technique table before the introduction, since the quality markers are the honest part and the outcome list is the promotional one, and check whether the algorithms you need exist on your operating system, since the cross-platform claim is qualified in the next sentence. Anyone wanting a framework whose quality regression is bounded by construction, or whose evaluation runs without fetching a dataset, should look for that elsewhere.

## FAQ

### What is Pruna and what does it do to a model?

It is a model optimization framework that applies compression techniques to an existing model: caching, quantization, pruning, distillation and compilation, selected through one configuration object and applied with a single call. The result is used the way you would use the original model.

### Which techniques does Pruna offer and what do they cost?

Eleven technique rows are summarised by their effect on speed, memory and quality, using markers for improves, roughly unchanged and worsens. Caching, compiling, factorisation, distribution and kernels are marked as improving speed. Distillation, quantization and pruning improve speed and memory while worsening quality, and recovery and enhancement exist to put quality back.

### How do I install Pruna?

From PyPI with pip, or from a cloned checkout in editable mode. It is available on Linux, macOS and Windows, though the readme notes that some algorithms restrict the operating system. You need Python 3.9 or higher, plus optionally the CUDA toolkit for GPU support.

### Can I evaluate a Pruna-optimized model offline?

Not from the documented path. The evaluation helper fetches a named public image dataset and limits it to ten items, so the snippet needs a download, and the readme does not show where the resulting score is returned.

### How should Pruna be cited?

As a software entry titled Efficient Machine Learning with Pruna, dated 2023, noting that it is available from the project website. That suggested record has not been updated as the package has moved through its 0.3 releases.

## Sources

- [License: Apache-2.0](https://github.com/PrunaAI/pruna/blob/main/LICENSE)
- [Project website](https://docs.pruna.ai)
- [PrunaAI/pruna on GitHub](https://github.com/PrunaAI/pruna)
- [README](https://github.com/PrunaAI/pruna/blob/main/README.md)
- [Releases](https://github.com/PrunaAI/pruna/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/prunaai-pruna