VoxPolish

A TTS Dataset Cleaner — turn noisy audio into clean, training-ready datasets in one command.

_{TTS dataset cleaner · audio dataset cleaner · speech denoising · noise removal · silence trimming · loudness normalization for text-to-speech training}

👉 Try VoxPolish live in your browser — upload audio, hear it cleaned instantly. No install.

Bad audio = bad TTS models. This tool removes background noise, trims silence, and normalizes loudness across your entire dataset — so your TTS model trains on clean, consistent speech.

Quick Start · Usage · How It Works · Benchmarks · FAQ

---

💡 Why this exists

VoxPolish is an open-source TTS dataset cleaner. Training a good text-to-speech (TTS) model needs clean audio. Real-world recordings have background hum, fan noise, room echo, inconsistent volume, and dead air at the start and end of clips. Cleaning a dataset by hand is impossible at scale.

TTS Dataset Cleaner runs your whole dataset through a 3-stage pipeline automatically:

Stage	What it does	Why TTS needs it
🔇 Noise Removal	Neural deep-learning denoiser	Clean speech = clean voice clones
✂️ Silence Trimming	Cuts dead air from start & end	No awkward pauses in generated speech
📊 Loudness Norm	Normalizes every file to -23 LUFS	Consistent volume = stable training

Point it at a folder. Get back a clean dataset. That's it.

---

🎧 See & Hear the Difference

The waveforms show the constant noise floor removed and dead air trimmed — speech stays, everything else goes.

🎧 Want to actually hear it? ▶️ Try VoxPolish live — upload any clip and hear it cleaned with a real audio player. Or tap the Before/After links below to play the demo clips.

🗣️ Voice Recording

🔴 Before — noisy  →  🟢 After — cleaned

🚗 Background / Traffic Noise

🔴 Before — noisy  →  🟢 After — cleaned

Every "after" clip is denoised, silence-trimmed, and normalized to -23 LUFS. Clips are MP3 — they play in your browser when opened.

---

✨ Features

• 🚀 One command — python clean.py --input ./data --output ./clean
• 🧠 Neural denoising — state-of-the-art noise suppression, phase-aware (no robotic artifacts)
• 🎯 Auto-detects dataset format — LJSpeech, VCTK, or a plain folder of audio
• 📁 Preserves structure — keeps your metadata.csv, subfolders, and filenames intact
• 🖥️ GPU or CPU — runs anywhere; uses your GPU automatically if available
• 🌐 Web UI included — drag-and-drop a ZIP, download cleaned dataset
• 📋 Detailed reports — per-file stats, latency, failures
• 🎛️ Fully configurable — toggle any stage, tune loudness target & noise limits

---

🚀 Quick Start

git clone https://github.com/Jeevav62/voxpolish.git
cd voxpolish

Then pick the path that suits you:

🐳 Option A — Docker (zero setup)

Runs the web UI in a container — no Python, no dependencies to install.

docker compose up --build
# open http://localhost:7860

Or clean a dataset headlessly via the CLI in the container:

docker compose run --rm voxpolish python clean.py --input /data/in --output /data/out
# put your dataset in ./data/in — cleaned files appear in ./data/out

⚡ Option B — one-command script

Creates a venv, auto-installs GPU or CPU PyTorch, and all dependencies.

bash setup.sh        # sets everything up
bash run.sh          # launches the web UI

🔧 Option C — manual setup

2. Create a virtual environment

python -m venv venv

# Windows
venv\Scripts\activate

# Linux / macOS
source venv/bin/activate

3. Install PyTorch

GPU (NVIDIA — recommended, much faster):

pip install torch torchaudio --index-url https://download.pytorch.org/whl/cu121

CPU only (works everywhere, slower):

pip install torch torchaudio --index-url https://download.pytorch.org/whl/cpu

Not sure which CUDA version you have? Run nvidia-smi. CUDA 12.x → use cu121. CUDA 11.x → use cu118.

4. Install the rest

pip install -r requirements.txt

5. Verify GPU (optional)

python -c "import torch; print('GPU:', torch.cuda.is_available())"

---

📖 Usage

Command Line

Basic — clean a folder:

python clean.py --input ./my_dataset --output ./my_dataset_clean

LJSpeech dataset (keeps metadata.csv):

python clean.py --input ./LJSpeech-1.1 --output ./LJSpeech-clean

Tune the pipeline:

python clean.py \
  --input ./data \
  --output ./clean \
  --target-lufs -20 \      # louder output
  --atten-lim 15 \         # gentler noise removal (preserve more)
  --no-trim                # skip silence trimming

All options:

Flag	Default	Description
--input	(required)	Input folder (audio files or dataset)
--output	(required)	Output folder (created automatically)
--no-pf	off	Disable post-filter (faster, slightly less suppression)
--atten-lim	none	Limit noise reduction to N dB (preserves naturalness)
--no-trim	off	Skip silence trimming
--no-norm	off	Skip loudness normalization
--target-lufs	-23.0	Loudness target (EBU R128 standard)
--workers	1	Parallel workers (keep at 1 for GPU)

