Upload 7 files

api.py

@@ -0,0 +1,41 @@
+# api.py
+from fastapi import FastAPI, UploadFile, File, Response
+from fastapi.middleware.cors import CORSMiddleware
+from inference import denoise_file_bytes  # this must exist in inference.py
+
+app = FastAPI(title="Audio Denoiser API")
+
+# Optional CORS (handy if you later call from a frontend)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # tighten later if needed
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+async def root():
+    return {"message": "Audio Denoiser API is running"}
+
+# IMPORTANT: this is POST, not GET
+@app.post("/denoise")
+async def denoise_endpoint(file: UploadFile = File(...)):
+    """
+    Upload a noisy audio file (wav), get back denoised audio bytes.
+    """
+    # Read uploaded file into bytes
+    contents = await file.read()
+
+    # Call your model inference – must return raw WAV bytes
+    denoised_bytes = denoise_file_bytes(contents)
+
+    # Return as an audio/wav HTTP response
+    return Response(
+        content=denoised_bytes,
+        media_type="audio/wav",
+        headers={
+            # Makes browser / client see it as downloadable file
+            "Content-Disposition": f'attachment; filename="denoised_{file.filename}"'
+        },
+    )

app.py

@@ -0,0 +1,57 @@
+# app.py
+import gradio as gr
+import torch
+import torchaudio
+
+from inference import denoise_waveform_tensor
+
+TITLE = "Advanced Audio Denoiser (Spectrogram U-Net)"
+DESCRIPTION = """
+Upload a noisy WAV/MP3 audio file and the model will try to remove background noise.
+This Space uses a ResUNet-based spectrogram denoiser trained by Prince.
+"""
+
+EXAMPLES = []  # You can add paths to example audio files if you upload some
+
+
+def denoise_gradio(input_audio):
+    """
+    input_audio: (filepath, sr) from Gradio
+    """
+    if input_audio is None:
+        return None
+
+    # Gradio passes (np.array, sr) by default with type="numpy"
+    waveform_np, sr = input_audio
+    # Convert to torch
+    waveform = torch.from_numpy(waveform_np).float().transpose(0, 1)  # (T, C) -> (C, T)
+    waveform = waveform.unsqueeze(0) if waveform.dim() == 1 else waveform
+
+    denoised, out_sr = denoise_waveform_tensor(waveform, sr)  # (1, T)
+    denoised_np = denoised.squeeze(0).numpy()
+
+    # Gradio expects (sr, np.array[T,])
+    return (out_sr, denoised_np)
+
+
+with gr.Blocks() as demo:
+    gr.Markdown(f"# {TITLE}")
+    gr.Markdown(DESCRIPTION)
+
+    with gr.Row():
+        with gr.Column():
+            inp = gr.Audio(
+                sources=["upload"],
+                type="numpy",
+                label="Upload noisy audio",
+            )
+            btn = gr.Button("Denoise")
+        with gr.Column():
+            out = gr.Audio(
+                type="numpy",
+                label="Denoised audio",
+            )
+
+    btn.click(denoise_gradio, inputs=inp, outputs=out)
+
+demo.launch()

best_denoiser_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a39212b3737ab29c4eb26aa8642d3a383919de24c945365d8dc17d16e51664b
+size 8132784

inference.py

