Captured at (local ISO): 2026-05-18 05:17:30

Introduction

Background noise is a long-standing pain point in speech interaction and audio processing. Alibaba DAMO Academy’s open-source FRCRN (Frequency-Recurrent Convolutional Recurrent Network) is a top-tier solution and has performed strongly in benchmarks such as DNS-Challenge. This guide walks you through deploying a 16 kHz single-microphone denoising service on your own server.

1. Environment Setup

Use a clean Python environment (3.8 or 3.9 recommended).

1.1 Install core dependencies

FRCRN depends on PyTorch and ModelScope:

# Install PyTorch (choose CPU or GPU build for your environment)
# Example for CUDA 11.7; without GPU: pip install torch
pip install torch torchvision torchaudio

If you use a preconfigured PyTorch image, you can skip the step above.

# ModelScope audio extras
pip install "modelscope[audio]" -f https://modelscope.oss-cn-beijing.aliyuncs.com/releases/repo.html

# Helper libraries
pip install soundfile librosa

1.2 System dependencies

Install ffmpeg if missing (helps with multiple audio formats):

• Ubuntu: sudo apt-get install ffmpeg
• CentOS: yum install ffmpeg

2. Quick start: denoise in a few lines

Verify the model before full deployment:

import os
from modelscope.pipelines import pipeline
from modelscope.utils.constant import Tasks

# 1. Init pipeline
# Model: damo/speech_frcrn_ans_cirm_16k
ans_pipeline = pipeline(
    Tasks.acoustic_noise_suppression,
    model='damo/speech_frcrn_ans_cirm_16k'
)

# 2. Input / output paths
input_path = 'test_noisy.wav'  # Must be 16 kHz WAV
output_path = 'test_denoised.wav'

# 3. Run denoising
ans_pipeline(input_path, output_path=output_path)

print(f"Done! Output saved to: {output_path}")

The first run downloads the model (about 1–2 minutes depending on network).

3. Advanced: Web API with FastAPI

Wrap denoising as an HTTP API for frontends or microservices.

3.1 Install web stack

pip install fastapi uvicorn python-multipart

3.2 Server code main.py

from fastapi import FastAPI, UploadFile, File, HTTPException
from fastapi.responses import FileResponse
from modelscope.pipelines import pipeline
from modelscope.utils.constant import Tasks
import shutil
import uuid
import os

app = FastAPI(title="FRCRN Speech Denoising API")

# Load model once at startup
print("Loading Model...")
ans_pipeline = pipeline(
    Tasks.acoustic_noise_suppression,
    model='damo/speech_frcrn_ans_cirm_16k'
)
print("Model Loaded!")

@app.post("/denoise")
async def denoise_api(file: UploadFile = File(...)):
    task_id = str(uuid.uuid4())
    in_file = f"temp_in_{task_id}.wav"
    out_file = f"temp_out_{task_id}.wav"

    try:
        with open(in_file, "wb") as buffer:
            shutil.copyfileobj(file.file, buffer)

        ans_pipeline(in_file, output_path=out_file)

        return FileResponse(out_file, media_type="audio/wav", filename="denoised.wav")

    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))
    
    finally:
        if os.path.exists(in_file):
            os.remove(in_file)

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

4. Pitfalls

4.1 Sample rate must be 16 kHz

FRCRN is trained for 16 kHz. Feeding 44.1 kHz or 48 kHz audio may not error but quality will be poor (pitch artifacts or noise).

• Fix: Resample with librosa before inference.

4.2 GPU vs CPU

• With NVIDIA GPU + CUDA, ModelScope uses GPU automatically.
• Low VRAM: force CPU at init:

  ans_pipeline = pipeline(Tasks.acoustic_noise_suppression, model='...', device='cpu')
  

4.3 Long audio

Clips over ~5 minutes may OOM. Split into ~30 s segments in the API layer and concatenate outputs.

5. Summary

ModelScope’s FRCRN lets you build industrial-grade denoising cheaply.

Recap:

1. Stack: PyTorch + ModelScope.
2. Core: pipeline + damo/speech_frcrn_ans_cirm_16k.
3. Serving: FastAPI endpoint.
4. Rule: Input audio at 16,000 Hz.

For a stable open-source single-mic denoiser, FRCRN is an excellent default choice.