After running, check output/cleaning_report.txt for a full summary.

Web UI (Gradio)

python app.py

Opens at http://127.0.0.1:7860. ZIP your dataset, drag it in, tweak the options, download the cleaned ZIP. Live progress bar and stats included.

---

🔬 How It Works

  Your noisy audio (any format, any sample rate)
                    │
                    ▼
        ┌───────────────────────┐
        │  1. Load & resample    │   →  48kHz (denoiser's native rate)
        │     to 48kHz           │
        └───────────┬───────────┘
                    ▼
        ┌───────────────────────┐
        │  2. Neural denoise     │   →  AI removes noise, keeps speech
        │     noise removal      │      (complex spectral filtering)
        └───────────┬───────────┘
                    ▼
        ┌───────────────────────┐
        │  3. Resample back      │   →  your original sample rate
        │     to original SR     │
        └───────────┬───────────┘
                    ▼
        ┌───────────────────────┐
        │  4. Trim silence       │   →  cut dead air, start & end
        └───────────┬───────────┘
                    ▼
        ┌───────────────────────┐
        │  5. Loudness normalize │   →  every file at -23 LUFS
        └───────────┬───────────┘
                    ▼
       Clean, consistent, training-ready audio ✅

The denoiser: the noise-removal core is a two-stage neural network. Stage 1 uses a lightweight GRU on perceptual ERB frequency bands for coarse noise removal. Stage 2 applies fine-grained complex filters only where speech lives. Because it processes both magnitude and phase, the output sounds natural — not the metallic, robotic artifacts older denoisers produce.

---

📁 Supported Formats

Input audio: .wav .mp3 .flac .ogg .m4a .aac

Dataset layouts (auto-detected):

Type	Structure	Handling
LJSpeech	wavs/ + metadata.csv	Cleans wavs/, copies metadata unchanged
VCTK	speaker_id/wav48/*.wav	Cleans per-speaker, preserves structure
Raw folder	any nested folders of audio	Cleans everything, mirrors folder tree

Output preserves your original sample rate, filenames, and folder structure.

---

📊 Benchmarks

Tested on NVIDIA RTX 2050 (4GB) · CUDA 12.9 · 16kHz speech clips:

Metric	Value
Avg processing time	~276 ms/file
Real-time factor	~0.05x (≈18× faster than real-time)
VRAM used	~74 MB
Output loudness accuracy	±0.1 LUFS of target

A 10,000-file dataset cleans in roughly 45 minutes on GPU. CPU works too — slower, but no GPU required.

---

❓ FAQ

Do I need a GPU?

No. It runs on CPU just fine — just slower. A GPU (even a modest one) gives ~10-20× speedup for large datasets.

I get a cudnnException warning. Is something broken?

No. It's a harmless cuDNN fallback message on some GPUs. The model automatically uses a different code path and results are identical. It's suppressed by default.

Will it change my sample rate?

No. Audio is internally processed at 48kHz (the model's requirement) but saved back at your original sample rate.

Does it work on music or non-speech?

It's tuned for speech. It will run on anything, but quality is optimized for voice — perfect for TTS, not for music mastering.

My output is too quiet / too loud.

Adjust --target-lufs. -23 is the broadcast standard. For louder output try -18 or -16. For audiobook style try -20.

The denoiser removed too much / made speech sound thin.

Use --atten-lim 12 (or higher). This caps how much noise is removed, blending in some of the original to preserve naturalness.

---

🤝 Contributing

Contributions welcome! Ideas:

• Additional dataset formats (Common Voice, custom layouts)
• Voice activity detection (VAD) to drop non-speech clips
• Per-file quality scoring (SNR, MOS estimation)
• Batch GPU inference for higher throughput

Open an issue or PR.

---

🙋 Work With Me

I'm Jeeva — I turn research papers into shipping products: reading the latest work and rebuilding it into real features, tools, and ideas people can use. VoxPolish is one example — a research-grade speech model wrapped into a one-command product.

What I do:

• 🔬 Research → product — take papers/models and ship them as usable features
• 🗣️ Fine-tune TTS & LLMs — voice cloning, custom speech models, domain-tuned language models
• 🛠️ Practical ML & audio tooling — pipelines, datasets, and apps that actually run

I'm open to collaboration, open-source work, and hiring opportunities. If you need someone who reads the paper and ships the product, let's talk:

• 🤗 Hugging Face: huggingface.co/jeevav62
• 🌐 Portfolio: see my work

---

📜 License

MIT — see LICENSE. Free for commercial and personal use.

---

🙏 Credits

Denoising powered by DeepFilterNet (MIT) · loudness normalization via pyloudnorm.

If this saved you time, drop a ⭐ — it helps others find it.