@@ -0,0 +1,146 @@
+# inference.py
+import io
+import torch
+import torchaudio
+
+from model_def import AdvancedResUNet
+
+CONFIG = {
+    "sample_rate": 16000,
+    "n_fft": 1024,
+    "hop_length": 256,
+    "n_mels": 80,
+    "device": "cuda" if torch.cuda.is_available() else "cpu",
+    "model_path": "best_denoiser_model.pth",  # put this file in the Space
+}
+
+_model = None
+_mel_scale = None
+_inverse_mel = None
+_window = None
+
+
+def _get_device():
+    return CONFIG["device"]
+
+
+def load_model():
+    global _model, _mel_scale, _inverse_mel, _window
+
+    if _model is not None:
+        return _model
+
+    device = _get_device()
+
+    model = AdvancedResUNet().to(device)
+    state_dict = torch.load(CONFIG["model_path"], map_location=device)
+    model.load_state_dict(state_dict)
+    model.eval()
+
+    # Mel + Inverse Mel + window
+    _mel_scale = torchaudio.transforms.MelScale(
+        n_mels=CONFIG["n_mels"],
+        sample_rate=CONFIG["sample_rate"],
+        n_stft=CONFIG["n_fft"] // 2 + 1,
+    ).to(device)
+
+    _inverse_mel = torchaudio.transforms.InverseMelScale(
+        n_stft=CONFIG["n_fft"] // 2 + 1,
+        n_mels=CONFIG["n_mels"],
+        sample_rate=CONFIG["sample_rate"],
+    ).to(device)
+
+    _window = torch.hann_window(CONFIG["n_fft"]).to(device)
+
+    _model = model
+    print(f"[inference] Model loaded on {device}")
+    return _model
+
+
+def _normalize_waveform(waveform: torch.Tensor) -> torch.Tensor:
+    max_val = waveform.abs().max()
+    if max_val > 0:
+        waveform = waveform / max_val
+    return waveform
+
+
+def denoise_waveform_tensor(waveform: torch.Tensor, sr: int) -> torch.Tensor:
+    """
+    waveform: Tensor of shape (1, T) on CPU
+    returns: denoised waveform Tensor (1, T) on CPU
+    """
+    device = _get_device()
+    model = load_model()
+
+    # Ensure mono
+    if waveform.dim() == 2 and waveform.size(0) > 1:
+        waveform = waveform.mean(dim=0, keepdim=True)
+
+    # Resample if needed
+    if sr != CONFIG["sample_rate"]:
+        resampler = torchaudio.transforms.Resample(sr, CONFIG["sample_rate"])
+        waveform = resampler(waveform)
+
+    waveform = _normalize_waveform(waveform)
+    waveform = waveform.to(device)
+
+    global _mel_scale, _inverse_mel, _window
+
+    # --- STFT: get magnitude and phase ---
+    stft_complex = torch.stft(
+        waveform,
+        n_fft=CONFIG["n_fft"],
+        hop_length=CONFIG["hop_length"],
+        window=_window,
+        return_complex=True,
+    )  # (1, n_freq, n_frames)
+
+    noisy_phase = torch.angle(stft_complex)
+    noisy_mag = torch.abs(stft_complex)  # (1, n_freq, n_frames)
+
+    # Mel wants (batch, n_freq, time) -> we already have that
+    noisy_mel = _mel_scale(noisy_mag)  # (1, n_mels, n_frames)
+    noisy_log_mel = torch.log1p(noisy_mel + 1e-6)
+
+    # Model expects (B, 1, n_mels, T)
+    noisy_log_mel = noisy_log_mel.unsqueeze(1)  # (1, 1, n_mels, n_frames)
+
+    with torch.no_grad():
+        denoised_log_mel = model(noisy_log_mel)  # (1, 1, n_mels, n_frames)
+        denoised_log_mel = denoised_log_mel.squeeze(1)  # (1, n_mels, n_frames)
+
+    denoised_mel = torch.expm1(denoised_log_mel)
+    denoised_mel = torch.clamp(denoised_mel, min=0.0)
+
+    # Back to linear spectrogram magnitude
+    pred_mag = _inverse_mel(denoised_mel)  # (1, n_freq, n_frames)
+
+    # Combine predicted magnitude with original phase
+    complex_pred = pred_mag * torch.exp(1j * noisy_phase)
+
+    rec_waveform = torch.istft(
+        complex_pred,
+        n_fft=CONFIG["n_fft"],
+        hop_length=CONFIG["hop_length"],
+        window=_window,
+        length=waveform.shape[-1],
+    )  # (1, T) or (T,)
+
+    if rec_waveform.dim() == 1:
+        rec_waveform = rec_waveform.unsqueeze(0)
+
+    rec_waveform = _normalize_waveform(rec_waveform.cpu())
+    return rec_waveform  # (1, T) CPU
+
+
+def denoise_file_bytes(file_bytes: bytes):
+    """
+    For API / Gradio: takes input bytes, returns (waveform, sample_rate)
+    """
+    buf = io.BytesIO(file_bytes)
+    waveform, sr = torchaudio.load(buf)  # (channels, T), CPU
+    if waveform.dim() == 1:
+        waveform = waveform.unsqueeze(0)
+
+    denoised = denoise_waveform_tensor(waveform, sr)  # (1, T) CPU
+    return denoised, CONFIG["sample_rate"]

