# LavaSR restores speech at roughly 5000x realtime

> LavaSR is a lightweight speech restoration and bandwidth extension model built on a Vocos prior, upsampling noisy low quality audio to 48 kHz in a single forward pass, with the README reporting speeds around 5000x realtime on GPU and 500 MB of video memory.

**ysharma3501/LavaSR** — 🌋LavaSR: Fast Speech restoration and enhancement

- Repository: https://github.com/ysharma3501/LavaSR
- Stars: 619 · Forks: 55
- Language: Python
- License: Apache-2.0
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/ysharma3501-lavasr

## What kind of restoration this is

LavaSR is described as a lightweight and high quality speech enhancement model that enhances low quality audio with noise into clean crisp audio. The main features list four properties: it is extremely fast, reaching speeds over 5000x realtime on GPUs and 50x realtime on CPUs; the quality surpasses diffusion models; the efficiency is stated as using 500 MB of video memory and potentially less; and the input is universal, supporting any input sampling rate from 8 kHz to 48 kHz.

The word to notice is bandwidth extension. This is not primarily a denoiser that happens to resample. The comparison tables are about upsampling from 8, 16 and 24 kHz to 48 kHz, and the quality metric is the log-spectral distance against the original 48 kHz file, where lower is better because it means closer to the original. A 16 kHz telephone path upsampled to 48 kHz sounds thin and muffled, and recovering the missing high frequencies is what this model is built to do.

The three use cases the README gives follow from that. Enhancing text to speech, because a narrow band TTS output can be repaired with little computational cost. Real-time enhancement, for on-device processing of low quality calls and audio with little memory. And restoring datasets, where a corpus of narrow band recordings can be enhanced in bulk.

The audience is therefore a speech or audio engineer who has bandwidth-limited audio and needs it back, and who cannot afford a diffusion model in the loop. The release note says LavaSR v2 came with a large increase in quality and speed, surpassing 6 GB slow diffusion models, and the paper for v2 has been accepted to the main track of Interspeech 2026.

## A Vocos prior with a Linkwitz-Riley inspired refiner

The project answers the question of what is novel in an Info section, and the answer is about architecture rather than scale.

It adapts the Vocos architecture for bandwidth extension, and proposes a Linkwitz-Riley inspired refiner to further increase quality. The speed explanation follows from the same source. Vocos is described as isotropic and single pass, which makes it much faster than time-domain based and diffusion based models, and it is said to scale well.

The training story is short and worth knowing. It starts from a Vocos prior and is trained with just 50k steps on the VCTK dataset, with the dataset randomly resampled to 8, 16 or 24 kHz and random noise added. That is a small training budget by the standards of modern speech models, and it also explains the shape of the benchmark, since the VCTK validation set is the evaluation set in the quality table.

The acknowledgements name Vocos for the architecture and UL-UNAS for the denoiser model, and the package dependency list confirms it: the project depends on torch, librosa, soundfile and vocos, with the vocos dependency pulled straight from a git repository at a specific branch rather than from PyPI.

The denoiser is a separate ingredient from the upsampler, which is reflected in the API, where denoising is an explicit option that defaults to off.

## The two tables that carry the argument

The README makes its case with two comparison tables, and it is worth reading them closely because they are more informative than the prose.

The first is quality, measured by log-spectral distance on the VCTK validation set, where lower means closer to the original 48 kHz file:

| Method | 8 to 48 kHz | 16 to 48 kHz | 24 to 48 kHz |
|---|---|---|---|
| Sinc upsampling | 2.98 | 2.75 | 2.17 |
| AudioSR (diffusion) | 1.13 | 0.98 | 0.82 |
| NU-WAVE2 (diffusion) | 1.10 | 0.94 | 0.87 |
| AP-BWE (previous best) | 0.86 | 0.74 | 0.64 |
| Proposed model | 0.85 | 0.72 | 0.63 |

The margins over the previous best are small, in the third decimal place, and that is the honest reading: the win is a modest quality improvement over a strong prior, and a large one over naive sinc upsampling and over diffusion approaches.

The second table is where the project is genuinely different, and it is speed and model size on an A100 GPU:

| Model | Speed (real time) | Model size |
|---|---|---|
| LavaSR | 5000x realtime | ~50 MB |
| AP-BWE | 300x realtime | ~70 MB |
| FlowHigh | 80x realtime | ~450 MB |
| FlashSR | 14x realtime | ~1000 MB |
| AudioSR | 0.6x realtime | ~6000 MB |

AudioSR is listed at 0.6x realtime, which is slower than real time, and at around 6 GB in size. LavaSR at 5000x and roughly 50 MB is two orders of magnitude smaller and four orders of magnitude faster, and that is the property that makes on-device use plausible at all. The README also notes that the headline speed of roughly 5000x on GPU and over 60x on CPU appears in the summary, while the features list gives 50x on CPU, so the CPU figure should be treated as a range rather than a promise.

## Installing and running the model

The install is one line, and it installs from the repository rather than from a package index:

```bash
uv pip install git+https://github.com/ysharma3501/LavaSR.git
```

The model itself is loaded from Hugging Face, with the device passed in:

```python
from LavaSR.model import LavaEnhance2 

## change device to your torch device type(cuda, mps, etc.)
device = 'cpu'
lava_model = LavaEnhance2("YatharthS/LavaSR", device)
```

The simple inference path loads the audio, enhances it and writes both files:

```python
import soundfile as sf
from IPython.display import Audio

input_audio, input_sr = lava_model.load_audio('input.wav')

## Enhance Audio
output_audio = lava_model.enhance(input_audio).cpu().numpy().squeeze()

## Save Audio(both input and output)
sf.write('input.wav', input_audio.cpu().numpy().squeeze(), 16000)
sf.write('output.wav', output_audio, 48000)
```

The advanced path exposes the four knobs that matter. The cutoff, which defaults to roughly half the sampling rate and can be lowered for higher quality at the risk of a metallic sound. The input sample rate, which can be anything from 8 to 48 kHz. A denoise flag, off by default, to be switched on only if the audio has noise to filter. And a batch flag, off by default, to be switched on if the audio is very long.

The two flags have different costs. Denoising adds a second model to the path, so it is a deliberate choice rather than a default, and the batch mode exists because a single long file will exhaust memory otherwise.

The weights are hosted on Hugging Face under YatharthS/LavaSR, with a Space, a Colab notebook and an arXiv paper linked alongside, so you can try the model in a browser before installing anything.

## Community ports and the roadmap

The community section is longer than you would expect from a model release, and it says something about the shape of the project.

There is a ComfyUI node for using LavaSR inside ComfyUI, a separate GUI application, a purely C++ implementation, a clean and simple ONNX implementation, and an ONNX runtime version with the weights embedded in the graph, DirectML and NPU support and an export script. There is also a hosted demo on FalAI.

That list is a good map of the deployment space. The C++ and ONNX ports are the ones that matter for on-device use, since the Python package pulls in torch, which is a large dependency for something intended to run close to the hardware. The ONNX variant with DirectML and NPU support is the one that would target a Windows device with a neural accelerator, and the export script is what makes the PyTorch weights usable there at all.

The roadmap is short. Releasing the model and the code, the Hugging Face space demo and the model with no metallic issue are all checked. Releasing the training code is not checked, and neither is a model trained on music and audio.

Both unchecked items are limitations in practice. Without the training code, you cannot retrain the model on your own data or adapt it to a different domain, and the current model is trained on VCTK speech with random noise, so material that is not speech is outside what it was trained for.

## Licence, packaging and a version mismatch

The README states that the model and code are licensed under the Apache-2.0 licence, with a pointer to the LICENSE file. The packaging metadata says something different. The pyproject.toml has no licence field, and its classifier list includes the MIT licence identifier, which is a different licence from the one the README describes.

That is a small inconsistency with a real consequence, since a tool that reads the packaging metadata will report a different licence than the one stated in prose. The LICENSE file in the repository is the document to trust, and this is an observation about what the metadata says rather than legal advice.

The version numbers are also out of step. The package metadata records version 0.0.2, while the single release tag in the list is v1.0.0-cameraready from 2026-06-19, which is also the date of the last push to the repository. The package is named LavaSR with a capital L, and the description in the metadata is Fast speech restoration, while the README calls it Fast Speech restoration and enhancement.

The dependency on vocos is worth noting for reproducibility, since it is pinned to a git branch rather than a released version, which means a future change in that repository can change the behaviour of an install that has not changed.

The project is not archived, requires Python 3.10 or later, and the packaging uses setuptools with the standard build backend.

## Conclusion

LavaSR fits a team that has degraded speech, either from a low bandwidth call path or from a text to speech system producing narrow band audio, and that needs to repair it in real time on a single GPU or on CPU. It is the wrong choice if you need a denoiser that can be trained on your own data, because the training code is still an open item on the roadmap, and it is the wrong choice if your audio needs to go beyond 48 kHz or needs a general denoiser, since the denoise path is off by default and the model is trained on speech. Before adopting it, pin the version you install, since the package metadata and the release tags disagree, and check the licence file, because the packaging metadata classifies the project differently from the README.

## FAQ

### What does LavaSR do to audio?

It enhances low quality audio with noise into clean audio, and its main task is bandwidth extension, upsampling from 8, 16 or 24 kHz to 48 kHz. The README describes it as a lightweight and high quality speech enhancement model, with universal input from 8 kHz to 48 kHz.

### How do I install LavaSR?

With uv pip install git+https://github.com/ysharma3501/LavaSR.git, which installs from the repository. The weights are loaded separately from Hugging Face with LavaEnhance2("YatharthS/LavaSR", device), where the device is your torch device such as cpu, cuda or mps.

### How fast is LavaSR compared to other models?

The README reports roughly 5000x realtime on GPU with a model size of about 50 MB, against 300x and about 70 MB for AP-BWE, 80x and about 450 MB for FlowHigh, 14x and about 1000 MB for FlashSR, and 0.6x realtime and about 6000 MB for AudioSR, with the speed comparisons done on an A100 GPU.

### What is LavaSR built on and what was it trained on?

It adapts the Vocos architecture for bandwidth extension and adds a Linkwitz-Riley inspired refiner, and it was trained from a Vocos prior with 50k steps on the VCTK dataset, randomly resampled to 8, 16 or 24 kHz with random noise added.

### Can I train LavaSR on my own data?

Not yet. Releasing the training code is an open item on the project's roadmap, so the published model is what you have to work with, and it is a speech model trained on VCTK.

## Sources

- [Issues](https://github.com/ysharma3501/LavaSR/issues)
- [License: Apache-2.0](https://github.com/ysharma3501/LavaSR/blob/main/LICENSE)
- [README](https://github.com/ysharma3501/LavaSR/blob/main/README.md)
- [Releases](https://github.com/ysharma3501/LavaSR/releases)
- [ysharma3501/LavaSR on GitHub](https://github.com/ysharma3501/LavaSR)

---

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