speech_denoiser_DCUNet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9oX5DLS3COS5"
   },
   "source": [
    "# Speech Denoising without Clean Training Data: a Noise2Noise Approach #"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Enter the noise type you want to train the model to denoise. The test and train dataset must already be generated beforehand. ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### white : additive_gaussian_noise ###\n",
    "### 0 : air_conditioner ###\n",
    "### 1 : car_horn ###\n",
    "### 2 : children_playing ###\n",
    "### 3 : dog_bark ###\n",
    "### 4 : drilling ###\n",
    "### 5 : engine_idling ###\n",
    "### 6 : gun_shot ###\n",
    "### 7 : jackhammer ###\n",
    "### 8 : siren ###\n",
    "### 9 : street_music ###\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "noise_class = \"white\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Specify the type of training you want to employ: either \"Noise2Noise\" or \"Noise2Clean\"  ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_type =  \"Noise2Noise\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FiXUioRtCOS6"
   },
   "source": [
    "### Import of libraries ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "if noise_class == \"white\": \n",
    "    TRAIN_INPUT_DIR = Path('Datasets/WhiteNoise_Train_Input')\n",
    "\n",
    "    if training_type == \"Noise2Noise\":\n",
    "        TRAIN_TARGET_DIR = Path('Datasets/WhiteNoise_Train_Output')\n",
    "    elif training_type == \"Noise2Clean\":\n",
    "        TRAIN_TARGET_DIR = Path('Datasets/clean_trainset_28spk_wav')\n",
    "    else:\n",
    "        raise Exception(\"Enter valid training type\")\n",
    "\n",
    "    TEST_NOISY_DIR = Path('Datasets/WhiteNoise_Test_Input')\n",
    "    TEST_CLEAN_DIR = Path('Datasets/clean_testset_wav') \n",
    "    \n",
    "else:\n",
    "    TRAIN_INPUT_DIR = Path('Datasets/US_Class'+str(noise_class)+'_Train_Input')\n",
    "\n",
    "    if training_type == \"Noise2Noise\":\n",
    "        TRAIN_TARGET_DIR = Path('Datasets/US_Class'+str(noise_class)+'_Train_Output')\n",
    "    elif training_type == \"Noise2Clean\":\n",
    "        TRAIN_TARGET_DIR = Path('Datasets/clean_trainset_28spk_wav')\n",
    "    else:\n",
    "        raise Exception(\"Enter valid training type\")\n",
    "\n",
    "    TEST_NOISY_DIR = Path('Datasets/US_Class'+str(noise_class)+'_Test_Input')\n",
    "    TEST_CLEAN_DIR = Path('Datasets/clean_testset_wav') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "basepath = str(noise_class)+\"_\"+training_type\n",
    "os.makedirs(basepath,exist_ok=True)\n",
    "os.makedirs(basepath+\"/Weights\",exist_ok=True)\n",
    "os.makedirs(basepath+\"/Samples\",exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "D0bWtt2J5i9F"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\madha\\.conda\\envs\\Noise2Noise-audio-denoising\\lib\\site-packages\\torchaudio\\extension\\extension.py:13: UserWarning: torchaudio C++ extension is not available.\n",
      "  warnings.warn('torchaudio C++ extension is not available.')\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import pickle\n",
    "import warnings\n",
    "import gc\n",
    "import copy\n",
    "\n",
    "import noise_addition_utils\n",
    "\n",
    "from metrics import AudioMetrics\n",
    "from metrics import AudioMetrics2\n",
    "\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchaudio\n",
    "\n",
    "from tqdm import tqdm, tqdm_notebook\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from matplotlib import colors, pyplot as plt\n",
    "from pypesq import pesq\n",
    "from IPython.display import clear_output\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "# not everything is smooth in sklearn, to conveniently output images in colab\n",
    "# we will ignore warnings\n",
    "warnings.filterwarnings(action='ignore', category=DeprecationWarning)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(999)\n",
    "torch.manual_seed(999)\n",
    "\n",
    "# If running on Cuda set these 2 for determinism\n",
    "torch.backends.cudnn.deterministic = True\n",
    "torch.backends.cudnn.benchmark = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-xnlgTsICOTA"
   },
   "source": [
    "### Checking whether the GPU is available ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "byUnPtQ25i9O",
    "outputId": "4b6d9f85-e5b6-4cb5-c3db-2f48321ed391"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No GPU available, training on CPU.\n"
     ]
    }
   ],
   "source": [
    "# First checking if GPU is available\n",
    "train_on_gpu=torch.cuda.is_available()\n",
    "\n",
    "if(train_on_gpu):\n",
    "    print('Training on GPU.')\n",
    "else:\n",
    "    print('No GPU available, training on CPU.')\n",
    "       \n",
    "DEVICE = torch.device('cuda' if train_on_gpu else 'cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "colab_type": "code",
    "id": "qacrfNwA6vw_",
    "outputId": "e1183ab5-4f39-478a-b00a-74fe5edfb511"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "'nvidia-smi' is not recognized as an internal or external command,\n",
      "operable program or batch file.\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_N4AFJANDcBG"
   },
   "source": [
    "### Set Audio backend as Soundfile for windows and Sox for Linux ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_N4AFJANDcBG"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TorchAudio backend used:\tsoundfile\n"
     ]
    }
   ],
   "source": [
    "torchaudio.set_audio_backend(\"soundfile\")\n",
    "print(\"TorchAudio backend used:\\t{}\".format(torchaudio.get_audio_backend()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IWvlIABzCOTM"
   },
   "source": [
    "### The sampling frequency and the selected values for the Short-time Fourier transform. ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8ngFJtPj5i9V"
   },
   "outputs": [],
   "source": [
    "SAMPLE_RATE = 48000\n",
    "N_FFT = (SAMPLE_RATE * 64) // 1000 \n",
    "HOP_LENGTH = (SAMPLE_RATE * 16) // 1000 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "x8suREWkb5Se"
   },
   "source": [
    "### The declaration of datasets and dataloaders ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cZ0wb9EN5i9f"
   },
   "outputs": [],
   "source": [
    "class SpeechDataset(Dataset):\n",
    "    \"\"\"\n",
    "    A dataset class with audio that cuts them/paddes them to a specified length, applies a Short-tome Fourier transform,\n",
    "    normalizes and leads to a tensor.\n",
    "    \"\"\"\n",
    "    def __init__(self, noisy_files, clean_files, n_fft=64, hop_length=16):\n",
    "        super().__init__()\n",
    "        # list of files\n",
    "        self.noisy_files = sorted(noisy_files)\n",
    "        self.clean_files = sorted(clean_files)\n",
    "        \n",
    "        # stft parameters\n",
    "        self.n_fft = n_fft\n",
    "        self.hop_length = hop_length\n",
    "        \n",
    "        self.len_ = len(self.noisy_files)\n",
    "        \n",
    "        # fixed len\n",
    "        self.max_len = 165000\n",
    "\n",
    "    \n",
    "    def __len__(self):\n",
    "        return self.len_\n",
    "      \n",
    "    def load_sample(self, file):\n",
    "        waveform, _ = torchaudio.load(file)\n",
    "        return waveform\n",
    "  \n",
    "    def __getitem__(self, index):\n",
    "        # load to tensors and normalization\n",
    "        x_clean = self.load_sample(self.clean_files[index])\n",
    "        x_noisy = self.load_sample(self.noisy_files[index])\n",
    "        \n",
    "        # padding/cutting\n",
    "        x_clean = self._prepare_sample(x_clean)\n",
    "        x_noisy = self._prepare_sample(x_noisy)\n",
    "        \n",
    "        # Short-time Fourier transform\n",
    "        x_noisy_stft = torch.stft(input=x_noisy, n_fft=self.n_fft, \n",
    "                                  hop_length=self.hop_length, normalized=True)\n",
    "        x_clean_stft = torch.stft(input=x_clean, n_fft=self.n_fft, \n",
    "                                  hop_length=self.hop_length, normalized=True)\n",
    "        \n",
    "        return x_noisy_stft, x_clean_stft\n",
    "        \n",
    "    def _prepare_sample(self, waveform):\n",
    "        waveform = waveform.numpy()\n",
    "        current_len = waveform.shape[1]\n",
    "        \n",
    "        output = np.zeros((1, self.max_len), dtype='float32')\n",
    "        output[0, -current_len:] = waveform[0, :self.max_len]\n",
    "        output = torch.from_numpy(output)\n",
    "        \n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8NLV2lcv5i9k"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No. of Training files: 0\n",
      "No. of Testing files: 0\n"
     ]
    }
   ],
   "source": [
    "train_input_files = sorted(list(TRAIN_INPUT_DIR.rglob('*.wav')))\n",
    "train_target_files = sorted(list(TRAIN_TARGET_DIR.rglob('*.wav')))\n",
    "\n",
    "test_noisy_files = sorted(list(TEST_NOISY_DIR.rglob('*.wav')))\n",
    "test_clean_files = sorted(list(TEST_CLEAN_DIR.rglob('*.wav')))\n",
    "\n",
    "print(\"No. of Training files:\",len(train_input_files))\n",
    "print(\"No. of Testing files:\",len(test_noisy_files))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7GHaKjYS5i9u"
   },
   "outputs": [],
   "source": [
    "test_dataset = SpeechDataset(test_noisy_files, test_clean_files, N_FFT, HOP_LENGTH)\n",
    "train_dataset = SpeechDataset(train_input_files, train_target_files, N_FFT, HOP_LENGTH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "79nIQjht5i9y"
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "num_samples should be a positive integer value, but got num_samples=0",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-14-4fd094205701>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtest_loader\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mDataLoader\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_dataset\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mshuffle\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mtrain_loader\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mDataLoader\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtrain_dataset\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mshuffle\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;31m# For testing purpose\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mtest_loader_single_unshuffled\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mDataLoader\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_dataset\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mshuffle\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\.conda\\envs\\Noise2Noise-audio-denoising\\lib\\site-packages\\torch\\utils\\data\\dataloader.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, dataset, batch_size, shuffle, sampler, batch_sampler, num_workers, collate_fn, pin_memory, drop_last, timeout, worker_init_fn, multiprocessing_context, generator, prefetch_factor, persistent_workers)\u001b[0m\n\u001b[0;32m    264\u001b[0m                     \u001b[1;31m# Cannot statically verify that dataset is Sized\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    265\u001b[0m                     \u001b[1;31m# Somewhat related: see NOTE [ Lack of Default `__len__` in Python Abstract Base Classes ]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 266\u001b[1;33m                     \u001b[0msampler\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mRandomSampler\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdataset\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgenerator\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mgenerator\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# type: ignore\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    267\u001b[0m                 \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    268\u001b[0m                     \u001b[0msampler\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mSequentialSampler\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdataset\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\.conda\\envs\\Noise2Noise-audio-denoising\\lib\\site-packages\\torch\\utils\\data\\sampler.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, data_source, replacement, num_samples, generator)\u001b[0m\n\u001b[0;32m    101\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    102\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnum_samples\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mint\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnum_samples\u001b[0m \u001b[1;33m<=\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 103\u001b[1;33m             raise ValueError(\"num_samples should be a positive integer \"\n\u001b[0m\u001b[0;32m    104\u001b[0m                              \"value, but got num_samples={}\".format(self.num_samples))\n\u001b[0;32m    105\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: num_samples should be a positive integer value, but got num_samples=0"
     ]
    }
   ],
   "source": [
    "test_loader = DataLoader(test_dataset, batch_size=1, shuffle=True)\n",
    "train_loader = DataLoader(train_dataset, batch_size=2, shuffle=True)\n",
    "\n",
    "# For testing purpose\n",
    "test_loader_single_unshuffled = DataLoader(test_dataset, batch_size=1, shuffle=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tHJZXeUQcsrq"
   },
   "source": [
    "### Average Test Set Metrics ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_set_metrics(test_loader, model):\n",
    "    metric_names = [\"CSIG\",\"CBAK\",\"COVL\",\"PESQ\",\"SSNR\",\"STOI\"]\n",
    "    overall_metrics = [[] for i in range(len(metric_names))]\n",
    "    \n",
    "    for i,(noisy,clean) in enumerate(test_loader):\n",
    "        x_est = model(noisy.to(DEVICE), is_istft=True)\n",
    "        x_est_np = x_est[0].view(-1).detach().cpu().numpy()\n",
    "        x_c_np = torch.istft(torch.squeeze(clean[0], 1), n_fft=N_FFT, hop_length=HOP_LENGTH, normalized=True).view(-1).detach().cpu().numpy()\n",
    "        metrics = AudioMetrics(x_c_np, x_est_np, SAMPLE_RATE)\n",
    "        \n",
    "        overall_metrics[0].append(metrics.CSIG)\n",
    "        overall_metrics[1].append(metrics.CBAK)\n",
    "        overall_metrics[2].append(metrics.COVL)\n",
    "        overall_metrics[3].append(metrics.PESQ)\n",
    "        overall_metrics[4].append(metrics.SSNR)\n",
    "        overall_metrics[5].append(metrics.STOI)\n",
    "    \n",
    "    metrics_dict = dict()\n",
    "    for i in range(len(metric_names)):\n",
    "        metrics_dict[metric_names[i]] ={'mean': np.mean(overall_metrics[i]), 'std_dev': np.std(overall_metrics[i])} \n",
    "    \n",
    "    return metrics_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "k73YEkgQCOTj"
   },
   "source": [
    "### Declaring the class layers ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Znx7QM3h5i92"
   },
   "outputs": [],
   "source": [
    "class CConv2d(nn.Module):\n",
    "    \"\"\"\n",
    "    Class of complex valued convolutional layer\n",
    "    \"\"\"\n",
    "    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.in_channels = in_channels\n",
    "        self.out_channels = out_channels\n",
    "        self.kernel_size = kernel_size\n",
    "        self.padding = padding\n",
    "        self.stride = stride\n",
    "        \n",
    "        self.real_conv = nn.Conv2d(in_channels=self.in_channels, \n",
    "                                   out_channels=self.out_channels, \n",
    "                                   kernel_size=self.kernel_size, \n",
    "                                   padding=self.padding, \n",
    "                                   stride=self.stride)\n",
    "        \n",
    "        self.im_conv = nn.Conv2d(in_channels=self.in_channels, \n",
    "                                 out_channels=self.out_channels, \n",
    "                                 kernel_size=self.kernel_size, \n",
    "                                 padding=self.padding, \n",
    "                                 stride=self.stride)\n",
    "        \n",
    "        # Glorot initialization.\n",
    "        nn.init.xavier_uniform_(self.real_conv.weight)\n",
    "        nn.init.xavier_uniform_(self.im_conv.weight)\n",
    "        \n",
    "        \n",
    "    def forward(self, x):\n",
    "        x_real = x[..., 0]\n",
    "        x_im = x[..., 1]\n",
    "        \n",
    "        c_real = self.real_conv(x_real) - self.im_conv(x_im)\n",
    "        c_im = self.im_conv(x_real) + self.real_conv(x_im)\n",
    "        \n",
    "        output = torch.stack([c_real, c_im], dim=-1)\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GgtxJbSQ5i96"
   },
   "outputs": [],
   "source": [
    "class CConvTranspose2d(nn.Module):\n",
    "    \"\"\"\n",
    "      Class of complex valued dilation convolutional layer\n",
    "    \"\"\"\n",
    "    def __init__(self, in_channels, out_channels, kernel_size, stride, output_padding=0, padding=0):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.in_channels = in_channels\n",
    "\n",
    "        self.out_channels = out_channels\n",
    "        self.kernel_size = kernel_size\n",
    "        self.output_padding = output_padding\n",
    "        self.padding = padding\n",
    "        self.stride = stride\n",
    "        \n",
    "        self.real_convt = nn.ConvTranspose2d(in_channels=self.in_channels, \n",
    "                                            out_channels=self.out_channels, \n",
    "                                            kernel_size=self.kernel_size, \n",
    "                                            output_padding=self.output_padding,\n",
    "                                            padding=self.padding,\n",
    "                                            stride=self.stride)\n",
    "        \n",
    "        self.im_convt = nn.ConvTranspose2d(in_channels=self.in_channels, \n",
    "                                            out_channels=self.out_channels, \n",
    "                                            kernel_size=self.kernel_size, \n",
    "                                            output_padding=self.output_padding, \n",
    "                                            padding=self.padding,\n",
    "                                            stride=self.stride)\n",
    "        \n",
    "        \n",
    "        # Glorot initialization.\n",
    "        nn.init.xavier_uniform_(self.real_convt.weight)\n",
    "        nn.init.xavier_uniform_(self.im_convt.weight)\n",
    "        \n",
    "        \n",
    "    def forward(self, x):\n",
    "        x_real = x[..., 0]\n",
    "        x_im = x[..., 1]\n",
    "        \n",
    "        ct_real = self.real_convt(x_real) - self.im_convt(x_im)\n",
    "        ct_im = self.im_convt(x_real) + self.real_convt(x_im)\n",
    "        \n",
    "        output = torch.stack([ct_real, ct_im], dim=-1)\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OJSmVrxp5i9-"
   },
   "outputs": [],
   "source": [
    "class CBatchNorm2d(nn.Module):\n",
    "    \"\"\"\n",
    "    Class of complex valued batch normalization layer\n",
    "    \"\"\"\n",
    "    def __init__(self, num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.num_features = num_features\n",
    "        self.eps = eps\n",
    "        self.momentum = momentum\n",
    "        self.affine = affine\n",
    "        self.track_running_stats = track_running_stats\n",
    "        \n",
    "        self.real_b = nn.BatchNorm2d(num_features=self.num_features, eps=self.eps, momentum=self.momentum,\n",
    "                                      affine=self.affine, track_running_stats=self.track_running_stats)\n",
    "        self.im_b = nn.BatchNorm2d(num_features=self.num_features, eps=self.eps, momentum=self.momentum,\n",
    "                                    affine=self.affine, track_running_stats=self.track_running_stats) \n",
    "        \n",
    "    def forward(self, x):\n",
    "        x_real = x[..., 0]\n",
    "        x_im = x[..., 1]\n",
    "        \n",
    "        n_real = self.real_b(x_real)\n",
    "        n_im = self.im_b(x_im)  \n",
    "        \n",
    "        output = torch.stack([n_real, n_im], dim=-1)\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "N7W37XMO5i-B"
   },
   "outputs": [],
   "source": [
    "class Encoder(nn.Module):\n",
    "    \"\"\"\n",
    "    Class of upsample block\n",
    "    \"\"\"\n",
    "    def __init__(self, filter_size=(7,5), stride_size=(2,2), in_channels=1, out_channels=45, padding=(0,0)):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.filter_size = filter_size\n",
    "        self.stride_size = stride_size\n",
    "        self.in_channels = in_channels\n",
    "        self.out_channels = out_channels\n",
    "        self.padding = padding\n",
    "\n",
    "        self.cconv = CConv2d(in_channels=self.in_channels, out_channels=self.out_channels, \n",
    "                             kernel_size=self.filter_size, stride=self.stride_size, padding=self.padding)\n",
    "        \n",
    "        self.cbn = CBatchNorm2d(num_features=self.out_channels) \n",
    "        \n",
    "        self.leaky_relu = nn.LeakyReLU()\n",
    "            \n",
    "    def forward(self, x):\n",
    "        \n",
    "        conved = self.cconv(x)\n",
    "        normed = self.cbn(conved)\n",
    "        acted = self.leaky_relu(normed)\n",
    "        \n",
    "        return acted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "fuugYDZs5i-G"
   },
   "outputs": [],
   "source": [
    "class Decoder(nn.Module):\n",
    "    \"\"\"\n",
    "    Class of downsample block\n",
    "    \"\"\"\n",
    "    def __init__(self, filter_size=(7,5), stride_size=(2,2), in_channels=1, out_channels=45,\n",
    "                 output_padding=(0,0), padding=(0,0), last_layer=False):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.filter_size = filter_size\n",
    "        self.stride_size = stride_size\n",
    "        self.in_channels = in_channels\n",
    "        self.out_channels = out_channels\n",
    "        self.output_padding = output_padding\n",
    "        self.padding = padding\n",
    "        \n",
    "        self.last_layer = last_layer\n",
    "        \n",
    "        self.cconvt = CConvTranspose2d(in_channels=self.in_channels, out_channels=self.out_channels, \n",
    "                             kernel_size=self.filter_size, stride=self.stride_size, output_padding=self.output_padding, padding=self.padding)\n",
    "        \n",
    "        self.cbn = CBatchNorm2d(num_features=self.out_channels) \n",
    "        \n",
    "        self.leaky_relu = nn.LeakyReLU()\n",
    "            \n",
    "    def forward(self, x):\n",
    "        \n",
    "        conved = self.cconvt(x)\n",
    "        \n",
    "        if not self.last_layer:\n",
    "            normed = self.cbn(conved)\n",
    "            output = self.leaky_relu(normed)\n",
    "        else:\n",
    "            m_phase = conved / (torch.abs(conved) + 1e-8)\n",
    "            m_mag = torch.tanh(torch.abs(conved))\n",
    "            output = m_phase * m_mag\n",
    "            \n",
    "        return output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3G5CqR3-COT8"
   },
   "source": [
    "### Loss function ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "J71ny6expQeW"
   },
   "outputs": [],
   "source": [
    "from pesq import pesq\n",
    "from scipy import interpolate\n",
    "\n",
    "def resample(original, old_rate, new_rate):\n",
    "    if old_rate != new_rate:\n",
    "        duration = original.shape[0] / old_rate\n",
    "        time_old  = np.linspace(0, duration, original.shape[0])\n",
    "        time_new  = np.linspace(0, duration, int(original.shape[0] * new_rate / old_rate))\n",
    "        interpolator = interpolate.interp1d(time_old, original.T)\n",
    "        new_audio = interpolator(time_new).T\n",
    "        return new_audio\n",
    "    else:\n",
    "        return original\n",
    "\n",
    "\n",
    "def wsdr_fn(x_, y_pred_, y_true_, eps=1e-8):\n",
    "    # to time-domain waveform\n",
    "    y_true_ = torch.squeeze(y_true_, 1)\n",
    "    y_true = torch.istft(y_true_, n_fft=N_FFT, hop_length=HOP_LENGTH, normalized=True)\n",
    "    x_ = torch.squeeze(x_, 1)\n",
    "    x = torch.istft(x_, n_fft=N_FFT, hop_length=HOP_LENGTH, normalized=True)\n",
    "\n",
    "    y_pred = y_pred_.flatten(1)\n",
    "    y_true = y_true.flatten(1)\n",
    "    x = x.flatten(1)\n",
    "\n",
    "\n",
    "    def sdr_fn(true, pred, eps=1e-8):\n",
    "        num = torch.sum(true * pred, dim=1)\n",
    "        den = torch.norm(true, p=2, dim=1) * torch.norm(pred, p=2, dim=1)\n",
    "        return -(num / (den + eps))\n",
    "\n",
    "    # true and estimated noise\n",
    "    z_true = x - y_true\n",
    "    z_pred = x - y_pred\n",
    "\n",
    "    a = torch.sum(y_true**2, dim=1) / (torch.sum(y_true**2, dim=1) + torch.sum(z_true**2, dim=1) + eps)\n",
    "    wSDR = a * sdr_fn(y_true, y_pred) + (1 - a) * sdr_fn(z_true, z_pred)\n",
    "    return torch.mean(wSDR)\n",
    "\n",
    "wonky_samples = []\n",
    "\n",
    "def getMetricsonLoader(loader, net, use_net=True):\n",
    "    net.eval()\n",
    "    # Original test metrics\n",
    "    scale_factor = 32768\n",
    "    # metric_names = [\"CSIG\",\"CBAK\",\"COVL\",\"PESQ\",\"SSNR\",\"STOI\",\"SNR \"]\n",
    "    metric_names = [\"PESQ-WB\",\"PESQ-NB\",\"SNR\",\"SSNR\",\"STOI\"]\n",
    "    overall_metrics = [[] for i in range(5)]\n",
    "    for i, data in enumerate(loader):\n",
    "        if (i+1)%10==0:\n",
    "            end_str = \"\\n\"\n",
    "        else:\n",
    "            end_str = \",\"\n",
    "        #print(i,end=end_str)\n",
    "        if i in wonky_samples:\n",
    "            print(\"Something's up with this sample. Passing...\")\n",
    "        else:\n",
    "            noisy = data[0]\n",
    "            clean = data[1]\n",
    "            if use_net: # Forward of net returns the istft version\n",
    "                x_est = net(noisy.to(DEVICE), is_istft=True)\n",
    "                x_est_np = x_est.view(-1).detach().cpu().numpy()\n",
    "            else:\n",
    "                x_est_np = torch.istft(torch.squeeze(noisy, 1), n_fft=N_FFT, hop_length=HOP_LENGTH, normalized=True).view(-1).detach().cpu().numpy()\n",
    "            x_clean_np = torch.istft(torch.squeeze(clean, 1), n_fft=N_FFT, hop_length=HOP_LENGTH, normalized=True).view(-1).detach().cpu().numpy()\n",
    "            \n",
    "        \n",
    "            metrics = AudioMetrics2(x_clean_np, x_est_np, 48000)\n",
    "            \n",
    "            ref_wb = resample(x_clean_np, 48000, 16000)\n",
    "            deg_wb = resample(x_est_np, 48000, 16000)\n",
    "            pesq_wb = pesq(16000, ref_wb, deg_wb, 'wb')\n",
    "            \n",
    "            ref_nb = resample(x_clean_np, 48000, 8000)\n",
    "            deg_nb = resample(x_est_np, 48000, 8000)\n",
    "            pesq_nb = pesq(8000, ref_nb, deg_nb, 'nb')\n",
    "\n",
    "            #print(new_scores)\n",
    "            #print(metrics.PESQ, metrics.STOI)\n",
    "\n",
    "            overall_metrics[0].append(pesq_wb)\n",
    "            overall_metrics[1].append(pesq_nb)\n",
    "            overall_metrics[2].append(metrics.SNR)\n",
    "            overall_metrics[3].append(metrics.SSNR)\n",
    "            overall_metrics[4].append(metrics.STOI)\n",
    "    print()\n",
    "    print(\"Sample metrics computed\")\n",
    "    results = {}\n",
    "    for i in range(5):\n",
    "        temp = {}\n",
    "        temp[\"Mean\"] =  np.mean(overall_metrics[i])\n",
    "        temp[\"STD\"]  =  np.std(overall_metrics[i])\n",
    "        temp[\"Min\"]  =  min(overall_metrics[i])\n",
    "        temp[\"Max\"]  =  max(overall_metrics[i])\n",
    "        results[metric_names[i]] = temp\n",
    "    print(\"Averages computed\")\n",
    "    if use_net:\n",
    "        addon = \"(cleaned by model)\"\n",
    "    else:\n",
    "        addon = \"(pre denoising)\"\n",
    "    print(\"Metrics on test data\",addon)\n",
    "    for i in range(5):\n",
    "        print(\"{} : {:.3f}+/-{:.3f}\".format(metric_names[i], np.mean(overall_metrics[i]), np.std(overall_metrics[i])))\n",
    "    return results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kYvWz_6jRZ3e"
   },
   "source": [
    "### Description of the training of epochs. ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "VukJTCGIZ8ZU"
   },
   "outputs": [],
   "source": [
    "def train_epoch(net, train_loader, loss_fn, optimizer):\n",
    "    net.train()\n",
    "    train_ep_loss = 0.\n",
    "    counter = 0\n",
    "    for noisy_x, clean_x in train_loader:\n",
    "\n",
    "        noisy_x, clean_x = noisy_x.to(DEVICE), clean_x.to(DEVICE)\n",
    "\n",
    "        # zero  gradients\n",
    "        net.zero_grad()\n",
    "\n",
    "        # get the output from the model\n",
    "        pred_x = net(noisy_x)\n",
    "\n",
    "        # calculate loss\n",
    "        loss = loss_fn(noisy_x, pred_x, clean_x)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        train_ep_loss += loss.item() \n",
    "        counter += 1\n",
    "\n",
    "    train_ep_loss /= counter\n",
    "\n",
    "    # clear cache\n",
    "    gc.collect()\n",
    "    torch.cuda.empty_cache()\n",
    "    return train_ep_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zYCJWaTMRgS3"
   },
   "source": [
    "### Description of the validation of epochs ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-JKrTMpPhw19"
   },
   "outputs": [],
   "source": [
    "def test_epoch(net, test_loader, loss_fn, use_net=True):\n",
    "    net.eval()\n",
    "    test_ep_loss = 0.\n",
    "    counter = 0.\n",
    "    '''\n",
    "    for noisy_x, clean_x in test_loader:\n",
    "        # get the output from the model\n",
    "        noisy_x, clean_x = noisy_x.to(DEVICE), clean_x.to(DEVICE)\n",
    "        pred_x = net(noisy_x)\n",
    "\n",
    "        # calculate loss\n",
    "        loss = loss_fn(noisy_x, pred_x, clean_x)\n",
    "        # Calc the metrics here\n",
    "        test_ep_loss += loss.item() \n",
    "        \n",
    "        counter += 1\n",
    "\n",
    "    test_ep_loss /= counter\n",
    "    '''\n",
    "    \n",
    "    #print(\"Actual compute done...testing now\")\n",
    "    \n",
    "    testmet = getMetricsonLoader(test_loader,net,use_net)\n",
    "\n",
    "    # clear cache\n",
    "    gc.collect()\n",
    "    torch.cuda.empty_cache()\n",
    "    \n",
    "    return test_ep_loss, testmet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "879vq_uBRm_2"
   },
   "source": [
    "### To understand whether the network is being trained or not, we will output a train and test loss. ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "I4gdVmhRr1Qi"
   },
   "outputs": [],
   "source": [
    "def train(net, train_loader, test_loader, loss_fn, optimizer, scheduler, epochs):\n",
    "    \n",
    "    train_losses = []\n",
    "    test_losses = []\n",
    "\n",
    "    for e in tqdm(range(epochs)):\n",
    "\n",
    "        # first evaluating for comparison\n",
    "        \n",
    "        if e == 0 and training_type==\"Noise2Clean\":\n",
    "            print(\"Pre-training evaluation\")\n",
    "            #with torch.no_grad():\n",
    "            #    test_loss,testmet = test_epoch(net, test_loader, loss_fn,use_net=False)\n",
    "            #print(\"Had to load model.. checking if deets match\")\n",
    "            testmet = getMetricsonLoader(test_loader,net,False)    # again, modified cuz im loading\n",
    "            #test_losses.append(test_loss)\n",
    "            #print(\"Loss before training:{:.6f}\".format(test_loss))\n",
    "        \n",
    "            with open(basepath + \"/results.txt\",\"w+\") as f:\n",
    "                f.write(\"Initial : \\n\")\n",
    "                f.write(str(testmet))\n",
    "                f.write(\"\\n\")\n",
    "        \n",
    "        \n",
    "        train_loss = train_epoch(net, train_loader, loss_fn, optimizer)\n",
    "        test_loss = 0\n",
    "        scheduler.step()\n",
    "        print(\"Saving model....\")\n",
    "        \n",
    "        with torch.no_grad():\n",
    "            test_loss, testmet = test_epoch(net, test_loader, loss_fn,use_net=True)\n",
    "\n",
    "        train_losses.append(train_loss)\n",
    "        test_losses.append(test_loss)\n",
    "        \n",
    "        #print(\"skipping testing cuz peak autism idk\")\n",
    "        \n",
    "        with open(basepath + \"/results.txt\",\"a\") as f:\n",
    "            f.write(\"Epoch :\"+str(e+1) + \"\\n\" + str(testmet))\n",
    "            f.write(\"\\n\")\n",
    "        \n",
    "        print(\"OPed to txt\")\n",
    "        \n",
    "        torch.save(net.state_dict(), basepath +'/Weights/dc20_model_'+str(e+1)+'.pth')\n",
    "        torch.save(optimizer.state_dict(), basepath+'/Weights/dc20_opt_'+str(e+1)+'.pth')\n",
    "        \n",
    "        print(\"Models saved\")\n",
    "\n",
    "        # clear cache\n",
    "        torch.cuda.empty_cache()\n",
    "        gc.collect()\n",
    "\n",
    "        #print(\"Epoch: {}/{}...\".format(e+1, epochs),\n",
    "        #              \"Loss: {:.6f}...\".format(train_loss),\n",
    "        #              \"Test Loss: {:.6f}\".format(test_loss))\n",
    "    return train_loss, test_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HO3p2zrOcn_z"
   },
   "source": [
    "### 20 Layer DCUNet Model ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "j8XCrVIg5i-K"
   },
   "outputs": [],
   "source": [
    "class DCUnet20(nn.Module):\n",
    "    \"\"\"\n",
    "    Deep Complex U-Net class of the model.\n",
    "    \"\"\"\n",
    "    def __init__(self, n_fft=64, hop_length=16):\n",
    "        super().__init__()\n",
    "        \n",
    "        # for istft\n",
    "        self.n_fft = n_fft\n",
    "        self.hop_length = hop_length\n",
    "        \n",
    "        self.set_size(model_complexity=int(45//1.414), input_channels=1, model_depth=20)\n",
    "        self.encoders = []\n",
    "        self.model_length = 20 // 2\n",
    "        \n",
    "        for i in range(self.model_length):\n",
    "            module = Encoder(in_channels=self.enc_channels[i], out_channels=self.enc_channels[i + 1],\n",
    "                             filter_size=self.enc_kernel_sizes[i], stride_size=self.enc_strides[i], padding=self.enc_paddings[i])\n",
    "            self.add_module(\"encoder{}\".format(i), module)\n",
    "            self.encoders.append(module)\n",
    "\n",
    "        self.decoders = []\n",
    "\n",
    "        for i in range(self.model_length):\n",
    "            if i != self.model_length - 1:\n",
    "                module = Decoder(in_channels=self.dec_channels[i] + self.enc_channels[self.model_length - i], out_channels=self.dec_channels[i + 1], \n",
    "                                 filter_size=self.dec_kernel_sizes[i], stride_size=self.dec_strides[i], padding=self.dec_paddings[i],\n",
    "                                 output_padding=self.dec_output_padding[i])\n",
    "            else:\n",
    "                module = Decoder(in_channels=self.dec_channels[i] + self.enc_channels[self.model_length - i], out_channels=self.dec_channels[i + 1], \n",
    "                                 filter_size=self.dec_kernel_sizes[i], stride_size=self.dec_strides[i], padding=self.dec_paddings[i],\n",
    "                                 output_padding=self.dec_output_padding[i], last_layer=True)\n",
    "            self.add_module(\"decoder{}\".format(i), module)\n",
    "            self.decoders.append(module)\n",
    "       \n",
    "        \n",
    "    def forward(self, x, is_istft=True):\n",
    "        # print('x : ', x.shape)\n",
    "        orig_x = x\n",
    "        xs = []\n",
    "        for i, encoder in enumerate(self.encoders):\n",
    "            xs.append(x)\n",
    "            x = encoder(x)\n",
    "            # print('Encoder : ', x.shape)\n",
    "            \n",
    "        p = x\n",
    "        for i, decoder in enumerate(self.decoders):\n",
    "            p = decoder(p)\n",
    "            if i == self.model_length - 1:\n",
    "                break\n",
    "            # print('Decoder : ', p.shape)\n",
    "            p = torch.cat([p, xs[self.model_length - 1 - i]], dim=1)\n",
    "        \n",
    "        # u9 - the mask\n",
    "        \n",
    "        mask = p\n",
    "        \n",
    "        # print('mask : ', mask.shape)\n",
    "        \n",
    "        output = mask * orig_x\n",
    "        output = torch.squeeze(output, 1)\n",
    "\n",
    "\n",
    "        if is_istft:\n",
    "            output = torch.istft(output, n_fft=self.n_fft, hop_length=self.hop_length, normalized=True)\n",
    "        \n",
    "        return output\n",
    "\n",
    "    \n",
    "    def set_size(self, model_complexity, model_depth=20, input_channels=1):\n",
    "\n",
    "        if model_depth == 20:\n",
    "            self.enc_channels = [input_channels,\n",
    "                                 model_complexity,\n",
    "                                 model_complexity,\n",
    "                                 model_complexity * 2,\n",
    "                                 model_complexity * 2,\n",
    "                                 model_complexity * 2,\n",
    "                                 model_complexity * 2,\n",
    "                                 model_complexity * 2,\n",
    "                                 model_complexity * 2,\n",
    "                                 model_complexity * 2,\n",
    "                                 128]\n",
    "\n",
    "            self.enc_kernel_sizes = [(7, 1),\n",
    "                                     (1, 7),\n",
    "                                     (6, 4),\n",
    "                                     (7, 5),\n",
    "                                     (5, 3),\n",
    "                                     (5, 3),\n",
    "                                     (5, 3),\n",
    "                                     (5, 3),\n",
    "                                     (5, 3),\n",
    "                                     (5, 3)]\n",
    "\n",
    "            self.enc_strides = [(1, 1),\n",
    "                                (1, 1),\n",
    "                                (2, 2),\n",
    "                                (2, 1),\n",
    "                                (2, 2),\n",
    "                                (2, 1),\n",
    "                                (2, 2),\n",
    "                                (2, 1),\n",
    "                                (2, 2),\n",
    "                                (2, 1)]\n",
    "\n",
    "            self.enc_paddings = [(3, 0),\n",
    "                                 (0, 3),\n",
    "                                 (0, 0),\n",
    "                                 (0, 0),\n",
    "                                 (0, 0),\n",
    "                                 (0, 0),\n",
    "                                 (0, 0),\n",
    "                                 (0, 0),\n",
    "                                 (0, 0),\n",
    "                                 (0, 0)]\n",
    "\n",
    "            self.dec_channels = [0,\n",
    "                                 model_complexity * 2,\n",
    "                                 model_complexity * 2,\n",
    "                                 model_complexity * 2,\n",
    "                                 model_complexity * 2,\n",
    "                                 model_complexity * 2,\n",
    "                                 model_complexity * 2,\n",
    "                                 model_complexity * 2,\n",
    "                                 model_complexity,\n",
    "                                 model_complexity,\n",
    "                                 1]\n",
    "\n",
    "            self.dec_kernel_sizes = [(6, 3), \n",
    "                                     (6, 3),\n",
    "                                     (6, 3),\n",
    "                                     (6, 4),\n",
    "                                     (6, 3),\n",
    "                                     (6, 4),\n",
    "                                     (8, 5),\n",
    "                                     (7, 5),\n",
    "                                     (1, 7),\n",
    "                                     (7, 1)]\n",
    "\n",
    "            self.dec_strides = [(2, 1), #\n",
    "                                (2, 2), #\n",
    "                                (2, 1), #\n",
    "                                (2, 2), #\n",
    "                                (2, 1), #\n",
    "                                (2, 2), #\n",
    "                                (2, 1), #\n",
    "                                (2, 2), #\n",
    "                                (1, 1),\n",
    "                                (1, 1)]\n",
    "\n",
    "            self.dec_paddings = [(0, 0),\n",
    "                                 (0, 0),\n",
    "                                 (0, 0),\n",
    "                                 (0, 0),\n",
    "                                 (0, 0),\n",
    "                                 (0, 0),\n",
    "                                 (0, 0),\n",
    "                                 (0, 0),\n",
    "                                 (0, 3),\n",
    "                                 (3, 0)]\n",
    "            \n",
    "            self.dec_output_padding = [(0,0),\n",
    "                                       (0,0),\n",
    "                                       (0,0),\n",
    "                                       (0,0),\n",
    "                                       (0,0),\n",
    "                                       (0,0),\n",
    "                                       (0,0),\n",
    "                                       (0,0),\n",
    "                                       (0,0),\n",
    "                                       (0,0)]\n",
    "        else:\n",
    "            raise ValueError(\"Unknown model depth : {}\".format(model_depth))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "G6bIE9iOj8pq"
   },
   "source": [
    "## Training New Model ##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QyBc1awQkI-D"
   },
   "outputs": [],
   "source": [
    "# # clear cache\n",
    "gc.collect()\n",
    "torch.cuda.empty_cache()\n",
    "\n",
    "dcunet20 = DCUnet20(N_FFT, HOP_LENGTH).to(DEVICE)\n",
    "optimizer = torch.optim.Adam(dcunet20.parameters())\n",
    "loss_fn = wsdr_fn\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# specify paths and uncomment to resume training from a given point\n",
    "# model_checkpoint = torch.load(path_to_model)\n",
    "# opt_checkpoint = torch.load(path_to_opt)\n",
    "# dcunet20.load_state_dict(model_checkpoint)\n",
    "# optimizer.load_state_dict(opt_checkpoint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ppXkJUsY55vI"
   },
   "outputs": [],
   "source": [
    "train_losses, test_losses = train(dcunet20, train_loader, test_loader, loss_fn, optimizer, scheduler, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using pretrained weights to run denoising inference ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Select the model weight .pth file ####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_weights_path = \"Pretrained_Weights/Noise2Noise/white.pth\"\n",
    "\n",
    "dcunet20 = DCUnet20(N_FFT, HOP_LENGTH).to(DEVICE)\n",
    "optimizer = torch.optim.Adam(dcunet20.parameters())\n",
    "\n",
    "checkpoint = torch.load(model_weights_path,\n",
    "                        map_location=torch.device('cpu')\n",
    "                       )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Select the testing audio folders for inference ####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_noisy_files = sorted(list(Path(\"Samples/Sample_Test_Input\").rglob('*.wav')))\n",
    "test_clean_files = sorted(list(Path(\"Samples/Sample_Test_Target\").rglob('*.wav')))\n",
    "\n",
    "test_dataset = SpeechDataset(test_noisy_files, test_clean_files, N_FFT, HOP_LENGTH)\n",
    "\n",
    "# For testing purpose\n",
    "test_loader_single_unshuffled = DataLoader(test_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dcunet20.load_state_dict(checkpoint)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Enter the index of the file in the Test Set folder to Denoise and evaluate metrics waveforms (Indexing starts from 0) ####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "index = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\madha\\.conda\\envs\\Noise2Noise-audio-denoising\\lib\\site-packages\\torch\\functional.py:580: UserWarning: stft will soon require the return_complex parameter be given for real inputs, and will further require that return_complex=True in a future PyTorch release. (Triggered internally at  ..\\aten\\src\\ATen\\native\\SpectralOps.cpp:639.)\n",
      "  return _VF.stft(input, n_fft, hop_length, win_length, window,  # type: ignore\n",
      "C:\\Users\\madha\\.conda\\envs\\Noise2Noise-audio-denoising\\lib\\site-packages\\torch\\functional.py:654: UserWarning: istft will require a complex-valued input tensor in a future PyTorch release. Matching the output from stft with return_complex=True.  (Triggered internally at  ..\\aten\\src\\ATen\\native\\SpectralOps.cpp:787.)\n",
      "  return _VF.istft(input, n_fft, hop_length, win_length, window, center,  # type: ignore\n"
     ]
    }
   ],
   "source": [
    "dcunet20.eval()\n",
    "test_loader_single_unshuffled_iter = iter(test_loader_single_unshuffled)\n",
    "\n",
    "x_n, x_c = next(test_loader_single_unshuffled_iter)\n",
    "for _ in range(index):\n",
    "    x_n, x_c = next(test_loader_single_unshuffled_iter)\n",
    "\n",
    "x_est = dcunet20(x_n, is_istft=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_est_np = x_est[0].view(-1).detach().cpu().numpy()\n",
    "x_c_np = torch.istft(torch.squeeze(x_c[0], 1), n_fft=N_FFT, hop_length=HOP_LENGTH, normalized=True).view(-1).detach().cpu().numpy()\n",
    "x_n_np = torch.istft(torch.squeeze(x_n[0], 1), n_fft=N_FFT, hop_length=HOP_LENGTH, normalized=True).view(-1).detach().cpu().numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Metrics ####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CSIG : 3.307\n",
      "CBAK : 3.460\n",
      "COVL : 2.851\n",
      "PESQ : 2.391\n",
      "SSNR : 13.330\n",
      "STOI : 0.920\n",
      "SNR : 19.753\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "metrics = AudioMetrics(x_c_np, x_est_np, SAMPLE_RATE)\n",
    "print(metrics.display())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualization of denoising the audio in /Samples folder ####"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Noisy audio waveform ####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x23773919d60>]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x_n_np)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Model denoised audio waveform ####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x23717b25ee0>]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x_est_np)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### True clean audio waveform ####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x23716238880>]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x_c_np)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Save Recently Denoised Speech Files ####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "noise_addition_utils.save_audio_file(np_array=x_est_np,file_path=Path(\"Samples/denoised.wav\"), sample_rate=SAMPLE_RATE, bit_precision=16)\n",
    "noise_addition_utils.save_audio_file(np_array=x_c_np,file_path=Path(\"Samples/clean.wav\"), sample_rate=SAMPLE_RATE, bit_precision=16)\n",
    "noise_addition_utils.save_audio_file(np_array=x_n_np,file_path=Path(\"Samples/noisy.wav\"), sample_rate=SAMPLE_RATE, bit_precision=16)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "machine_shape": "hm",
   "name": "dcunet.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}