model_def.py

@@ -0,0 +1,79 @@
+# model_def.py
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class ResidualBlock(nn.Module):
+    def __init__(self, in_channels, out_channels):
+        super().__init__()
+        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1)
+        self.bn1 = nn.BatchNorm2d(out_channels)
+        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1)
+        self.bn2 = nn.BatchNorm2d(out_channels)
+
+        self.shortcut = nn.Sequential()
+        if in_channels != out_channels:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_channels, out_channels, kernel_size=1),
+                nn.BatchNorm2d(out_channels)
+            )
+
+    def forward(self, x):
+        residual = self.shortcut(x)
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = self.bn2(self.conv2(out))
+        out += residual
+        return F.relu(out)
+
+class AdvancedResUNet(nn.Module):
+    def __init__(self):
+        super().__init__()
+        # Encoder
+        self.enc1 = ResidualBlock(1, 32)
+        self.pool1 = nn.MaxPool2d(2)
+        self.enc2 = ResidualBlock(32, 64)
+        self.pool2 = nn.MaxPool2d(2)
+        self.enc3 = ResidualBlock(64, 128)
+        self.pool3 = nn.MaxPool2d(2)
+        # Bottleneck
+        self.bottleneck = ResidualBlock(128, 256)
+        # Decoder
+        self.up3 = nn.ConvTranspose2d(256, 128, kernel_size=2, stride=2)
+        self.dec3 = ResidualBlock(256, 128)
+        self.up2 = nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2)
+        self.dec2 = ResidualBlock(128, 64)
+        self.up1 = nn.ConvTranspose2d(64, 32, kernel_size=2, stride=2)
+        self.dec1 = ResidualBlock(64, 32)
+
+        self.final_conv = nn.Conv2d(32, 1, kernel_size=1)
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        e1 = self.enc1(x)
+        p1 = self.pool1(e1)
+        e2 = self.enc2(p1)
+        p2 = self.pool2(e2)
+        e3 = self.enc3(p2)
+        p3 = self.pool3(e3)
+        b = self.bottleneck(p3)
+
+        d3 = self.up3(b)
+        if d3.shape != e3.shape:
+            d3 = F.interpolate(d3, size=e3.shape[2:])
+        d3 = torch.cat([d3, e3], dim=1)
+        d3 = self.dec3(d3)
+
+        d2 = self.up2(d3)
+        if d2.shape != e2.shape:
+            d2 = F.interpolate(d2, size=e2.shape[2:])
+        d2 = torch.cat([d2, e2], dim=1)
+        d2 = self.dec2(d2)
+
+        d1 = self.up1(d2)
+        if d1.shape != e1.shape:
+            d1 = F.interpolate(d1, size=e1.shape[2:])
+        d1 = torch.cat([d1, e1], dim=1)
+        d1 = self.dec1(d1)
+
+        mask = self.sigmoid(self.final_conv(d1))
+        return x * mask

requirement.txt

@@ -0,0 +1,8 @@
+install python modules
+
+fastapi
+uvicorn
+torch
+torchaudio
+requests
+gradio

test_api_client.py

@@ -0,0 +1,31 @@
+# test_api_client.py
+import requests
+import os
+
+API_URL = "http://127.0.0.1:8000/denoise"
+
+# path to one noisy test file
+INPUT_WAV = r"E:\Test Audio Data\Test Audio Data\example_noisy.wav"
+OUTPUT_WAV = r"E:\Test Audio Data\Test Audio Data\example_noisy_denoised_from_api.wav"
+
+def test_denoise():
+    if not os.path.exists(INPUT_WAV):
+        print("Input file not found:", INPUT_WAV)
+        return
+
+    with open(INPUT_WAV, "rb") as f:
+        files = {"file": ("example_noisy.wav", f, "audio/wav")}
+        resp = requests.post(API_URL, files=files)
+
+    print("Status code:", resp.status_code)
+
+    if resp.status_code == 200:
+        with open(OUTPUT_WAV, "wb") as out_f:
+            out_f.write(resp.content)
+        print("Saved denoised file to:", OUTPUT_WAV)
+    else:
+        print("Error response body:")
+        print(resp.text)
+
+if __name__ == "__main__":
+    test_denoise()