Deepfake-Audio

.gitignore

@@ -0,0 +1,22 @@
+*.pyc
+*.aux
+*.log
+*.out
+*.synctex.gz
+*.suo
+*__pycache__
+*.idea
+*.ipynb_checkpoints
+*.pickle
+*.npy
+*.blg
+*.bbl
+*.bcf
+*.toc
+*.sh
+encoder/saved_models/*
+synthesizer/saved_models/*
+vocoder/saved_models/*
+saved_models/*
+.venv/
+.pytest_cache/

CITATION.cff

@@ -0,0 +1,13 @@
+cff-version: 1.2.0
+message: "If you use this project or its associated academic materials, please cite them as below."
+authors:
+- family-names: "Thakur"
+  given-names: "Amey"
+  orcid: "https://orcid.org/0000-0001-5644-1575"
+- family-names: "Satish"
+  given-names: "Mega"
+  orcid: "https://orcid.org/0000-0002-1844-9557"
+title: "Deepfake Audio"
+version: 1.0.0
+date-released: 2021-02-06
+url: "https://github.com/Amey-Thakur/DEEPFAKE-AUDIO"

DEEPFAKE-AUDIO.ipynb

@@ -0,0 +1,923 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "metadata": {
+                "id": "view-in-github",
+                "colab_type": "text"
+            },
+            "source": [
+                "<a href=\"https://colab.research.google.com/github/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {
+                "id": "X7Om-e0ahXrB"
+            },
+            "source": [
+                "#\n",
+                "<h1 align=\"center\">\ud83c\udf99\ufe0f Deepfake Audio</h1>\n",
+                "<h3 align=\"center\"><i>A neural voice cloning studio powered by SV2TTS technology</i></h3>\n",
+                "\n",
+                "<div align=\"center\">\n",
+                "\n",
+                "| **Author** | **Profiles** |\n",
+                "|:---:|:---|\n",
+                "| **Amey Thakur** | [![GitHub](https://img.shields.io/badge/GitHub-Amey--Thakur-181717?logo=github)](https://github.com/Amey-Thakur) [![ORCID](https://img.shields.io/badge/ORCID-0000--0001--5644--1575-A6CE39?logo=orcid)](https://orcid.org/0000-0001-5644-1575) [![Google Scholar](https://img.shields.io/badge/Google_Scholar-Amey_Thakur-4285F4?logo=google-scholar&logoColor=white)](https://scholar.google.ca/citations?user=0inooPgAAAAJ&hl=en) [![Kaggle](https://img.shields.io/badge/Kaggle-Amey_Thakur-20BEFF?logo=kaggle)](https://www.kaggle.com/ameythakur20) |\n",
+                "| **Mega Satish** | [![GitHub](https://img.shields.io/badge/GitHub-msatmod-181717?logo=github)](https://github.com/msatmod) [![ORCID](https://img.shields.io/badge/ORCID-0000--0002--1844--9557-A6CE39?logo=orcid)](https://orcid.org/0000-0002-1844-9557) [![Google Scholar](https://img.shields.io/badge/Google_Scholar-Mega_Satish-4285F4?logo=google-scholar&logoColor=white)](https://scholar.google.ca/citations?user=7Ajrr6EAAAAJ&hl=en) [![Kaggle](https://img.shields.io/badge/Kaggle-Mega_Satish-20BEFF?logo=kaggle)](https://www.kaggle.com/megasatish) |\n",
+                "\n",
+                "---\n",
+                "\n",
+                "**Attribution:** This project builds upon the foundational work of [CorentinJ/Real-Time-Voice-Cloning](https://github.com/CorentinJ/Real-Time-Voice-Cloning).\n",
+                "\n",
+                "\ud83d\ude80 **Live Demo:** [Hugging Face Space](https://huggingface.co/spaces/ameythakur/Deepfake-Audio) | \ud83c\udfa5 **Video Demo:** [YouTube](https://youtu.be/i3wnBcbHDbs) | \ud83d\udcbb **Repository:** [GitHub](https://github.com/Amey-Thakur/DEEPFAKE-AUDIO)\n",
+                "\n",
+                "<a href=\"https://youtu.be/i3wnBcbHDbs\">\n",
+                "  <img src=\"https://img.youtube.com/vi/i3wnBcbHDbs/0.jpg\" alt=\"Video Demo\" width=\"60%\">\n",
+                "</a>\n",
+                "\n",
+                "</div>\n",
+                "\n",
+                "## \ud83d\udcd6 Introduction\n",
+                "\n",
+                "> **An audio deepfake is when a \u201ccloned\u201d voice that is potentially indistinguishable from the real person\u2019s is used to produce synthetic audio.**\n",
+                "\n",
+                "This research notebook demonstrates the **SV2TTS (Speaker Verification to Text-to-Speech)** framework, a three-stage deep learning pipeline capable of cloning a voice from a mere 5 seconds of audio.\n",
+                "\n",
+                "### The Pipeline\n",
+                "1.  **Speaker Encoder**: Creates a fixed-dimensional embedding (fingerprint) from the reference audio.\n",
+                "2.  **Synthesizer**: Generates a Mel Spectrogram from text, conditioned on the speaker embedding.\n",
+                "3.  **Vocoder**: Converts the Mel Spectrogram into a raw time-domain waveform (audible speech)."
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {
+                "id": "4kb73A1rhXrE"
+            },
+            "source": [
+                "## \u2601\ufe0f Cloud Environment Setup\n",
+                "Execute the following cell **only** if you are running this notebook in a cloud environment like **Google Colab** or **Kaggle**.\n",
+                "\n",
+                "This script will:\n",
+                "1.  **Clone the Repository**: Tries GitHub first, then falls back to **Personal Hugging Face Space** (`ameythakur/Deepfake-Audio`) if GitHub fails.\n",
+                "2.  **Environment Detection**: Automatically detects **Kaggle** vs **Colab**.\n",
+                "3.  **Data Retrieval**:\n",
+                "    *   **Kaggle**: Links directly from `/kaggle/input/deepfakeaudio` (No download needed).\n",
+                "    *   **Others**: Attempts Git LFS pull.\n",
+                "4.  **Fallback to Kagglehub**: If LFS budget exceeded, downloads from `ameythakur20/deepfakeaudio`.\n",
+                "5.  Install all required Python and System dependencies."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 1,
+            "metadata": {
+                "colab": {
+                    "base_uri": "https://localhost:8080/"
+                },
+                "id": "bDzcxXrzhXrE",
+                "outputId": "060d68bb-0b5c-43a8-f0fd-119d6335404e"
+            },
+            "outputs": [
+                {
+                    "output_type": "stream",
+                    "name": "stdout",
+                    "text": [
+                        "\ud83d\udcbb Detected Google Colab Environment. Initiating setup...\n",
+                        "\u2b07\ufe0f Cloning DEEPFAKE-AUDIO repository from MAIN (GitHub)...\n",
+                        "Cloning into 'DEEPFAKE-AUDIO'...\n",
+                        "remote: Enumerating objects: 682, done.\u001b[K\n",
+                        "remote: Counting objects: 100% (62/62), done.\u001b[K\n",
+                        "remote: Compressing objects: 100% (55/55), done.\u001b[K\n",
+                        "remote: Total 682 (delta 7), reused 7 (delta 7), pack-reused 620 (from 1)\u001b[K\n",
+                        "Receiving objects: 100% (682/682), 71.95 MiB | 12.37 MiB/s, done.\n",
+                        "Resolving deltas: 100% (328/328), done.\n",
+                        "Downloading Dataset/encoder.pt (17 MB)\n",
+                        "Error downloading object: Dataset/encoder.pt (39373b8): Smudge error: Error downloading Dataset/encoder.pt (39373b86598fa3da9fcddee6142382efe09777e8d37dc9c0561f41f0070f134e): batch response: This repository exceeded its LFS budget. The account responsible for the budget should increase it to restore access.\n",
+                        "\n",
+                        "Errors logged to /content/DEEPFAKE-AUDIO/.git/lfs/logs/20260129T113138.869344323.log\n",
+                        "Use `git lfs logs last` to view the log.\n",
+                        "error: external filter 'git-lfs filter-process' failed\n",
+                        "fatal: Dataset/encoder.pt: smudge filter lfs failed\n",
+                        "warning: Clone succeeded, but checkout failed.\n",
+                        "You can inspect what was checked out with 'git status'\n",
+                        "and retry with 'git restore --source=HEAD :/'\n",
+                        "\n",
+                        "\ud83d\udd27 Installing dependencies...\n",
+                        "Reading package lists... Done\n",
+                        "Building dependency tree... Done\n",
+                        "Reading state information... Done\n",
+                        "libsndfile1 is already the newest version (1.0.31-2ubuntu0.2).\n",
+                        "0 upgraded, 0 newly installed, 0 to remove and 41 not upgraded.\n",
+                        "\ud83d\udce6 Attempting Git LFS pull...\n",
+                        "Updated git hooks.\n",
+                        "Git LFS initialized.\n",
+                        "Error updating the git index:\n",
+                        "error: Source Code/encoder/__init__.py: cannot add to the index - missing --add option?\n",
+                        "fatal: Unable to process path Source Code/encoder/__init__.py\n",
+                        "\n",
+                        "\n",
+                        "Errors logged to /content/DEEPFAKE-AUDIO/.git/lfs/logs/20260129T113158.470476122.log\n",
+                        "Use `git lfs logs last` to view the log.\n",
+                        "batch response: This repository exceeded its LFS budget. The account responsible for the budget should increase it to restore access.\n",
+                        "error: failed to fetch some objects from 'https://github.com/Amey-Thakur/DEEPFAKE-AUDIO.git/info/lfs'\n",
+                        "\u26a0\ufe0f GitHub LFS Budget Exceeded or Pull Failed. Using Kaggle Fallback...\n",
+                        "Requirement already satisfied: kagglehub in /usr/local/lib/python3.12/dist-packages (0.3.13)\n",
+                        "Requirement already satisfied: packaging in /usr/local/lib/python3.12/dist-packages (from kagglehub) (25.0)\n",
+                        "Requirement already satisfied: pyyaml in /usr/local/lib/python3.12/dist-packages (from kagglehub) (6.0.3)\n",
+                        "Requirement already satisfied: requests in /usr/local/lib/python3.12/dist-packages (from kagglehub) (2.32.4)\n",
+                        "Requirement already satisfied: tqdm in /usr/local/lib/python3.12/dist-packages (from kagglehub) (4.67.1)\n",
+                        "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests->kagglehub) (3.4.4)\n",
+                        "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests->kagglehub) (3.11)\n",
+                        "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/dist-packages (from requests->kagglehub) (2.5.0)\n",
+                        "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.12/dist-packages (from requests->kagglehub) (2026.1.4)\n",
+                        "\ud83d\ude80 Downloading assets from Kagglehub (ameythakur20/deepfakeaudio)...\n",
+                        "Warning: Looks like you're using an outdated `kagglehub` version (installed: 0.3.13), please consider upgrading to the latest version (0.4.1).\n",
+                        "Downloading from https://www.kaggle.com/api/v1/datasets/download/ameythakur20/deepfakeaudio?dataset_version_number=5...\n"
+                    ]
+                },
+                {
+                    "output_type": "stream",
+                    "name": "stderr",
+                    "text": [
+                        "100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 550M/550M [00:25<00:00, 22.7MB/s]"
+                    ]
+                },
+                {
+                    "output_type": "stream",
+                    "name": "stdout",
+                    "text": [
+                        "Extracting files...\n"
+                    ]
+                },
+                {
+                    "output_type": "stream",
+                    "name": "stderr",
+                    "text": [
+                        "\n"
+                    ]
+                },
+                {
+                    "output_type": "stream",
+                    "name": "stdout",
+                    "text": [
+                        "\u2705 Samples linked from Kaggle.\n",
+                        "\u2705 Models linked from Kaggle.\n"
+                    ]
+                }
+            ],
+            "source": [
+                "import os\n",
+                "import sys\n",
+                "import shutil\n",
+                "\n",
+                "# Detect Cloud Environment (Colab/Kaggle)\n",
+                "try:\n",
+                "    shell = get_ipython()\n",
+                "    if 'google.colab' in str(shell):\n",
+                "        print(\"\ud83d\udcbb Detected Google Colab Environment. Initiating setup...\")\n",
+                "\n",
+                "        # 1. Clone the Repository (GitHub with HF Fallback)\n",
+                "        if not os.path.exists(\"DEEPFAKE-AUDIO\"):\n",
+                "            print(\"\u2b07\ufe0f Cloning DEEPFAKE-AUDIO repository from MAIN (GitHub)...\")\n",
+                "            clone_status = shell.system(\"git clone https://github.com/Amey-Thakur/DEEPFAKE-AUDIO\")\n",
+                "\n",
+                "            # Fallback to Hugging Face if GitHub clone failed (folder empty or not created)\n",
+                "            if not os.path.exists(\"DEEPFAKE-AUDIO\") or not os.listdir(\"DEEPFAKE-AUDIO\"):\n",
+                "                print(\"\u26a0\ufe0f GitHub Clone Failed. Attempting Fallback: Personal Hugging Face Space...\")\n",
+                "                if os.path.exists(\"DEEPFAKE-AUDIO\"): shutil.rmtree(\"DEEPFAKE-AUDIO\")\n",
+                "                shell.system(\"git clone https://huggingface.co/spaces/ameythakur/Deepfake-Audio DEEPFAKE-AUDIO\")\n",
+                "                print(\"\u2705 Cloned from Hugging Face Space.\")\n",
+                "\n",
+                "        os.chdir(\"/content/DEEPFAKE-AUDIO\")\n",
+                "\n",
+                "        # Install Dependencies (Colab)\n",
+                "        print(\"\ud83d\udd27 Installing dependencies...\")\n",
+                "        shell.system(\"apt-get install -y libsndfile1\")\n",
+                "        shell.system(\"pip install librosa==0.9.2 unidecode webrtcvad inflect umap-learn scikit-learn>=1.3 tqdm scipy 'matplotlib>=3.7,<3.9' Pillow>=10.2 soundfile huggingface_hub\")\n",
+                "\n",
+                "\n",
+                "\n",
+                "        # 2. Attempt Git LFS (Colab)\n",
+                "        print(\"\ud83d\udce6 Attempting Git LFS pull...\")\n",
+                "        shell.system(\"git lfs install\")\n",
+                "        lfs_status = shell.system(\"git lfs pull\")\n",
+                "\n",
+                "        # 3. Check for Fallback (If LFS failed or budget exceeded)\n",
+                "        sample_trigger = \"Dataset/samples/Steve Jobs.wav\"\n",
+                "        if lfs_status != 0 or not os.path.exists(sample_trigger) or os.path.getsize(sample_trigger) < 1000:\n",
+                "            print(\"\u26a0\ufe0f GitHub LFS Budget Exceeded or Pull Failed. Using Kaggle Fallback...\")\n",
+                "            shell.system(\"pip install kagglehub\")\n",
+                "            import kagglehub\n",
+                "            print(\"\ud83d\ude80 Downloading assets from Kagglehub (ameythakur20/deepfakeaudio)...\")\n",
+                "            k_path = kagglehub.dataset_download(\"ameythakur20/deepfakeaudio\")\n",
+                "\n",
+                "            # Link/Copy samples\n",
+                "            k_samples = os.path.join(k_path, \"samples\")\n",
+                "            if os.path.exists(k_samples):\n",
+                "                 if os.path.exists(\"Dataset/samples\"):\n",
+                "                      shutil.rmtree(\"Dataset/samples\")\n",
+                "                 os.makedirs(\"Dataset\", exist_ok=True)\n",
+                "                 os.symlink(k_samples, \"Dataset/samples\")\n",
+                "                 print(\"\u2705 Samples linked from Kaggle.\")\n",
+                "\n",
+                "            # Link/Copy models\n",
+                "            for model in [\"encoder.pt\", \"synthesizer.pt\", \"vocoder.pt\"]:\n",
+                "                 k_model = os.path.join(k_path, model)\n",
+                "                 if os.path.exists(k_model):\n",
+                "                      target = os.path.join(\"Dataset\", model)\n",
+                "                      if os.path.exists(target): os.remove(target)\n",
+                "                      os.symlink(k_model, target)\n",
+                "            print(\"\u2705 Models linked from Kaggle.\")\n",
+                "\n",
+                "    elif \"kaggle\" in os.environ.get(\"KAGGLE_KERNEL_RUN_TYPE\", \"\"):\n",
+                "        print(\"\ud83d\udcbb Detected Kaggle Environment. Initiating setup...\")\n",
+                "        os.chdir(\"/kaggle/working\")\n",
+                "\n",
+                "        # 1. Clone the Repository (GitHub with HF Fallback)\n",
+                "        if not os.path.exists(\"DEEPFAKE-AUDIO\"):\n",
+                "            print(\"\u2b07\ufe0f Cloning DEEPFAKE-AUDIO repository from MAIN (GitHub)...\")\n",
+                "            shell.system(\"git clone https://github.com/Amey-Thakur/DEEPFAKE-AUDIO\")\n",
+                "\n",
+                "            if not os.path.exists(\"DEEPFAKE-AUDIO\") or not os.listdir(\"DEEPFAKE-AUDIO\"):\n",
+                "                print(\"\u26a0\ufe0f GitHub Clone Failed. Attempting Fallback: Personal Hugging Face Space...\")\n",
+                "                if os.path.exists(\"DEEPFAKE-AUDIO\"): shutil.rmtree(\"DEEPFAKE-AUDIO\")\n",
+                "                shell.system(\"git clone https://huggingface.co/spaces/ameythakur/Deepfake-Audio DEEPFAKE-AUDIO\")\n",
+                "                print(\"\u2705 Cloned from Hugging Face Space.\")\n",
+                "\n",
+                "        os.chdir(\"/kaggle/working/DEEPFAKE-AUDIO\")\n",
+                "\n",
+                "        # 2. Priority: Link Kaggle Dataset (Skip LFS pull if dataset exists)\n",
+                "        kaggle_input = \"/kaggle/input/deepfakeaudio\"\n",
+                "        if os.path.exists(kaggle_input):\n",
+                "            print(f\"\u2705 Kaggle Dataset Detected at {kaggle_input}. Linking assets...\")\n",
+                "            # Link logic specific to Kaggle structure\n",
+                "            if os.path.exists(\"Dataset/samples\"):\n",
+                "                 shutil.rmtree(\"Dataset/samples\")\n",
+                "            if not os.path.exists(\"Dataset\"):\n",
+                "                 os.makedirs(\"Dataset\")\n",
+                "            # Attempt to symlink folder or copy items\n",
+                "            try:\n",
+                "                if os.path.exists(os.path.join(kaggle_input, \"samples\")):\n",
+                "                    os.symlink(os.path.join(kaggle_input, \"samples\"), \"Dataset/samples\")\n",
+                "                for model in [\"encoder.pt\", \"synthesizer.pt\", \"vocoder.pt\"]:\n",
+                "                    src = os.path.join(kaggle_input, model)\n",
+                "                    dst = os.path.join(\"Dataset\", model)\n",
+                "                    if os.path.exists(src):\n",
+                "                        if os.path.exists(dst): os.remove(dst)\n",
+                "                        os.symlink(src, dst)\n",
+                "            except Exception as e: print(f\"Warning during linking: {e}\")\n",
+                "            print(\"\u2705 Assets linked from Kaggle Input.\")\n",
+                "        else:\n",
+                "            print(\"\u26a0\ufe0f Kaggle Input not found. Attempting standard LFS pull...\")\n",
+                "            shell.system(\"git lfs install\")\n",
+                "            shell.system(\"git lfs pull\")\n",
+                "\n",
+                "        # Install Dependencies\n",
+                "        print(\"\ud83d\udd27 Installing dependencies...\")\n",
+                "        shell.system(\"apt-get install -y libsndfile1\")\n",
+                "        shell.system(\"pip install librosa==0.9.2 unidecode webrtcvad inflect umap-learn scikit-learn>=1.3 tqdm scipy 'matplotlib>=3.7,<3.9' Pillow>=10.2 soundfile huggingface_hub\")\n",
+                "\n",
+                "        # 2. Attempt Git LFS\n",
+                "        print(\"\ud83d\udce6 Attempting Git LFS pull...\")\n",
+                "        shell.system(\"git lfs install\")\n",
+                "        lfs_status = shell.system(\"git lfs pull\")\n",
+                "\n",
+                "        # 3. Check for Fallback (If LFS failed or budget exceeded)\n",
+                "        # Detection: If samples folder is empty or contains small pointer files\n",
+                "        sample_trigger = \"Dataset/samples/Steve Jobs.wav\"\n",
+                "        if lfs_status != 0 or not os.path.exists(sample_trigger) or os.path.getsize(sample_trigger) < 1000:\n",
+                "            print(\"\u26a0\ufe0f GitHub LFS Budget Exceeded or Pull Failed. Using Kaggle Fallback...\")\n",
+                "            shell.system(\"pip install kagglehub\")\n",
+                "            import kagglehub\n",
+                "\n",
+                "            # Pull from public Kaggle dataset\n",
+                "            print(\"\ud83d\ude80 Downloading assets from Kagglehub (ameythakur20/deepfakeaudio)...\")\n",
+                "            k_path = kagglehub.dataset_download(\"ameythakur20/deepfakeaudio\")\n",
+                "\n",
+                "            # Link/Copy samples\n",
+                "            k_samples = os.path.join(k_path, \"samples\")\n",
+                "            if os.path.exists(k_samples):\n",
+                "                 if os.path.exists(\"Dataset/samples\"):\n",
+                "                      shutil.rmtree(\"Dataset/samples\")\n",
+                "                 os.makedirs(\"Dataset\", exist_ok=True)\n",
+                "                 os.symlink(k_samples, \"Dataset/samples\")\n",
+                "                 print(\"\u2705 Samples linked from Kaggle.\")\n",
+                "\n",
+                "            # Link/Copy models\n",
+                "            for model in [\"encoder.pt\", \"synthesizer.pt\", \"vocoder.pt\"]:\n",
+                "                 k_model = os.path.join(k_path, model)\n",
+                "                 if os.path.exists(k_model):\n",
+                "                      target = os.path.join(\"Dataset\", model)\n",
+                "                      if os.path.exists(target): os.remove(target)\n",
+                "                      os.symlink(k_model, target)\n",
+                "            print(\"\u2705 Models linked from Kaggle.\")\n",
+                "\n",
+                "        # 4. Pull Latest Code Changes\n",
+                "        print(\"\ud83d\udd04 Synchronizing with remote repository...\")\n",
+                "        shell.system(\"git pull\")\n",
+                "\n",
+                "        # 5. Install System Dependencies\n",
+                "        print(\"\ud83d\udd27 Installing system dependencies (libsndfile1)...\")\n",
+                "        shell.system(\"apt-get install -y libsndfile1\")\n",
+                "\n",
+                "        # 6. Install Python Dependencies\n",
+                "        print(\"\ud83d\udce6 Installing Python libraries...\")\n",
+                "        shell.system(\"pip install librosa==0.9.2 unidecode webrtcvad inflect umap-learn scikit-learn>=1.3 tqdm scipy 'matplotlib>=3.7,<3.9' Pillow>=10.2 soundfile huggingface_hub\")\n",
+                "\n",
+                "        print(\"\u2705 Environment setup complete. Ready for cloning.\")\n",
+                "    else:\n",
+                "        print(\"\ud83c\udfe0 Running in local or custom environment. Skipping cloud setup.\")\n",
+                "except NameError:\n",
+                "    print(\"\ud83c\udfe0 Running in local or custom environment. Skipping cloud setup.\")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {
+                "id": "3sJUw_G8hXrG"
+            },
+            "source": [
+                "## 1\ufe0f\u20e3 Model & Data Initialization\n",
+                "\n",
+                "We prioritize data availability to ensure the notebook runs smoothly regardless of the platform. The system checks for checkpoints in this order:\n",
+                "\n",
+                "1.  **Repository Local** (`Dataset/` / `Source Code/`): Fast local access if cloned.\n",
+                "2.  **Kaggle Dataset** (`/kaggle/input/deepfakeaudio/`): Pre-loaded environment data.\n",
+                "    *   *Reference*: [Amey Thakur's Kaggle Dataset](https://www.kaggle.com/datasets/ameythakur20/deepfakeaudio)\n",
+                "3.  **Personal Backup** (Hugging Face Space): `ameythakur/Deepfake-Audio`.\n",
+                "    *   *Reference*: [Amey Thakur's HF Space](https://huggingface.co/spaces/ameythakur/Deepfake-Audio)\n",
+                "4.  **HuggingFace Auto-Download**: Robust fallback for fresh environments.\n",
+                "    *   *Reference*: [CorentinJ's SV2TTS Repository](https://huggingface.co/CorentinJ/SV2TTS)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 2,
+            "metadata": {
+                "colab": {
+                    "base_uri": "https://localhost:8080/"
+                },
+                "id": "bY79_5WrhXrH",
+                "outputId": "c1767603-817a-4f2c-8ce9-a09f2436bc5d"
+            },
+            "outputs": [
+                {
+                    "output_type": "stream",
+                    "name": "stdout",
+                    "text": [
+                        "\ud83d\udcc2 Working Directory: /content/DEEPFAKE-AUDIO\n",
+                        "\u2705 Module Path Registered: /content/DEEPFAKE-AUDIO/Source Code\n",
+                        "\u2b07\ufe0f Verifying Model Availability...\n",
+                        "\u2705 Found high-priority local models in 'Dataset/'. Verified.\n"
+                    ]
+                }
+            ],
+            "source": [
+                "import sys\n",
+                "import os\n",
+                "from pathlib import Path\n",
+                "import zipfile\n",
+                "import shutil\n",
+                "\n",
+                "# Determine if running in Google Colab\n",
+                "IS_COLAB = 'google.colab' in sys.modules\n",
+                "\n",
+                "# Register 'Source Code' to Python path for module imports\n",
+                "source_path = os.path.abspath(\"Source Code\")\n",
+                "if source_path not in sys.path:\n",
+                "    sys.path.append(source_path)\n",
+                "\n",
+                "print(f\"\ud83d\udcc2 Working Directory: {os.getcwd()}\")\n",
+                "print(f\"\u2705 Module Path Registered: {source_path}\")\n",
+                "\n",
+                "# Define paths for model checkpoints\n",
+                "extract_path = \"pretrained_models\"\n",
+                "\n",
+                "if not os.path.exists(extract_path):\n",
+                "    os.makedirs(extract_path)\n",
+                "\n",
+                "# --- \ud83e\udde0 Checkpoint Verification Strategy ---\n",
+                "print(\"\u2b07\ufe0f Verifying Model Availability...\")\n",
+                "\n",
+                "# Priority 1: Check Local Repository 'Dataset/' folder\n",
+                "core_models = [\"encoder.pt\", \"synthesizer.pt\", \"vocoder.pt\"]\n",
+                "\n",
+                "def is_valid_pt(p):\n",
+                "    \"\"\"Checks if a file exists and is not an LFS pointer (typically < 1KB).\"\"\"\n",
+                "    return os.path.exists(p) and os.path.getsize(p) > 1000\n",
+                "\n",
+                "dataset_models_present = all([is_valid_pt(os.path.join(\"Dataset\", m)) for m in core_models])\n",
+                "\n",
+                "if dataset_models_present:\n",
+                "    print(\"\u2705 Found high-priority local models in 'Dataset/'. Verified.\")\n",
+                "else:\n",
+                "    # Priority 2: Check Kaggle Dataset (Online Pre-loaded environment data)\n",
+                "    kaggle_path = \"/kaggle/input/deepfakeaudio\"\n",
+                "    kaggle_models_present = all([is_valid_pt(os.path.join(kaggle_path, m)) for m in core_models])\n",
+                "\n",
+                "    if kaggle_models_present:\n",
+                "        print(f\"\u2705 Found hardcoded Kaggle Dataset models at {kaggle_path}. Skipping download.\")\n",
+                "    else:\n",
+                "        print(\"\u26a0\ufe0f Models not found or are LFS pointers. Attempting fallback download...\")\n",
+                "\n",
+                "        # Priority 3: Personal Hugging Face Space (ameythakur/Deepfake-Audio)\n",
+                "        personal_hf_success = False\n",
+                "        try:\n",
+                "            print(\"\ud83d\ude80 Attempting download from Personal Hugging Face Space (ameythakur/Deepfake-Audio)...\")\n",
+                "            from huggingface_hub import hf_hub_download\n",
+                "            os.makedirs(\"pretrained_models\", exist_ok=True)\n",
+                "            for model in core_models:\n",
+                "                 try:\n",
+                "                     fpath = hf_hub_download(repo_id=\"ameythakur/Deepfake-Audio\", filename=f\"Dataset/{model}\", repo_type=\"space\", local_dir=\"pretrained_models\")\n",
+                "                 except:\n",
+                "                     fpath = hf_hub_download(repo_id=\"ameythakur/Deepfake-Audio\", filename=model, repo_type=\"space\", local_dir=\"pretrained_models\")\n",
+                "                 target = os.path.join(\"pretrained_models\", model)\n",
+                "                 if fpath != target and os.path.exists(fpath): shutil.move(fpath, target)\n",
+                "            if os.path.exists(os.path.join(\"pretrained_models\", \"Dataset\")): shutil.rmtree(os.path.join(\"pretrained_models\", \"Dataset\"))\n",
+                "            print(\"\u2705 Models successfully acquired via Personal Hugging Face fallback.\")\n",
+                "            personal_hf_success = True\n",
+                "        except Exception as e_hf:\n",
+                "            print(f\"\u26a0\ufe0f Personal HF Checkpoint failed: {e_hf}. Trying External Fallback...\")\n",
+                "\n",
+                "        # Priority 4 (Fallback): Auto-download from HuggingFace via utils script\n",
+                "        if not personal_hf_success:\n",
+                "            try:\n",
+                "                from utils.default_models import ensure_default_models\n",
+                "                ensure_default_models(Path(\"pretrained_models\"))\n",
+                "                print(\"\u2705 Models successfully acquired via External HuggingFace fallback.\")\n",
+                "            except Exception as e:\n",
+                "                print(f\"\u26a0\ufe0f Critical: Could not auto-download models. Error: {e}\")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {
+                "id": "ycvMxmYJhXrI"
+            },
+            "source": [
+                "## 2\ufe0f\u20e3 Architecture Loading\n",
+                "\n",
+                "We now initialize the three distinct neural networks that comprise the SV2TTS framework. Please ensure you are running on a **GPU Runtime** (e.g., T4 on Colab) for optimal performance."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 3,
+            "metadata": {
+                "colab": {
+                    "base_uri": "https://localhost:8080/"
+                },
+                "id": "yEShAzbfhXrI",
+                "outputId": "9d2ce872-19a3-4259-a10b-8afebb394b28"
+            },
+            "outputs": [
+                {
+                    "output_type": "stream",
+                    "name": "stdout",
+                    "text": [
+                        "\ud83c\udfaf Computation Device: cuda\n",
+                        "\u23f3 Loading Neural Networks (SV2TTS Pipeline)...\n",
+                        "\ud83d\udfe2 Loading Encoder from Repository: Dataset/encoder.pt\n",
+                        "Loaded encoder \"encoder.pt\" trained to step 1564501\n",
+                        "\ud83d\udfe2 Loading Synthesizer from Repository: Dataset/synthesizer.pt\n",
+                        "Synthesizer using device: cuda\n",
+                        "\ud83d\udfe2 Loading Vocoder from Repository: Dataset/vocoder.pt\n",
+                        "Building Wave-RNN\n",
+                        "Trainable Parameters: 4.481M\n",
+                        "Loading model weights at Dataset/vocoder.pt\n",
+                        "\u2705 Pipeline operational. All components loaded correctly.\n"
+                    ]
+                }
+            ],
+            "source": [
+                "from encoder import inference as encoder\n",
+                "from synthesizer.inference import Synthesizer\n",
+                "from vocoder import inference as vocoder\n",
+                "import numpy as np\n",
+                "import torch\n",
+                "from pathlib import Path\n",
+                "\n",
+                "# Hardware Acceleration Check\n",
+                "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+                "print(f\"\ud83c\udfaf Computation Device: {device}\")\n",
+                "\n",
+                "def resolve_checkpoint(component_name, legacy_path_suffix):\n",
+                "    \"\"\"\n",
+                "    Intelligently resolves the path to model checkpoints based on priority.\n",
+                "    1. Repository /Dataset/ folder.\n",
+                "    2. Kaggle Input directory (Hardcoded: /kaggle/input/deepfakeaudio/).\n",
+                "    3. Auto-downloaded 'pretrained_models'.\n",
+                "    \"\"\"\n",
+                "\n",
+                "    def is_valid(p):\n",
+                "        return p.exists() and p.stat().st_size > 1000\n",
+                "\n",
+                "    # 1. Repository Local (Dataset/)\n",
+                "    dataset_p = Path(\"Dataset\") / f\"{component_name.lower()}.pt\"\n",
+                "    if is_valid(dataset_p):\n",
+                "        print(f\"\ud83d\udfe2 Loading {component_name} from Repository: {dataset_p}\")\n",
+                "        return dataset_p\n",
+                "\n",
+                "    # 2. Kaggle Environment (Hardcoded Path: /kaggle/input/deepfakeaudio/)\n",
+                "    kaggle_p = Path(\"/kaggle/input/deepfakeaudio\") / f\"{component_name.lower()}.pt\"\n",
+                "    if is_valid(kaggle_p):\n",
+                "        print(f\"\ud83d\udfe2 Loading {component_name} from Kaggle: {kaggle_p}\")\n",
+                "        return kaggle_p\n",
+                "\n",
+                "    # 3. Default / Auto-Downloaded Fallback\n",
+                "    default_p = Path(\"pretrained_models/default\") / f\"{component_name.lower()}.pt\"\n",
+                "    if is_valid(default_p):\n",
+                "        print(f\"\ud83d\udfe2 Loading {component_name} from Fallback: {default_p}\")\n",
+                "        return default_p\n",
+                "\n",
+                "    # 4. Legacy/Manual Paths\n",
+                "    legacy_p = Path(\"pretrained_models\") / legacy_path_suffix\n",
+                "    if legacy_p.exists():\n",
+                "         if legacy_p.is_dir():\n",
+                "             pts = [f for f in legacy_p.glob(\"*.pt\") if is_valid(f)]\n",
+                "             if pts: return pts[0]\n",
+                "             pts_rec = [f for f in legacy_p.rglob(\"*.pt\") if is_valid(f)]\n",
+                "             if pts_rec: return pts_rec[0]\n",
+                "         elif is_valid(legacy_p):\n",
+                "             return legacy_p\n",
+                "\n",
+                "    print(f'\u26a0\ufe0f Warning: {component_name} checkpoint not found! Falling back to dynamic search...')\n",
+                "    return None\n",
+                "\n",
+                "print(\"\u23f3 Loading Neural Networks (SV2TTS Pipeline)...\")\n",
+                "\n",
+                "try:\n",
+                "    # 1. Encoder: Extract speaker embedding\n",
+                "    encoder_path = resolve_checkpoint(\"Encoder\", \"encoder/saved_models\")\n",
+                "    encoder.load_model(encoder_path)\n",
+                "\n",
+                "    # 2. Synthesizer: Generates spectrograms from text\n",
+                "    synth_path = resolve_checkpoint(\"Synthesizer\", \"synthesizer/saved_models/logs-pretrained/taco_pretrained\")\n",
+                "    synthesizer = Synthesizer(synth_path)\n",
+                "\n",
+                "    # 3. Vocoder: Converts spectrograms to audio waveforms\n",
+                "    vocoder_path = resolve_checkpoint(\"Vocoder\", \"vocoder/saved_models/pretrained\")\n",
+                "    vocoder.load_model(vocoder_path)\n",
+                "\n",
+                "    print(\"\u2705 Pipeline operational. All components loaded correctly.\")\n",
+                "except Exception as e:\n",
+                "    print(f\"\u274c Architecture Error: {e}\")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {
+                "id": "GjaGAUyVhXrJ"
+            },
+            "source": [
+                "## 3\ufe0f\u20e3 Inference Interface\n",
+                "\n",
+                "Select your **Input Method** below to begin cloning.\n",
+                "\n",
+                "*   **Presets**: Choose from a high-quality list of celebrity samples.\n",
+                "*   **Upload**: Use your own `.wav` or `.mp3` file (5-10 seconds recommended).\n",
+                "*   **Record**: Capture your voice directly in the browser (Colab only)."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 4,
+            "metadata": {
+                "colab": {
+                    "base_uri": "https://localhost:8080/",
+                    "height": 1000,
+                    "referenced_widgets": [
+                        "17941275da2c4712a8f7aeee24e985dc",
+                        "d35d66d0fc6f4956a22315288f75761e",
+                        "e5738978acde489493cc00b7580b41bf",
+                        "a1c213e8e9ed4e6a80611f91e37c16ee",
+                        "2a6b69d651c24930b892c0bb52e9d9e4",
+                        "39339f0b568c4d5084de7664d336ba50",
+                        "0923c7a8ae574c4fa2c9eb8c25076b95",
+                        "b0a46e803d84423cacb55e37ae6c043b",
+                        "bb70b9f36452494da95ee1033601218f",
+                        "f3008160ab52453d932a0cb62c711eee",
+                        "f035a503fafe48038036bdd50bd07b1c",
+                        "dac9a6ef6db347e08b2268c5e5654008",
+                        "779855519a5844d3bcc1ed69a8c44608",
+                        "05f5b43427fe47fbae468c4cec2be72c",
+                        "98051b53e539482aadf5d4b132dd3021",
+                        "3ed45fa49669481dbee831dfb2f6ebeb",
+                        "9d9b4954b5a74bf2b2f0fef974564bda",
+                        "3753f04d0dbb48a6a9a5c5589425ad91",
+                        "c294dc1d01e3421097eefe7eb2e5e377",
+                        "de81a54ce89a4aaeaba52f01c571b212",
+                        "7dbdc18b94a54cb6a492c7f33a661a56",
+                        "b9b8b1f96c3d4b89a9bc3e32d6076ad3",
+                        "91e19a809309432995d435aeba1e8bde",
+                        "c51b8d7f054b41039f354fce639d6947",
+                        "20d72122af6f449c90d53871c5a29b7d",
+                        "f73ef86eeaab452eb11e45f1e17464a8",
+                        "edf2d4f03fae4c5da75d0e3e1ad60382"
+                    ]
+                },
+                "id": "3wq8NsHohXrJ",
+                "outputId": "b92ea5cd-958b-4f83-9c48-1726f5f821a1"
+            },
+            "outputs": [
+                {
+                    "output_type": "stream",
+                    "name": "stdout",
+                    "text": [
+                        "Select Input Method:\n",
+                        "\u2705 Samples located at: /content/DEEPFAKE-AUDIO/Dataset/samples\n"
+                    ]
+                },
+                {
+                    "output_type": "display_data",
+                    "data": {
+                        "text/plain": [
+                            "Tab(children=(VBox(children=(Dropdown(description='Preset:', options=('Donald Trump.wav', 'Steve Jobs.wav', 'A\u2026"
+                        ],
+                        "application/vnd.jupyter.widget-view+json": {
+                            "version_major": 2,
+                            "version_minor": 0,
+                            "model_id": "17941275da2c4712a8f7aeee24e985dc"
+                        }
+                    },
+                    "metadata": {}
+                },
+                {
+                    "output_type": "display_data",
+                    "data": {
+                        "text/plain": [
+                            "Textarea(value=\"Hello, I'm Elon Musk. Welcome to Deepfake Audio by Amey Thakur and Mega Satish. Explore AI voi\u2026"
+                        ],
+                        "application/vnd.jupyter.widget-view+json": {
+                            "version_major": 2,
+                            "version_minor": 0,
+                            "model_id": "de81a54ce89a4aaeaba52f01c571b212"
+                        }
+                    },
+                    "metadata": {}
+                },
+                {
+                    "output_type": "display_data",
+                    "data": {
+                        "text/plain": [
+                            "Button(button_style='primary', description='Clone Voice! \ud83d\ude80', style=ButtonStyle())"
+                        ],
+                        "application/vnd.jupyter.widget-view+json": {
+                            "version_major": 2,
+                            "version_minor": 0,
+                            "model_id": "91e19a809309432995d435aeba1e8bde"
+                        }
+                    },
+                    "metadata": {}
+                },
+                {
+                    "output_type": "display_data",
+                    "data": {
+                        "text/plain": [
+                            "Output()"
+                        ],
+                        "application/vnd.jupyter.widget-view+json": {
+                            "version_major": 2,
+                            "version_minor": 0,
+                            "model_id": "f73ef86eeaab452eb11e45f1e17464a8"
+                        }
+                    },
+                    "metadata": {}
+                }
+            ],
+            "source": [
+                "import ipywidgets as widgets\n",
+                "from IPython.display import display, Javascript, Audio\n",
+                "try:\n",
+                "    from google.colab import output\n",
+                "    HAS_COLAB = True\n",
+                "except ImportError:\n",
+                "    HAS_COLAB = False\n",
+                "from base64 import b64decode\n",
+                "import io\n",
+                "import librosa\n",
+                "import librosa.display\n",
+                "import os\n",
+                "import soundfile as sf\n",
+                "import matplotlib.pyplot as plt\n",
+                "import numpy as np\n",
+                "import glob\n",
+                "\n",
+                "RECORD = \"\"\"\n",
+                "const sleep = time => new Promise(resolve => setTimeout(resolve, time))\n",
+                "const b2text = blob => new Promise(resolve => {\n",
+                "  const reader = new FileReader()\n",
+                "  reader.onloadend = e => resolve(e.srcElement.result)\n",
+                "  reader.readAsDataURL(blob)\n",
+                "})\n",
+                "var record = time => new Promise(async resolve => {\n",
+                "  stream = await navigator.mediaDevices.getUserMedia({ audio: true })\n",
+                "  recorder = new MediaRecorder(stream)\n",
+                "  chunks = []\n",
+                "  recorder.ondataavailable = e => chunks.push(e.data)\n",
+                "  recorder.start()\n",
+                "  await sleep(time)\n",
+                "  recorder.onstop = async ()=>{\n",
+                "    blob = new Blob(chunks)\n",
+                "    text = await b2text(blob)\n",
+                "    resolve(text)\n",
+                "  }\n",
+                "  recorder.stop()\n",
+                "})\"\"\"\n",
+                "\n",
+                "def record_audio(sec=10):\n",
+                "    if not HAS_COLAB:\n",
+                "        raise RuntimeError(\"Recording is only available in a Google Colab environment.\")\n",
+                "    print(\"\ud83d\udd34 Recording active for %d seconds...\" % sec)\n",
+                "    display(Javascript(RECORD))\n",
+                "    s = output.eval_js('record(%d)' % (sec*1000))\n",
+                "    print(\"\u2705 Recording saved.\")\n",
+                "    binary = b64decode(s.split(',')[1])\n",
+                "    with open('recording.wav', 'wb') as f:\n",
+                "        f.write(binary)\n",
+                "    return 'recording.wav'\n",
+                "\n",
+                "def visualize_results(original_wav, generated_wav, spec, embed, title=\"Analysis\"):\n",
+                "    try:\n",
+                "        fig, axes = plt.subplots(3, 1, figsize=(10, 12))\n",
+                "        axes[0].set_title(\"Input Voice vs. Cloned Voice (Waveform)\")\n",
+                "        try:\n",
+                "            librosa.display.waveshow(original_wav, alpha=0.5, ax=axes[0], label=\"Original\")\n",
+                "            librosa.display.waveshow(generated_wav, alpha=0.5, ax=axes[0], label=\"Cloned\", color='r')\n",
+                "            axes[0].legend()\n",
+                "        except:\n",
+                "            axes[0].plot(original_wav, alpha=0.5, label=\"Original\")\n",
+                "            axes[0].plot(generated_wav, alpha=0.5, label=\"Cloned\", color='r')\n",
+                "            axes[0].legend()\n",
+                "\n",
+                "        axes[1].set_title(\"Generated Mel Spectrogram\")\n",
+                "        im = axes[1].imshow(spec, aspect=\"auto\", origin=\"lower\", interpolation='none')\n",
+                "        fig.colorbar(im, ax=axes[1])\n",
+                "\n",
+                "        axes[2].set_title(\"Speaker Embedding (256-D Heatmap)\")\n",
+                "        if len(embed) == 256:\n",
+                "            axes[2].imshow(embed.reshape(16, 16), aspect='auto', cmap='viridis')\n",
+                "        else:\n",
+                "            axes[2].plot(embed)\n",
+                "\n",
+                "        plt.tight_layout()\n",
+                "        plt.show()\n",
+                "    except Exception as e:\n",
+                "        print(f\"\u26a0\ufe0f Graphs partially failed: {e}. Audio was successful.\")\n",
+                "\n",
+                "# --- \ud83d\udee1\ufe0f IMPROVED SAMPLE DISCOVERY ---\n",
+                "def find_samples_dir():\n",
+                "    \"\"\"Locates reference samples with high persistence across all environments.\"\"\"\n",
+                "    # Priority paths\n",
+                "    priority_roots = [\n",
+                "        \"Source Code/samples\",\n",
+                "        \"Dataset/samples\",\n",
+                "        \"D:/GitHub/DEEPFAKE-AUDIO/Source Code/samples\",\n",
+                "        \"D:/GitHub/DEEPFAKE-AUDIO/Dataset/samples\",\n",
+                "        \"/content/DEEPFAKE-AUDIO/Source Code/samples\",\n",
+                "        \"/kaggle/input/deepfakeaudio/samples\",\n",
+                "        \"/kaggle/input/deepfakeaudio\"\n",
+                "    ]\n",
+                "\n",
+                "    def filter_real_audio(d):\n",
+                "        if not os.path.exists(d): return []\n",
+                "        # Check if files are real audio (not small LFS pointers < 1KB)\n",
+                "        return [f for f in os.listdir(d) if f.lower().endswith((\".wav\", \".mp3\")) and os.path.getsize(os.path.join(d, f)) > 1024]\n",
+                "\n",
+                "    for d in priority_roots:\n",
+                "        files = filter_real_audio(d)\n",
+                "        if files:\n",
+                "            print(f\"\u2705 Samples located at: {os.path.abspath(d)}\")\n",
+                "            return d, files\n",
+                "\n",
+                "    # More aggressive glob search\n",
+                "    print(\"\ud83d\udd0d Searching folders for audio samples...\")\n",
+                "    potential_matches = glob.glob(\"**/samples/*.wav\", recursive=True) + glob.glob(\"**/samples/*.mp3\", recursive=True)\n",
+                "    valid_matches = [m for m in potential_matches if os.path.getsize(m) > 1024]\n",
+                "\n",
+                "    if valid_matches:\n",
+                "        root = os.path.dirname(valid_matches[0])\n",
+                "        files = [os.path.basename(f) for f in glob.glob(os.path.join(root, \"*.*\")) if f.lower().endswith((\".wav\", \".mp3\")) and os.path.getsize(f) > 1024]\n",
+                "        print(f\"\u2728 Located samples via glob at: {os.path.abspath(root)}\")\n",
+                "        return root, files\n",
+                "\n",
+                "    return None, []\n",
+                "\n",
+                "print(\"Select Input Method:\")\n",
+                "tab = widgets.Tab()\n",
+                "\n",
+                "samples_dir, preset_files = find_samples_dir()\n",
+                "if samples_dir:\n",
+                "    preset_files.sort()\n",
+                "    for name in reversed([\"Donald Trump.wav\", \"Steve Jobs.wav\"]):\n",
+                "        if name in preset_files:\n",
+                "            preset_files.insert(0, preset_files.pop(preset_files.index(name)))\n",
+                "else:\n",
+                "    print(\"\u26a0\ufe0f Warning: No reference samples found. Please run the setup cell or upload manually.\")\n",
+                "\n",
+                "dropdown = widgets.Dropdown(options=preset_files,\n",
+                "                            value=preset_files[0] if preset_files else None,\n",
+                "                            description='Preset:')\n",
+                "uploader = widgets.FileUpload(accept='.wav,.mp3', multiple=False)\n",
+                "record_btn = widgets.Button(description=\"Start Recording (10s)\", button_style='danger')\n",
+                "record_out = widgets.Output()\n",
+                "\n",
+                "def on_record_click(b):\n",
+                "    with record_out:\n",
+                "        record_btn.disabled = True\n",
+                "        try: record_audio(10)\n",
+                "        except Exception as e: print(f\"Error: {e}.\")\n",
+                "        record_btn.disabled = False\n",
+                "record_btn.on_click(on_record_click)\n",
+                "\n",
+                "# Tab assignment MUST use .children attribute\n",
+                "tab.children = [\n",
+                "    widgets.VBox([dropdown]),\n",
+                "    widgets.VBox([uploader]),\n",
+                "    widgets.VBox([record_btn, record_out])\n",
+                "]\n",
+                "tab.set_title(0, '\ud83c\udfb5 Presets')\n",
+                "tab.set_title(1, '\ud83d\udcc2 Upload')\n",
+                "tab.set_title(2, '\ud83d\udd34 Record')\n",
+                "display(tab)\n",
+                "\n",
+                "text_input = widgets.Textarea(\n",
+                "    value=\"Hello, I'm Elon Musk. Welcome to Deepfake Audio by Amey Thakur and Mega Satish. Explore AI voice Go!\",\n",
+                "    placeholder='Enter text to synthesize...',\n",
+                "    description='Text:',\n",
+                "    layout=widgets.Layout(width='50%', height='100px')\n",
+                ")\n",
+                "clone_btn = widgets.Button(description=\"Clone Voice! \ud83d\ude80\", button_style='primary')\n",
+                "out = widgets.Output()\n",
+                "display(text_input, clone_btn, out)\n",
+                "\n",
+                "def run_cloning(b):\n",
+                "    with out:\n",
+                "        out.clear_output()\n",
+                "        active_tab = tab.selected_index\n",
+                "        input_path = None\n",
+                "        try:\n",
+                "            if active_tab == 0:\n",
+                "                 if not dropdown.value: return print(\"\u274c No preset selected.\")\n",
+                "                 input_path = os.path.join(samples_dir, dropdown.value)\n",
+                "                 print(f\"\ud83c\udf99\ufe0f Source: Preset ({dropdown.value})\")\n",
+                "            elif active_tab == 1:\n",
+                "                 if not uploader.value: return print(\"\u274c No file uploaded.\")\n",
+                "                 fname = list(uploader.value.keys())[0]\n",
+                "                 content = uploader.value[fname]['content']\n",
+                "                 input_path = \"uploaded_sample.wav\"\n",
+                "                 with open(input_path, \"wb\") as f: f.write(content)\n",
+                "                 print(f\"\ud83c\udf99\ufe0f Source: Upload ({fname})\")\n",
+                "            elif active_tab == 2:\n",
+                "                 if not os.path.exists(\"recording.wav\"): return print(\"\u274c No recording found.\")\n",
+                "                 input_path = \"recording.wav\"\n",
+                "                 print(\"\ud83c\udf99\ufe0f Source: Microphone\")\n",
+                "\n",
+                "            print(\"\u23f3 Step 1/3: Encoding speaker identity...\")\n",
+                "            original_wav, sampling_rate = librosa.load(input_path)\n",
+                "            preprocessed_wav = encoder.preprocess_wav(original_wav, sampling_rate)\n",
+                "            embed = encoder.embed_utterance(preprocessed_wav)\n",
+                "            print(\"\u23f3 Step 2/3: Synthesizing speech...\")\n",
+                "            specs = synthesizer.synthesize_spectrograms([text_input.value], [embed])\n",
+                "            spec = specs[0]\n",
+                "            print(\"\u23f3 Step 3/3: Generating waveform...\")\n",
+                "            generated_wav = vocoder.infer_waveform(spec)\n",
+                "            print(\"\ud83c\udf89 Synthesis Complete!\")\n",
+                "            display(Audio(generated_wav, rate=synthesizer.sample_rate))\n",
+                "            print(\"\\n\ud83d\udcca Generating Analysis...\")\n",
+                "            visualize_results(original_wav, generated_wav, spec, embed)\n",
+                "        except Exception as e: print(f\"\u274c Error: {e}\")\n",
+                "clone_btn.on_click(run_cloning)"
+            ]
+        }
+    ],
+    "metadata": {
+        "kernelspec": {
+            "display_name": "Python 3",
+            "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.10.12"
+        },
+        "colab": {
+            "provenance": [],
+            "gpuType": "T4",
+            "include_colab_link": true
+        },
+        "accelerator": "GPU"
+    },
+    "nbformat": 4,
+    "nbformat_minor": 0
+}

DEEPFAKE-AUDIO.py

@@ -0,0 +1,689 @@
+# ==================================================================================================
+# DEEPFAKE-AUDIO - DEEPFAKE-AUDIO.py (Neural Voice Cloning Research Script)
+# ==================================================================================================
+#
+# 📝 DESCRIPTION
+# This script is a comprehensive, production-ready Python implementation of the SV2TTS
+# (Speaker Verification to Text-to-Speech) voice cloning pipeline. It is a direct
+# conversion of the 'DEEPFAKE-AUDIO.ipynb' Jupyter notebook, designed to run in both
+# local and cloud (Colab/Kaggle) environments.
+#
+# The pipeline enables cloning a voice from as little as 5 seconds of audio. It consists
+# of three distinct neural networks:
+#   1. Speaker Encoder: Extracts a fixed-dimensional embedding (fingerprint) from
+#      the reference audio.
+#   2. Synthesizer (Tacotron 2): Generates a Mel-Spectrogram from text, conditioned
+#      on the speaker embedding.
+#   3. Vocoder (WaveRNN): Converts the Mel-Spectrogram into a raw time-domain waveform
+#      (audible speech).
+#
+# KEY FEATURES:
+# - Cross-Platform: Runs seamlessly on Windows, Linux, Google Colab, and Kaggle.
+# - Robust Fallbacks: Implements a multi-source data retrieval strategy (Local ->
+#   Kaggle -> Hugging Face) to guarantee model availability.
+# - Interactive Mode: Supports preset samples, local file uploads, and microphone
+#   recording (Colab only).
+# - Analysis & Visualization: Generates waveform comparisons, Mel-Spectrograms, and
+#   speaker embedding heatmaps.
+#
+# 👤 AUTHORS
+# - Amey Thakur
+#   - GitHub: https://github.com/Amey-Thakur
+#   - ORCID: https://orcid.org/0000-0001-5644-1575
+#   - Google Scholar: https://scholar.google.ca/citations?user=0inooPgAAAAJ
+# - Mega Satish
+#   - GitHub: https://github.com/msatmod
+#   - ORCID: https://orcid.org/0000-0002-1844-9557
+#   - Google Scholar: https://scholar.google.ca/citations?user=7Ajrr6EAAAAJ
+#
+# 🤝🏻 CREDITS
+# This project builds upon the foundational work of the Real-Time Voice Cloning project.
+# Original Repository: https://github.com/CorentinJ/Real-Time-Voice-Cloning
+# Pre-trained Models: https://huggingface.co/CorentinJ/SV2TTS
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Live Demo: https://huggingface.co/spaces/ameythakur/Deepfake-Audio
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Kaggle Dataset: https://www.kaggle.com/datasets/ameythakur20/deepfakeaudio
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================
+
+"""
+DEEPFAKE-AUDIO.py: A complete, standalone script for neural voice cloning.
+
+This script provides a command-line interface for the SV2TTS voice cloning pipeline.
+It can be run directly or imported as a module.
+
+Usage:
+    python DEEPFAKE-AUDIO.py [--preset <name>] [--input <path>] [--text <text>]
+
+Example:
+    python DEEPFAKE-AUDIO.py --preset "Steve Jobs.wav" --text "Hello, this is a cloned voice."
+"""
+
+# ==================================================================================================
+# SECTION 1: IMPORTS & GLOBAL CONFIGURATION
+# ==================================================================================================
+# This section imports all necessary libraries and sets up global variables. It handles
+# environment detection and defines paths for data and model discovery.
+
+import os
+import sys
+import shutil
+import glob
+import argparse
+from pathlib import Path
+
+# --- Cross-Platform Compatibility ---
+# Ensure the 'Source Code' directory is on Python's path for module imports.
+# This is critical for accessing the encoder, synthesizer, and vocoder submodules.
+SCRIPT_DIR = Path(__file__).resolve().parent
+SOURCE_CODE_PATH = SCRIPT_DIR / "Source Code"
+if str(SOURCE_CODE_PATH) not in sys.path:
+    sys.path.insert(0, str(SOURCE_CODE_PATH))
+
+# --- Cloud Environment Detection ---
+# These flags help adapt the script's behavior based on the runtime environment.
+IS_COLAB = "google.colab" in sys.modules
+IS_KAGGLE = "KAGGLE_KERNEL_RUN_TYPE" in os.environ
+
+
+# ==================================================================================================
+# SECTION 2: CLOUD ENVIRONMENT SETUP (COLAB/KAGGLE)
+# ==================================================================================================
+# This function is designed to run exclusively in cloud notebook environments.
+# It handles repository cloning, dependency installation, and data retrieval with
+# multiple fallback sources.
+
+def setup_cloud_environment():
+    """
+    Orchestrates the cloud environment setup for Google Colab and Kaggle.
+
+    This function performs the following steps:
+    1. Clones the DEEPFAKE-AUDIO repository from GitHub.
+    2. Falls back to Hugging Face if GitHub cloning fails.
+    3. Installs necessary system (libsndfile1) and Python dependencies.
+    4. Attempts to pull large files via Git LFS.
+    5. Falls back to Kagglehub for data if LFS budget is exceeded.
+    """
+    try:
+        # Attempt to get the IPython shell for executing system commands.
+        shell = get_ipython()
+    except NameError:
+        # If NameError, we are not in an interactive IPython environment.
+        print("🏠 Running in local or custom environment. Skipping cloud setup.")
+        return
+
+    repo_name = "DEEPFAKE-AUDIO"
+
+    # --- Google Colab Specific Setup ---
+    if IS_COLAB:
+        print("💻 Detected Google Colab Environment. Initiating setup...")
+        colab_working_dir = f"/content/{repo_name}"
+
+        # Step 1: Clone the Repository
+        if not os.path.exists(colab_working_dir):
+            print("⬇️ Cloning DEEPFAKE-AUDIO repository from GitHub...")
+            shell.system(f"git clone https://github.com/Amey-Thakur/{repo_name}")
+
+            # Fallback to Hugging Face if GitHub clone fails
+            if not os.path.exists(colab_working_dir) or not os.listdir(colab_working_dir):
+                print("⚠️ GitHub Clone Failed. Attempting Fallback: Hugging Face Space...")
+                if os.path.exists(colab_working_dir):
+                    shutil.rmtree(colab_working_dir)
+                shell.system(f"git clone https://huggingface.co/spaces/ameythakur/Deepfake-Audio {repo_name}")
+                print("✅ Cloned from Hugging Face Space.")
+
+        os.chdir(colab_working_dir)
+
+        # Step 2: Install Dependencies
+        print("🔧 Installing system and Python dependencies...")
+        shell.system("apt-get install -y libsndfile1")
+        deps = "librosa==0.9.2 unidecode webrtcvad inflect umap-learn scikit-learn>=1.3 tqdm scipy 'matplotlib>=3.7,<3.9' Pillow>=10.2 soundfile huggingface_hub"
+        shell.system(f"pip install {deps}")
+
+        # Step 3: Attempt Git LFS Pull
+        print("📦 Attempting Git LFS pull for large model files...")
+        shell.system("git lfs install")
+        lfs_status = shell.system("git lfs pull")
+
+        # Step 4: Kaggle Fallback if LFS Fails
+        # Check for a valid sample file to determine LFS success.
+        sample_trigger = "Dataset/samples/Steve Jobs.wav"
+        is_lfs_failed = (
+            lfs_status != 0 or
+            not os.path.exists(sample_trigger) or
+            os.path.getsize(sample_trigger) < 1000  # LFS pointers are < 1KB
+        )
+
+        if is_lfs_failed:
+            print("⚠️ GitHub LFS failed or exceeded budget. Using Kaggle Fallback...")
+            shell.system("pip install kagglehub")
+            import kagglehub
+            print("🚀 Downloading assets from Kagglehub (ameythakur20/deepfakeaudio)...")
+            kaggle_path = kagglehub.dataset_download("ameythakur20/deepfakeaudio")
+            _link_kaggle_assets(kaggle_path)
+
+    # --- Kaggle Specific Setup ---
+    elif IS_KAGGLE:
+        print("💻 Detected Kaggle Environment. Initiating setup...")
+        kaggle_working_dir = f"/kaggle/working/{repo_name}"
+
+        # Step 1: Clone the Repository
+        if not os.path.exists(kaggle_working_dir):
+            print("⬇️ Cloning DEEPFAKE-AUDIO repository from GitHub...")
+            os.chdir("/kaggle/working")
+            shell.system(f"git clone https://github.com/Amey-Thakur/{repo_name}")
+
+        os.chdir(kaggle_working_dir)
+
+        # Step 2: Link Kaggle Dataset (Highest Priority on Kaggle)
+        kaggle_input_path = "/kaggle/input/deepfakeaudio"
+        if os.path.exists(kaggle_input_path):
+            print(f"✅ Kaggle Dataset Detected at {kaggle_input_path}. Linking assets...")
+            _link_kaggle_assets(kaggle_input_path)
+        else:
+            print("⚠️ Kaggle Input not found. Attempting Git LFS pull...")
+            shell.system("git lfs install")
+            shell.system("git lfs pull")
+
+        # Step 3: Install Dependencies
+        print("🔧 Installing dependencies...")
+        shell.system("apt-get install -y libsndfile1")
+        deps = "librosa==0.9.2 unidecode webrtcvad inflect umap-learn scikit-learn>=1.3 tqdm scipy 'matplotlib>=3.7,<3.9' Pillow>=10.2 soundfile huggingface_hub"
+        shell.system(f"pip install {deps}")
+        print("✅ Environment setup complete. Ready for cloning.")
+
+
+def _link_kaggle_assets(source_path):
+    """
+    Helper function to create symbolic links from Kaggle data to the expected 'Dataset/' folder.
+
+    Args:
+        source_path: The root path of the downloaded/linked Kaggle data.
+    """
+    target_dir = "Dataset"
+    os.makedirs(target_dir, exist_ok=True)
+
+    # Link samples folder
+    k_samples = os.path.join(source_path, "samples")
+    target_samples = os.path.join(target_dir, "samples")
+    if os.path.exists(k_samples):
+        if os.path.exists(target_samples):
+            shutil.rmtree(target_samples)
+        os.symlink(k_samples, target_samples)
+        print("✅ Samples linked from Kaggle.")
+
+    # Link model files
+    for model_name in ["encoder.pt", "synthesizer.pt", "vocoder.pt"]:
+        src = os.path.join(source_path, model_name)
+        dst = os.path.join(target_dir, model_name)
+        if os.path.exists(src):
+            if os.path.exists(dst):
+                os.remove(dst)
+            os.symlink(src, dst)
+    print("✅ Models linked from Kaggle.")
+
+
+# ==================================================================================================
+# SECTION 3: MODEL & DATA INITIALIZATION
+# ==================================================================================================
+# This section handles the discovery and validation of model checkpoints (encoder,
+# synthesizer, vocoder). It implements a priority-based search across local paths,
+# Kaggle datasets, and Hugging Face.
+
+def is_valid_checkpoint(filepath):
+    """
+    Validates a file path to ensure it's a real model checkpoint and not an
+    LFS pointer file.
+
+    Args:
+        filepath: Path object or string to the file.
+
+    Returns:
+        True if the file exists and is larger than 1KB, False otherwise.
+    """
+    path = Path(filepath)
+    return path.exists() and path.stat().st_size > 1000
+
+
+def resolve_checkpoint_path(component_name: str, legacy_suffix: str) -> Path:
+    """
+    Resolves the path to a model checkpoint using a priority-based search strategy.
+
+    Search Order:
+    1. Local 'Dataset/' folder (part of the repository).
+    2. Kaggle Input directory (`/kaggle/input/deepfakeaudio/`).
+    3. Auto-downloaded 'pretrained_models/default/' folder.
+    4. Legacy/manual paths for advanced users.
+
+    Args:
+        component_name: The name of the component ('Encoder', 'Synthesizer', 'Vocoder').
+        legacy_suffix: A fallback path suffix for older project structures.
+
+    Returns:
+        A Path object to the checkpoint, or None if not found.
+    """
+    model_filename = f"{component_name.lower()}.pt"
+
+    # Priority 1: Local Repository 'Dataset/' folder
+    local_path = Path("Dataset") / model_filename
+    if is_valid_checkpoint(local_path):
+        print(f"🟢 Loading {component_name} from Repository: {local_path}")
+        return local_path
+
+    # Priority 2: Kaggle Environment
+    kaggle_path = Path("/kaggle/input/deepfakeaudio") / model_filename
+    if is_valid_checkpoint(kaggle_path):
+        print(f"🟢 Loading {component_name} from Kaggle: {kaggle_path}")
+        return kaggle_path
+
+    # Priority 3: Auto-Downloaded Fallback ('pretrained_models/default/')
+    default_path = Path("pretrained_models/default") / model_filename
+    if is_valid_checkpoint(default_path):
+        print(f"🟢 Loading {component_name} from Fallback: {default_path}")
+        return default_path
+
+    # Priority 4: Legacy/Manual Paths
+    legacy_path = Path("pretrained_models") / legacy_suffix
+    if legacy_path.exists():
+        if legacy_path.is_dir():
+            pts = [f for f in legacy_path.glob("*.pt") if is_valid_checkpoint(f)]
+            if pts:
+                return pts[0]
+        elif is_valid_checkpoint(legacy_path):
+            return legacy_path
+
+    print(f"⚠️ Warning: {component_name} checkpoint not found!")
+    return None
+
+
+def download_models_from_huggingface():
+    """
+    Attempts to download model checkpoints from Hugging Face if they are not
+    found locally.
+
+    Tries the following sources in order:
+    1. Personal Hugging Face Space: `ameythakur/Deepfake-Audio`
+    2. External Fallback: Uses the `utils.default_models` script.
+    """
+    from huggingface_hub import hf_hub_download
+
+    core_models = ["encoder.pt", "synthesizer.pt", "vocoder.pt"]
+    target_dir = Path("pretrained_models")
+    target_dir.mkdir(exist_ok=True)
+
+    print("🚀 Attempting download from Hugging Face Space (ameythakur/Deepfake-Audio)...")
+    try:
+        for model in core_models:
+            try:
+                # Try nested path first (Dataset/model.pt)
+                fpath = hf_hub_download(
+                    repo_id="ameythakur/Deepfake-Audio",
+                    filename=f"Dataset/{model}",
+                    repo_type="space",
+                    local_dir=str(target_dir)
+                )
+            except Exception:
+                # Try root path (model.pt)
+                fpath = hf_hub_download(
+                    repo_id="ameythakur/Deepfake-Audio",
+                    filename=model,
+                    repo_type="space",
+                    local_dir=str(target_dir)
+                )
+            target_file = target_dir / model
+            if Path(fpath) != target_file and Path(fpath).exists():
+                shutil.move(fpath, target_file)
+
+        nested_folder = target_dir / "Dataset"
+        if nested_folder.exists():
+            shutil.rmtree(nested_folder)
+        print("✅ Models successfully acquired via Personal Hugging Face fallback.")
+        return True
+    except Exception as e:
+        print(f"⚠️ Personal HF download failed: {e}. Trying external fallback...")
+
+    # External Fallback: Use the utility script from the project
+    try:
+        from utils.default_models import ensure_default_models
+        ensure_default_models(target_dir)
+        print("✅ Models successfully acquired via External HuggingFace fallback.")
+        return True
+    except Exception as e:
+        print(f"❌ Critical: Could not auto-download models. Error: {e}")
+        return False
+
+
+def verify_and_load_pipeline():
+    """
+    Verifies the availability of model checkpoints and loads the SV2TTS pipeline.
+
+    This function first checks for locally available models. If models are missing,
+    it attempts to download them from Hugging Face. Finally, it loads the encoder,
+    synthesizer, and vocoder into memory.
+
+    Returns:
+        A tuple containing (encoder_module, synthesizer_instance, vocoder_module),
+        or None if loading fails.
+    """
+    import torch
+    from encoder import inference as encoder
+    from synthesizer.inference import Synthesizer
+    from vocoder import inference as vocoder
+
+    print(f"🎯 Computation Device: {'cuda' if torch.cuda.is_available() else 'cpu'}")
+    print("⬇️ Verifying Model Availability...")
+
+    core_models = ["encoder.pt", "synthesizer.pt", "vocoder.pt"]
+    dataset_models_present = all(
+        is_valid_checkpoint(Path("Dataset") / m) for m in core_models
+    )
+
+    if dataset_models_present:
+        print("✅ Found high-priority local models in 'Dataset/'. Verified.")
+    else:
+        # Attempt to download if not present
+        kaggle_path = Path("/kaggle/input/deepfakeaudio")
+        kaggle_models_present = all(
+            is_valid_checkpoint(kaggle_path / m) for m in core_models
+        )
+        if not kaggle_models_present:
+            print("⚠️ Models not found locally. Attempting fallback download...")
+            download_models_from_huggingface()
+
+    print("⏳ Loading Neural Networks (SV2TTS Pipeline)...")
+    try:
+        # 1. Encoder: Extract speaker embedding
+        encoder_path = resolve_checkpoint_path("Encoder", "encoder/saved_models")
+        encoder.load_model(encoder_path)
+
+        # 2. Synthesizer: Generates spectrograms from text
+        synth_path = resolve_checkpoint_path(
+            "Synthesizer", "synthesizer/saved_models/logs-pretrained/taco_pretrained"
+        )
+        synthesizer_instance = Synthesizer(synth_path)
+
+        # 3. Vocoder: Converts spectrograms to audio waveforms
+        vocoder_path = resolve_checkpoint_path("Vocoder", "vocoder/saved_models/pretrained")
+        vocoder.load_model(vocoder_path)
+
+        print("✅ Pipeline operational. All components loaded correctly.")
+        return encoder, synthesizer_instance, vocoder
+    except Exception as e:
+        print(f"❌ Architecture Error: {e}")
+        return None
+
+
+# ==================================================================================================
+# SECTION 4: AUDIO SAMPLE DISCOVERY
+# ==================================================================================================
+# This section provides utilities for finding reference audio samples (e.g., celebrity
+# presets) across various locations in the file system.
+
+def find_samples_directory():
+    """
+    Locates the directory containing reference audio samples.
+
+    Searches through a prioritized list of paths and returns the first one
+    containing valid audio files (>.wav or .mp3 > 1KB).
+
+    Returns:
+        A tuple (samples_dir_path, list_of_filenames) or (None, []) if not found.
+    """
+    priority_paths = [
+        "Source Code/samples",
+        "Dataset/samples",
+        "D:/GitHub/DEEPFAKE-AUDIO/Source Code/samples",
+        "D:/GitHub/DEEPFAKE-AUDIO/Dataset/samples",
+        "/content/DEEPFAKE-AUDIO/Source Code/samples",
+        "/kaggle/input/deepfakeaudio/samples",
+        "/kaggle/input/deepfakeaudio",
+    ]
+
+    def get_valid_audio_files(directory):
+        """Filters a directory for real audio files (not LFS pointers)."""
+        if not os.path.exists(directory):
+            return []
+        return [
+            f for f in os.listdir(directory)
+            if f.lower().endswith((".wav", ".mp3")) and
+               os.path.getsize(os.path.join(directory, f)) > 1024
+        ]
+
+    for path in priority_paths:
+        files = get_valid_audio_files(path)
+        if files:
+            print(f"✅ Samples located at: {os.path.abspath(path)}")
+            return path, files
+
+    # Fallback: Use glob to search recursively
+    print("🔍 Searching for audio samples via glob...")
+    potential_matches = (
+        glob.glob("**/samples/*.wav", recursive=True) +
+        glob.glob("**/samples/*.mp3", recursive=True)
+    )
+    valid_matches = [m for m in potential_matches if os.path.getsize(m) > 1024]
+
+    if valid_matches:
+        root_dir = os.path.dirname(valid_matches[0])
+        files = [os.path.basename(f) for f in valid_matches]
+        print(f"✨ Located samples via glob at: {os.path.abspath(root_dir)}")
+        return root_dir, list(set(files))
+
+    return None, []
+
+
+# ==================================================================================================
+# SECTION 5: INFERENCE & VISUALIZATION
+# ==================================================================================================
+# This section contains the core voice cloning logic and functions for visualizing
+# the results (waveforms, spectrograms, embeddings).
+
+def clone_voice(
+    encoder_module,
+    synthesizer_instance,
+    vocoder_module,
+    input_audio_path: str,
+    text_to_synthesize: str
+):
+    """
+    Performs the voice cloning inference.
+
+    This is the main function that orchestrates the three-stage pipeline:
+    encode -> synthesize -> vocalize.
+
+    Args:
+        encoder_module: The loaded encoder module.
+        synthesizer_instance: The loaded Synthesizer instance.
+        vocoder_module: The loaded vocoder module.
+        input_audio_path: Path to the reference audio file.
+        text_to_synthesize: The text string to be spoken by the cloned voice.
+
+    Returns:
+        A tuple (generated_waveform, mel_spectrogram, speaker_embedding, original_waveform).
+    """
+    import numpy as np
+    import librosa
+
+    print(f"🎙️ Reference Audio: {input_audio_path}")
+    print(f"📝 Text to Clone: \"{text_to_synthesize[:80]}...\"" if len(text_to_synthesize) > 80 else f"📝 Text to Clone: \"{text_to_synthesize}\"")
+
+    # --- Step 1: Encode ---
+    # Load the reference audio and preprocess it for the encoder.
+    print("⏳ Step 1/3: Encoding speaker identity...")
+    original_wav, sampling_rate = librosa.load(input_audio_path)
+    preprocessed_wav = encoder_module.preprocess_wav(original_wav, sampling_rate)
+    speaker_embedding = encoder_module.embed_utterance(preprocessed_wav)
+    print(f"   -> Embedding shape: {speaker_embedding.shape}")
+
+    # --- Step 2: Synthesize ---
+    # Generate a Mel-Spectrogram from the text, conditioned on the speaker embedding.
+    print("⏳ Step 2/3: Synthesizing speech (Mel-Spectrogram)...")
+    specs = synthesizer_instance.synthesize_spectrograms([text_to_synthesize], [speaker_embedding])
+    mel_spectrogram = specs[0]
+    print(f"   -> Spectrogram shape: {mel_spectrogram.shape}")
+
+    # --- Step 3: Vocalize ---
+    # Convert the Mel-Spectrogram into a raw audio waveform.
+    print("⏳ Step 3/3: Generating waveform (WaveRNN)...")
+    generated_wav = vocoder_module.infer_waveform(mel_spectrogram)
+    print(f"   -> Waveform length: {len(generated_wav)} samples")
+
+    print("🎉 Synthesis Complete!")
+    return generated_wav, mel_spectrogram, speaker_embedding, original_wav
+
+
+def visualize_results(original_wav, generated_wav, mel_spectrogram, speaker_embedding):
+    """
+    Generates a multi-panel visualization of the cloning results.
+
+    Creates a figure with three subplots:
+    1. Waveform comparison: Original vs. Cloned audio.
+    2. Generated Mel-Spectrogram.
+    3. Speaker Embedding heatmap.
+
+    Args:
+        original_wav: The original waveform as a NumPy array.
+        generated_wav: The generated waveform as a NumPy array.
+        mel_spectrogram: The Mel-Spectrogram as a NumPy array.
+        speaker_embedding: The 256-D speaker embedding vector.
+    """
+    import matplotlib.pyplot as plt
+    import librosa.display
+
+    try:
+        fig, axes = plt.subplots(3, 1, figsize=(12, 14))
+
+        # --- Panel 1: Waveform Comparison ---
+        axes[0].set_title("Input Voice vs. Cloned Voice (Waveform)", fontsize=14)
+        try:
+            librosa.display.waveshow(original_wav, alpha=0.6, ax=axes[0], label="Original", color='blue')
+            librosa.display.waveshow(generated_wav, alpha=0.6, ax=axes[0], label="Cloned", color='red')
+        except Exception:
+            axes[0].plot(original_wav, alpha=0.6, label="Original", color='blue')
+            axes[0].plot(generated_wav, alpha=0.6, label="Cloned", color='red')
+        axes[0].legend(loc='upper right')
+        axes[0].set_xlabel("Time")
+        axes[0].set_ylabel("Amplitude")
+
+        # --- Panel 2: Mel-Spectrogram ---
+        axes[1].set_title("Generated Mel Spectrogram", fontsize=14)
+        img = axes[1].imshow(mel_spectrogram, aspect="auto", origin="lower", interpolation="none", cmap='magma')
+        fig.colorbar(img, ax=axes[1], format="%+2.0f dB")
+        axes[1].set_xlabel("Time Frames")
+        axes[1].set_ylabel("Mel Frequency Bins")
+
+        # --- Panel 3: Speaker Embedding ---
+        axes[2].set_title("Speaker Embedding (256-D Identity Fingerprint)", fontsize=14)
+        if len(speaker_embedding) == 256:
+            axes[2].imshow(speaker_embedding.reshape(16, 16), aspect='auto', cmap='viridis')
+        else:
+            axes[2].plot(speaker_embedding)
+        axes[2].set_xlabel("Dimension")
+        axes[2].set_ylabel("Value")
+
+        plt.tight_layout()
+        plt.savefig("cloning_results.png", dpi=150)
+        print("📊 Analysis saved to 'cloning_results.png'.")
+        plt.show()
+    except Exception as e:
+        print(f"⚠️ Visualization partially failed: {e}. Audio cloning was successful.")
+
+
+# ==================================================================================================
+# SECTION 6: MAIN EXECUTION
+# ==================================================================================================
+# This is the entry point for the script when run from the command line.
+
+def main():
+    """
+    Main entry point for the DEEPFAKE-AUDIO script.
+
+    Parses command-line arguments and runs the voice cloning pipeline.
+    """
+    parser = argparse.ArgumentParser(
+        description="DEEPFAKE-AUDIO: Neural Voice Cloning with SV2TTS",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python DEEPFAKE-AUDIO.py --preset "Steve Jobs.wav" --text "Hello world!"
+  python DEEPFAKE-AUDIO.py --input "my_voice.wav" --text "This is a cloned message."
+        """
+    )
+    parser.add_argument(
+        "--preset", type=str, default=None,
+        help="Name of a preset sample file (e.g., 'Steve Jobs.wav')."
+    )
+    parser.add_argument(
+        "--input", type=str, default=None,
+        help="Path to a custom audio file to use as the voice reference."
+    )
+    parser.add_argument(
+        "--text", type=str,
+        default="Hello, I'm a cloned voice. Welcome to Deepfake Audio by Amey Thakur and Mega Satish.",
+        help="The text to be synthesized by the cloned voice."
+    )
+    parser.add_argument(
+        "--output", type=str, default="cloned_output.wav",
+        help="Path to save the generated audio file."
+    )
+
+    args = parser.parse_args()
+
+    # --- Step 1: Cloud Setup (if applicable) ---
+    setup_cloud_environment()
+
+    # --- Step 2: Verify and Load Pipeline ---
+    pipeline = verify_and_load_pipeline()
+    if pipeline is None:
+        print("❌ Failed to load the SV2TTS pipeline. Exiting.")
+        sys.exit(1)
+    encoder_mod, synthesizer_inst, vocoder_mod = pipeline
+
+    # --- Step 3: Determine Input Audio ---
+    input_audio_path = None
+    if args.input:
+        input_audio_path = args.input
+    elif args.preset:
+        samples_dir, _ = find_samples_directory()
+        if samples_dir:
+            input_audio_path = os.path.join(samples_dir, args.preset)
+        else:
+            print(f"❌ Could not find samples directory for preset '{args.preset}'.")
+            sys.exit(1)
+    else:
+        # Default to first available preset
+        samples_dir, preset_files = find_samples_directory()
+        if samples_dir and preset_files:
+            input_audio_path = os.path.join(samples_dir, preset_files[0])
+            print(f"ℹ️ No input specified. Using default preset: {preset_files[0]}")
+        else:
+            print("❌ No input audio provided and no presets found. Exiting.")
+            sys.exit(1)
+
+    if not os.path.exists(input_audio_path):
+        print(f"❌ Audio file not found: {input_audio_path}")
+        sys.exit(1)
+
+    # --- Step 4: Run Inference ---
+    generated_wav, mel_spec, embedding, original_wav = clone_voice(
+        encoder_mod, synthesizer_inst, vocoder_mod,
+        input_audio_path, args.text
+    )
+
+    # --- Step 5: Save Output ---
+    import soundfile as sf
+    sf.write(args.output, generated_wav, synthesizer_inst.sample_rate)
+    print(f"💾 Cloned audio saved to: {args.output}")
+
+    # --- Step 6: Visualize Results ---
+    visualize_results(original_wav, generated_wav, mel_spec, embedding)
+
+
+if __name__ == "__main__":
+    main()

Dataset/encoder.pt

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

Dataset/samples/Andrew Tate.wav

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

Dataset/samples/Barack Obama.wav

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

Dataset/samples/Bill Gates.wav

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

Dataset/samples/Donald Trump.wav

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

Dataset/samples/Elon Musk.wav

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

Dataset/samples/Greta Thunberg.wav

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

Dataset/samples/Hillary Clinton.wav

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

Dataset/samples/J.K. Rowling.wav

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

Dataset/samples/Jensen Huang.wav

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

Dataset/samples/Joe Biden.wav

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

Dataset/samples/Kamala Harris.wav

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

Dataset/samples/Mark Zuckerberg.wav

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

Dataset/samples/Oprah Winfrey.wav

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

Dataset/samples/Steve Jobs.wav

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

Dataset/synthesizer.pt

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

Dataset/vocoder.pt

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

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Amey Thakur & Mega Satish
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,369 @@
+---
+title: Deepfake Audio
+emoji: 🎙️
+colorFrom: indigo
+colorTo: yellow
+sdk: gradio
+sdk_version: 4.44.1
+python_version: 3.11
+app_file: Source Code/app.py
+pinned: false
+---
+
+<div align="center">
+
+  <a name="readme-top"></a>
+  # Deepfake Audio
+
+  [![License: MIT](https://img.shields.io/badge/License-MIT-lightgrey)](LICENSE)
+  ![Status](https://img.shields.io/badge/Status-Completed-success)
+  [![Technology](https://img.shields.io/badge/Technology-Python%20%7C%20Deep%20Learning-blueviolet)](https://github.com/Amey-Thakur/DEEPFAKE-AUDIO)
+  [![Developed by Amey Thakur and Mega Satish](https://img.shields.io/badge/Developed%20by-Amey%20Thakur%20%26%20Mega%20Satish-blue.svg)](https://github.com/Amey-Thakur/DEEPFAKE-AUDIO)
+
+  An advanced neural voice synthesis platform implementing Transfer Learning from Speaker Verification to Multispeaker Text-To-Speech Synthesis (SV2TTS) for high-fidelity zero-shot voice cloning.
+
+  **[Source Code](Source%20Code/Deepfake-Audio/)** &nbsp;·&nbsp; **[Technical Specification](docs/SPECIFICATION.md)** &nbsp;·&nbsp; **[Video Demo](https://youtu.be/i3wnBcbHDbs)** &nbsp;·&nbsp; **[Live Demo](https://huggingface.co/spaces/ameythakur/Deepfake-Audio)**
+
+  <br>
+
+  <a href="https://youtu.be/i3wnBcbHDbs">
+    <img src="https://img.youtube.com/vi/i3wnBcbHDbs/hqdefault.jpg" alt="Video Demo" width="70%">
+  </a>
+
+</div>
+
+---
+
+<div align="center">
+
+  [Authors](#authors) &nbsp;·&nbsp; [Overview](#overview) &nbsp;·&nbsp; [Features](#features) &nbsp;·&nbsp; [Structure](#project-structure) &nbsp;·&nbsp; [Results](#results) &nbsp;·&nbsp; [Quick Start](#quick-start) &nbsp;·&nbsp; [Usage Guidelines](#usage-guidelines) &nbsp;·&nbsp; [License](#license) &nbsp;·&nbsp; [About](#about-this-repository) &nbsp;·&nbsp; [Acknowledgments](#acknowledgments)
+
+</div>
+
+---
+
+<!-- AUTHORS -->
+<div align="center">
+
+  <a name="authors"></a>
+  ## Authors
+
+| <a href="https://github.com/Amey-Thakur"><img src="https://github.com/Amey-Thakur.png" width="150" height="150" alt="Amey Thakur"></a><br>[**Amey Thakur**](https://github.com/Amey-Thakur)<br><br>[![ORCID](https://img.shields.io/badge/ORCID-0000--0001--5644--1575-green.svg)](https://orcid.org/0000-0001-5644-1575) | <a href="https://github.com/msatmod"><img src="Mega/Mega.png" width="150" height="150" alt="Mega Satish"></a><br>[**Mega Satish**](https://github.com/msatmod)<br><br>[![ORCID](https://img.shields.io/badge/ORCID-0000--0002--1844--9557-green.svg)](https://orcid.org/0000-0002-1844-9557) |
+| :---: | :---: |
+
+</div>
+
+> [!IMPORTANT]
+> ### 🤝🏻 Special Acknowledgement
+> *Special thanks to **[Mega Satish](https://github.com/msatmod)** for her meaningful contributions, guidance, and support that helped shape this work.*
+
+---
+
+<!-- OVERVIEW -->
+<a name="overview"></a>
+## Overview
+
+**Deepfake Audio** is a multi-stage neural voice synthesis architecture designed to clone speaker identities and generate high-fidelity speech from textual input. By implementing the **SV2TTS** framework, this project translates skeletal vocal characteristics into a latent embedding, which then conditions a generative model to produce new vocalizations with strikingly natural prosody and timbre.
+
+> [!IMPORTANT]
+> ### Attribution
+> This project builds upon the foundational research and implementation of the **[Real-Time-Voice-Cloning](https://github.com/CorentinJ/Real-Time-Voice-Cloning)** repository by **[Corentin Jemine](https://github.com/CorentinJ)**.
+
+> [!NOTE]
+> ### 🎙️ Defining Audio Deepfakes
+> An **audio deepfake** is when a “cloned” voice that is potentially indistinguishable from the real person’s is used to produce synthetic audio. This process involves utilizing advanced neural architectures, such as the **SV2TTS** framework, to distillate high-dimensional vocal identities into latent embeddings. These embeddings then condition a generative model to synthesize new speech that mirrors the original speaker's prosody, timbre, and acoustic nuances with striking fidelity.
+
+The repository serves as a digital study into the mechanics of neural cloning and signal processing, brought into a modern context via a **Progressive Web App (PWA)** interface, enabling high-performance voice synthesis through a decoupled engine architecture.
+
+### Synthesis Heuristics
+The classification engine is governed by strict **computational design patterns** ensuring fidelity and responsiveness:
+*   **Speaker Normalization**: The encoder utilizes a linear speaker verification pipeline, incrementally distilling lexical tokens into a global affective voice state.
+*   **Zero-Shot Inference**: Beyond simple playback, the system integrates a **Tacotron 2-based synthesizer** that dynamically refines its accuracy over time, simulating an organic learning curve for complex phonetic structures.
+*   **Real-Time Vocoding**: Audio reconstruction supports both streaming and batch generation, ensuring **high-fidelity** waveform response critical for interactive neural study.
+
+> [!TIP]
+> **Acoustic Precision Integration**
+>
+> To maximize cloning clarity, the engine employs a **multi-stage neural pipeline**. **Latent filters** refine the embedding stream, and **probabilistic weights** visualize the voice's confidence vector, strictly coupling acoustic flair with state changes. This ensures the user's mental model is constantly synchronized with the underlying neural simulation.
+
+---
+
+<!-- FEATURES -->
+<a name="features"></a>
+## Features
+
+| Feature | Description |
+|---------|-------------|
+| **SV2TTS Core** | Combines **LSTM Speaker Encoders** with **Tacotron Synthesizers** for comprehensive voice cloning. |
+| **PWA Architecture** | Implements a robust standalone installable interface for immediate neural vocalization study. |
+| **Academic Clarity** | In-depth and detailed comments integrated throughout the codebase for transparent logic study. |
+| **Neural Topology** | Efficient **Decoupled Engine execution** via Gradio and Torch for native high-performance access. |
+| **Inference Pipeline** | Asynchronous architecture ensuring **stability** and responsiveness on local clients. |
+| **Visual Feedback** | **Interactive Status Monitors** that trigger on synthesis events for sensory reward. |
+| **State Feedback** | **Embedding-Based Indicators** and waveform effects for high-impact acoustic feel. |
+| **Social Persistence** | **Interactive Footer Integration** bridging the analysis to the source repository. |
+
+> [!NOTE]
+> ### Interactive Polish: The Acoustic Singularity
+> We have engineered a **Logic-Driven State Manager** that calibrates vocal scores across multiple vectors to simulate human-like identity transfer. The visual language focuses on the minimalist "Neon Mic" aesthetic, ensuring maximum focus on the interactive neural trajectory.
+
+### Tech Stack
+- **Languages**: Python 3.9+
+- **Logic**: **Neural Pipelines** (SV2TTS & Signal Processing)
+- **Frameworks**: **PyTorch** & **TensorFlow** (Inference)
+- **UI System**: Modern Design (Gradio & Custom CSS)
+- **Deployment**: Local execution / Hugging Face Spaces
+- **Architecture**: Progressive Web App (PWA)
+
+---
+
+<!-- STRUCTURE -->
+<a name="project-structure"></a>
+## Project Structure
+
+```python
+DEEPFAKE-AUDIO/
+│
+├── Dataset/                         # Neural Assets
+│   ├── samples/                     # Voice Reference Audio
+│   ├── encoder.pt                   # Speaker Verification Model
+│   ├── synthesizer.pt               # TTS Synthesis Model
+│   └── vocoder.pt                   # Waveform Reconstruction Model
+│
+├── docs/                            # Academic Documentation
+│   └── SPECIFICATION.md             # Technical Architecture
+│
+├── Mega/                            # Attribution Assets
+│   ├── Filly.jpg                    # Companion (Filly)
+│   └── Mega.png                     # Profile Image (Mega Satish)
+│
+├── screenshots/                     # Visual Gallery
+│   ├── 01_landing_page.png
+│   ├── 02_landing_page_footer.png
+│   ├── 03_example_run_config.png
+│   ├── 04_example_run_processing.png
+│   ├── 05_example_run_results.png
+│   ├── 06_example_run_results_footer.png
+│   ├── 07_download_option.png
+│   ├── Audio.wav                    # Sample Output
+│   └── favicon.png                  # Project Icon
+│
+├── Source Code/                     # Primary Application Layer
+│   ├── app.py                       # Gradio Studio Interface
+│   ├── app_ui_demo.py               # UI-Only Verification Mode
+│   ├── Dockerfile                   # Containerization Config
+│   ├── requirements.txt             # Dependency Manifest
+│   ├── favicon.png                  # Application Icon
+│   └── intro_message.wav            # Audio Branding
+│
+├── .gitattributes                   # Signal Normalization
+├── .gitignore                       # Deployment Exclusions
+├── DEEPFAKE-AUDIO.ipynb             # Research Notebook
+├── DEEPFAKE-AUDIO.py                # Research Script (Standalone CLI)
+├── SECURITY.md                      # Security Protocols
+├── CITATION.cff                     # Academic Citation Manifest
+├── codemeta.json                    # Metadata Standard
+├── LICENSE                          # MIT License (Verbatim)
+└── README.md                        # Project Entrance
+```
+
+---
+
+<a name="results"></a>
+## Results
+
+  <div align="center">
+  <b>Main Interface: Modern Design</b>
+  <br>
+  <i>Initial system state with clean aesthetics and synchronized brand identity.</i>
+  <br><br>
+  <img src="screenshots/01_landing_page.png" alt="Landing Page" width="90%">
+  <br>
+  <sub><i>💡 <b>Interactive Element:</b> Engage the title header to activate the system's auditory introduction.</i></sub>
+  <br><br><br>
+
+  <b>Interactive Polish: Footer Integration</b>
+  <br>
+  <i>Seamlessly integrated authorship and social persistence.</i>
+  <br><br>
+  <img src="screenshots/02_landing_page_footer.png" alt="Footer UI" width="90%">
+  <br><br><br>
+
+  <b>Synthesis Setup: Adaptive Config</b>
+  <br>
+  <i>Configuring target text and reference identity for neural cloning.</i>
+  <br><br>
+  <img src="screenshots/03_example_run_config.png" alt="Configuration" width="90%">
+  <br><br><br>
+
+  <b>Neural Processing: Real-Time Inference</b>
+  <br>
+  <i>System Distillery extracting acoustic embeddings and synthesizing mel-spectrograms.</i>
+  <br><br>
+  <img src="screenshots/04_example_run_processing.png" alt="Processing" width="90%">
+  <br><br><br>
+
+  <b>Quantified Output: Generated Results</b>
+  <br>
+  <i>Successful high-fidelity audio synthesis with precise identity fidelity.</i>
+  <br><br>
+  <img src="screenshots/05_example_run_results.png" alt="Results" width="90%">
+  <br><br><br>
+
+  <b>Complete User Flow: Result & Footer</b>
+  <br>
+  <i>Comprehensive view of the post-synthesis state.</i>
+  <br><br>
+  <img src="screenshots/06_example_run_results_footer.png" alt="Results Footer" width="90%">
+  <br><br><br>
+
+  <b>System Options: Audio Export</b>
+  <br>
+  <i>Exporting synthesized waveforms for downstream academic reference.</i>
+  <br><br>
+  <img src="screenshots/07_download_option.png" alt="Download" width="90%">
+  <br><br><br>
+
+  <b>Generated Result Output: Audio Signal</b>
+  <br>
+  <i>Interactive verified output from the neural synthesis pipeline.</i>
+  <br><br>
+  <a href="screenshots/Audio.wav"><img src="screenshots/favicon.png" alt="Audio Result" width="100"></a>
+  <br>
+  <a href="screenshots/Audio.wav"><b>Listen to Generated Sample</b></a>
+</div>
+
+---
+
+<!-- QUICK START -->
+<a name="quick-start"></a>
+## Quick Start
+
+### 1. Prerequisites
+- **Python 3.9+**: Required for runtime execution. [Download Python](https://www.python.org/downloads/)
+- **Git**: For version control and cloning. [Download Git](https://git-scm.com/downloads)
+
+> [!WARNING]
+> ### Neural Model Acquisition
+>
+> The synthesis engine relies on pre-trained neural models. Ensure you have the weights (`encoder.pt`, `synthesizer.pt`, `vocoder.pt`) placed in the `Dataset/` directory. Failure to synchronize these assets will result in initialization errors.
+
+### 2. Installation & Setup
+
+#### Step 1: Clone the Repository
+Open your terminal and clone the repository:
+```bash
+git clone https://github.com/Amey-Thakur/DEEPFAKE-AUDIO.git
+cd DEEPFAKE-AUDIO
+```
+
+#### Step 2: Configure Virtual Environment
+Prepare an isolated environment to manage dependencies:
+
+**Windows (Command Prompt / PowerShell):**
+```bash
+python -m venv venv
+venv\Scripts\activate
+```
+
+**macOS / Linux (Terminal):**
+```bash
+python3 -m venv venv
+source venv/bin/activate
+```
+
+#### Step 3: Install Core Dependencies
+Ensure your environment is active, then install the required libraries:
+```bash
+pip install -r "Source Code/requirements.txt"
+```
+
+### 3. Execution
+
+#### A. Interactive Web Studio (PWA)
+Launch the primary Gradio-based studio engine:
+```bash
+python "Source Code/app.py"
+```
+> [!TIP]
+> **PWA Installation**: Once the studio is running, you can click the "Install" icon in your browser's address bar to add the **Deepfake Audio Studio** to your desktop as a standalone application.
+
+#### B. Research & Automation Script
+For automated synthesis or command-line research workflows:
+```bash
+# Example: Using a preset identity
+python DEEPFAKE-AUDIO.py --preset "Steve Jobs.wav" --text "Neural cloning active."
+
+# Example: Using a custom voice file
+python DEEPFAKE-AUDIO.py --input "my_voice.wav" --text "Synthesizing new speech."
+```
+
+---
+
+<!-- USAGE GUIDELINES -->
+<a name="usage-guidelines"></a>
+## Usage Guidelines
+
+This repository is openly shared to support learning and knowledge exchange across the academic community.
+
+**For Students**  
+Use this project as reference material for understanding **Neural Voice Synthesis**, **Transfer Learning (SV2TTS)**, and **real-time audio inference**. The source code is available for study to facilitate self-paced learning and exploration of **Python-based deep learning pipelines and PWA integration**.
+
+**For Educators**  
+This project may serve as a practical lab example or supplementary teaching resource for **Deep Learning**, **Acoustic Science**, and **Interactive System Architecture** courses. Attribution is appreciated when utilizing content.
+
+**For Researchers**  
+The documentation and architectural approach may provide insights into **academic project structuring**, **neural identity representation**, and **hybrid multi-stage synthesis pipelines**.
+
+---
+
+<!-- LICENSE -->
+<a name="license"></a>
+## License
+
+This repository and all its creative and technical assets are made available under the **MIT License**. See the [LICENSE](LICENSE) file for complete terms.
+
+> [!NOTE]
+> **Summary**: You are free to share and adapt this content for any purpose, even commercially, as long as you provide appropriate attribution to the original authors.
+
+Copyright © 2021 Amey Thakur & Mega Satish
+
+---
+
+<!-- ABOUT -->
+<a name="about-this-repository"></a>
+## About This Repository
+
+**Created & Maintained by**: [Amey Thakur](https://github.com/Amey-Thakur) & [Mega Satish](https://github.com/msatmod)
+
+This project features **Deepfake Audio**, a three-stage neural voice synthesis system. It represents a personal exploration into **Deep Learning**-based identity transfer and high-performance interactive application architecture via **Gradio**.
+
+**Connect:** [GitHub](https://github.com/Amey-Thakur) &nbsp;·&nbsp; [LinkedIn](https://www.linkedin.com/in/amey-thakur) &nbsp;·&nbsp; [ORCID](https://orcid.org/0000-0001-5644-1575)
+
+### Acknowledgments
+
+Grateful acknowledgment to [**Mega Satish**](https://github.com/msatmod) for her exceptional collaboration and scholarly partnership on this neural voice cloning research. Her constant support, technical clarity, and dedication to software quality were instrumental in achieving the system's functional objectives. Learning alongside her was a transformative experience; her thoughtful approach to problem-solving and steady encouragement turned complex requirements into meaningful learning moments. This work reflects the growth and insights gained from our side-by-side academic journey. Thank you, Mega, for everything you shared and taught along the way.
+
+Special thanks to [**Corentin Jemine**](https://github.com/CorentinJ) for the foundational research and open-source implementation of the **Real-Time-Voice-Cloning** repository, which served as the cornerstone for this project's technical architecture.
+
+---
+
+<div align="center">
+
+  [↑ Back to Top](#readme-top)
+
+  [Authors](#authors) &nbsp;·&nbsp; [Overview](#overview) &nbsp;·&nbsp; [Features](#features) &nbsp;·&nbsp; [Structure](#project-structure) &nbsp;·&nbsp; [Results](#results) &nbsp;·&nbsp; [Quick Start](#quick-start) &nbsp;·&nbsp; [Usage Guidelines](#usage-guidelines) &nbsp;·&nbsp; [License](#license) &nbsp;·&nbsp; [About](#about-this-repository) &nbsp;·&nbsp; [Acknowledgments](#acknowledgments)
+
+  <br>
+
+  🎙️ **[Deepfake Audio](https://huggingface.co/spaces/ameythakur/Deepfake-Audio)**
+
+  ---
+
+  ### 🎓 [Computer Engineering Repository](https://github.com/Amey-Thakur/COMPUTER-ENGINEERING)
+
+  **Computer Engineering (B.E.) - University of Mumbai**
+
+  *Semester-wise curriculum, laboratories, projects, and academic notes.*
+
+</div>

SECURITY.md

@@ -0,0 +1,41 @@
+# Security Policy
+
+## Maintenance Status
+
+This repository is part of a curated collection of academic and engineering projects and is maintained in a finalized and stable state. The project is preserved as a complete and authoritative record, with its scope and contents intentionally fixed to ensure long-term academic and professional reference.
+
+## Supported Versions
+
+As a finalized project, only the version listed below is authoritative:
+
+| Version | Supported |
+| ------- | --------- |
+| 1.0.0   | Yes       |
+
+## Vulnerability Reporting Protocol
+
+In accordance with established academic and professional standards for security disclosure, security-related observations associated with this project are documented through formal scholarly channels.
+
+To document a security concern, communication is facilitated with the project curators:
+  - **Curator**: [Amey Thakur](https://github.com/Amey-Thakur)
+  - **Collaborator**: [Mega Satish](https://github.com/msatmod)
+  - **Method**: Reports are submitted via the repository’s [GitHub Issues](https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/issues) interface to formally record security-related findings.
+
+Submissions include:
+  1. A precise and technically accurate description of the identified issue.
+  2. Demonstrable steps or technical evidence sufficient to contextualize the finding.
+  3. An explanation of the issue’s relevance within the defined scope of the project.
+
+## Implementation Context: Deep Learning Audio Synthesis
+
+This project consists of an advanced Deep Learning platform, utilizing Transfer Learning from Speaker Verification to Multispeaker Text-To-Speech Synthesis (SV2TTS) and Real-Time Vocoders for high-fidelity audio generation.
+
+-   **Scope Limitation**: This policy applies exclusively to the documentation, code, and model assets contained within this repository and does not extend to the runtime environment (Google Colab/Python) or third-party libraries.
+
+## Technical Integrity Statement
+
+This repository is preserved as a fixed academic and engineering project. Security-related submissions are recorded for documentation and contextual reference and do not imply active monitoring, response obligations, or subsequent modification of the repository.
+
+---
+
+*This document defines the security posture of a finalized Python project.*

Source Code/DEEPFAKE-AUDIO.ipynb

@@ -0,0 +1,923 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "metadata": {
+                "id": "view-in-github",
+                "colab_type": "text"
+            },
+            "source": [
+                "<a href=\"https://colab.research.google.com/github/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {
+                "id": "X7Om-e0ahXrB"
+            },
+            "source": [
+                "#\n",
+                "<h1 align=\"center\">\ud83c\udf99\ufe0f Deepfake Audio</h1>\n",
+                "<h3 align=\"center\"><i>A neural voice cloning studio powered by SV2TTS technology</i></h3>\n",
+                "\n",
+                "<div align=\"center\">\n",
+                "\n",
+                "| **Author** | **Profiles** |\n",
+                "|:---:|:---|\n",
+                "| **Amey Thakur** | [![GitHub](https://img.shields.io/badge/GitHub-Amey--Thakur-181717?logo=github)](https://github.com/Amey-Thakur) [![ORCID](https://img.shields.io/badge/ORCID-0000--0001--5644--1575-A6CE39?logo=orcid)](https://orcid.org/0000-0001-5644-1575) [![Google Scholar](https://img.shields.io/badge/Google_Scholar-Amey_Thakur-4285F4?logo=google-scholar&logoColor=white)](https://scholar.google.ca/citations?user=0inooPgAAAAJ&hl=en) [![Kaggle](https://img.shields.io/badge/Kaggle-Amey_Thakur-20BEFF?logo=kaggle)](https://www.kaggle.com/ameythakur20) |\n",
+                "| **Mega Satish** | [![GitHub](https://img.shields.io/badge/GitHub-msatmod-181717?logo=github)](https://github.com/msatmod) [![ORCID](https://img.shields.io/badge/ORCID-0000--0002--1844--9557-A6CE39?logo=orcid)](https://orcid.org/0000-0002-1844-9557) [![Google Scholar](https://img.shields.io/badge/Google_Scholar-Mega_Satish-4285F4?logo=google-scholar&logoColor=white)](https://scholar.google.ca/citations?user=7Ajrr6EAAAAJ&hl=en) [![Kaggle](https://img.shields.io/badge/Kaggle-Mega_Satish-20BEFF?logo=kaggle)](https://www.kaggle.com/megasatish) |\n",
+                "\n",
+                "---\n",
+                "\n",
+                "**Attribution:** This project builds upon the foundational work of [CorentinJ/Real-Time-Voice-Cloning](https://github.com/CorentinJ/Real-Time-Voice-Cloning).\n",
+                "\n",
+                "\ud83d\ude80 **Live Demo:** [Hugging Face Space](https://huggingface.co/spaces/ameythakur/Deepfake-Audio) | \ud83c\udfa5 **Video Demo:** [YouTube](https://youtu.be/i3wnBcbHDbs) | \ud83d\udcbb **Repository:** [GitHub](https://github.com/Amey-Thakur/DEEPFAKE-AUDIO)\n",
+                "\n",
+                "<a href=\"https://youtu.be/i3wnBcbHDbs\">\n",
+                "  <img src=\"https://img.youtube.com/vi/i3wnBcbHDbs/0.jpg\" alt=\"Video Demo\" width=\"60%\">\n",
+                "</a>\n",
+                "\n",
+                "</div>\n",
+                "\n",
+                "## \ud83d\udcd6 Introduction\n",
+                "\n",
+                "> **An audio deepfake is when a \u201ccloned\u201d voice that is potentially indistinguishable from the real person\u2019s is used to produce synthetic audio.**\n",
+                "\n",
+                "This research notebook demonstrates the **SV2TTS (Speaker Verification to Text-to-Speech)** framework, a three-stage deep learning pipeline capable of cloning a voice from a mere 5 seconds of audio.\n",
+                "\n",
+                "### The Pipeline\n",
+                "1.  **Speaker Encoder**: Creates a fixed-dimensional embedding (fingerprint) from the reference audio.\n",
+                "2.  **Synthesizer**: Generates a Mel Spectrogram from text, conditioned on the speaker embedding.\n",
+                "3.  **Vocoder**: Converts the Mel Spectrogram into a raw time-domain waveform (audible speech)."
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {
+                "id": "4kb73A1rhXrE"
+            },
+            "source": [
+                "## \u2601\ufe0f Cloud Environment Setup\n",
+                "Execute the following cell **only** if you are running this notebook in a cloud environment like **Google Colab** or **Kaggle**.\n",
+                "\n",
+                "This script will:\n",
+                "1.  **Clone the Repository**: Tries GitHub first, then falls back to **Personal Hugging Face Space** (`ameythakur/Deepfake-Audio`) if GitHub fails.\n",
+                "2.  **Environment Detection**: Automatically detects **Kaggle** vs **Colab**.\n",
+                "3.  **Data Retrieval**:\n",
+                "    *   **Kaggle**: Links directly from `/kaggle/input/deepfakeaudio` (No download needed).\n",
+                "    *   **Others**: Attempts Git LFS pull.\n",
+                "4.  **Fallback to Kagglehub**: If LFS budget exceeded, downloads from `ameythakur20/deepfakeaudio`.\n",
+                "5.  Install all required Python and System dependencies."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 1,
+            "metadata": {
+                "colab": {
+                    "base_uri": "https://localhost:8080/"
+                },
+                "id": "bDzcxXrzhXrE",
+                "outputId": "060d68bb-0b5c-43a8-f0fd-119d6335404e"
+            },
+            "outputs": [
+                {
+                    "output_type": "stream",
+                    "name": "stdout",
+                    "text": [
+                        "\ud83d\udcbb Detected Google Colab Environment. Initiating setup...\n",
+                        "\u2b07\ufe0f Cloning DEEPFAKE-AUDIO repository from MAIN (GitHub)...\n",
+                        "Cloning into 'DEEPFAKE-AUDIO'...\n",
+                        "remote: Enumerating objects: 682, done.\u001b[K\n",
+                        "remote: Counting objects: 100% (62/62), done.\u001b[K\n",
+                        "remote: Compressing objects: 100% (55/55), done.\u001b[K\n",
+                        "remote: Total 682 (delta 7), reused 7 (delta 7), pack-reused 620 (from 1)\u001b[K\n",
+                        "Receiving objects: 100% (682/682), 71.95 MiB | 12.37 MiB/s, done.\n",
+                        "Resolving deltas: 100% (328/328), done.\n",
+                        "Downloading Dataset/encoder.pt (17 MB)\n",
+                        "Error downloading object: Dataset/encoder.pt (39373b8): Smudge error: Error downloading Dataset/encoder.pt (39373b86598fa3da9fcddee6142382efe09777e8d37dc9c0561f41f0070f134e): batch response: This repository exceeded its LFS budget. The account responsible for the budget should increase it to restore access.\n",
+                        "\n",
+                        "Errors logged to /content/DEEPFAKE-AUDIO/.git/lfs/logs/20260129T113138.869344323.log\n",
+                        "Use `git lfs logs last` to view the log.\n",
+                        "error: external filter 'git-lfs filter-process' failed\n",
+                        "fatal: Dataset/encoder.pt: smudge filter lfs failed\n",
+                        "warning: Clone succeeded, but checkout failed.\n",
+                        "You can inspect what was checked out with 'git status'\n",
+                        "and retry with 'git restore --source=HEAD :/'\n",
+                        "\n",
+                        "\ud83d\udd27 Installing dependencies...\n",
+                        "Reading package lists... Done\n",
+                        "Building dependency tree... Done\n",
+                        "Reading state information... Done\n",
+                        "libsndfile1 is already the newest version (1.0.31-2ubuntu0.2).\n",
+                        "0 upgraded, 0 newly installed, 0 to remove and 41 not upgraded.\n",
+                        "\ud83d\udce6 Attempting Git LFS pull...\n",
+                        "Updated git hooks.\n",
+                        "Git LFS initialized.\n",
+                        "Error updating the git index:\n",
+                        "error: Source Code/encoder/__init__.py: cannot add to the index - missing --add option?\n",
+                        "fatal: Unable to process path Source Code/encoder/__init__.py\n",
+                        "\n",
+                        "\n",
+                        "Errors logged to /content/DEEPFAKE-AUDIO/.git/lfs/logs/20260129T113158.470476122.log\n",
+                        "Use `git lfs logs last` to view the log.\n",
+                        "batch response: This repository exceeded its LFS budget. The account responsible for the budget should increase it to restore access.\n",
+                        "error: failed to fetch some objects from 'https://github.com/Amey-Thakur/DEEPFAKE-AUDIO.git/info/lfs'\n",
+                        "\u26a0\ufe0f GitHub LFS Budget Exceeded or Pull Failed. Using Kaggle Fallback...\n",
+                        "Requirement already satisfied: kagglehub in /usr/local/lib/python3.12/dist-packages (0.3.13)\n",
+                        "Requirement already satisfied: packaging in /usr/local/lib/python3.12/dist-packages (from kagglehub) (25.0)\n",
+                        "Requirement already satisfied: pyyaml in /usr/local/lib/python3.12/dist-packages (from kagglehub) (6.0.3)\n",
+                        "Requirement already satisfied: requests in /usr/local/lib/python3.12/dist-packages (from kagglehub) (2.32.4)\n",
+                        "Requirement already satisfied: tqdm in /usr/local/lib/python3.12/dist-packages (from kagglehub) (4.67.1)\n",
+                        "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests->kagglehub) (3.4.4)\n",
+                        "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests->kagglehub) (3.11)\n",
+                        "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/dist-packages (from requests->kagglehub) (2.5.0)\n",
+                        "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.12/dist-packages (from requests->kagglehub) (2026.1.4)\n",
+                        "\ud83d\ude80 Downloading assets from Kagglehub (ameythakur20/deepfakeaudio)...\n",
+                        "Warning: Looks like you're using an outdated `kagglehub` version (installed: 0.3.13), please consider upgrading to the latest version (0.4.1).\n",
+                        "Downloading from https://www.kaggle.com/api/v1/datasets/download/ameythakur20/deepfakeaudio?dataset_version_number=5...\n"
+                    ]
+                },
+                {
+                    "output_type": "stream",
+                    "name": "stderr",
+                    "text": [
+                        "100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 550M/550M [00:25<00:00, 22.7MB/s]"
+                    ]
+                },
+                {
+                    "output_type": "stream",
+                    "name": "stdout",
+                    "text": [
+                        "Extracting files...\n"
+                    ]
+                },
+                {
+                    "output_type": "stream",
+                    "name": "stderr",
+                    "text": [
+                        "\n"
+                    ]
+                },
+                {
+                    "output_type": "stream",
+                    "name": "stdout",
+                    "text": [
+                        "\u2705 Samples linked from Kaggle.\n",
+                        "\u2705 Models linked from Kaggle.\n"
+                    ]
+                }
+            ],
+            "source": [
+                "import os\n",
+                "import sys\n",
+                "import shutil\n",
+                "\n",
+                "# Detect Cloud Environment (Colab/Kaggle)\n",
+                "try:\n",
+                "    shell = get_ipython()\n",
+                "    if 'google.colab' in str(shell):\n",
+                "        print(\"\ud83d\udcbb Detected Google Colab Environment. Initiating setup...\")\n",
+                "\n",
+                "        # 1. Clone the Repository (GitHub with HF Fallback)\n",
+                "        if not os.path.exists(\"DEEPFAKE-AUDIO\"):\n",
+                "            print(\"\u2b07\ufe0f Cloning DEEPFAKE-AUDIO repository from MAIN (GitHub)...\")\n",
+                "            clone_status = shell.system(\"git clone https://github.com/Amey-Thakur/DEEPFAKE-AUDIO\")\n",
+                "\n",
+                "            # Fallback to Hugging Face if GitHub clone failed (folder empty or not created)\n",
+                "            if not os.path.exists(\"DEEPFAKE-AUDIO\") or not os.listdir(\"DEEPFAKE-AUDIO\"):\n",
+                "                print(\"\u26a0\ufe0f GitHub Clone Failed. Attempting Fallback: Personal Hugging Face Space...\")\n",
+                "                if os.path.exists(\"DEEPFAKE-AUDIO\"): shutil.rmtree(\"DEEPFAKE-AUDIO\")\n",
+                "                shell.system(\"git clone https://huggingface.co/spaces/ameythakur/Deepfake-Audio DEEPFAKE-AUDIO\")\n",
+                "                print(\"\u2705 Cloned from Hugging Face Space.\")\n",
+                "\n",
+                "        os.chdir(\"/content/DEEPFAKE-AUDIO\")\n",
+                "\n",
+                "        # Install Dependencies (Colab)\n",
+                "        print(\"\ud83d\udd27 Installing dependencies...\")\n",
+                "        shell.system(\"apt-get install -y libsndfile1\")\n",
+                "        shell.system(\"pip install librosa==0.9.2 unidecode webrtcvad inflect umap-learn scikit-learn>=1.3 tqdm scipy 'matplotlib>=3.7,<3.9' Pillow>=10.2 soundfile huggingface_hub\")\n",
+                "\n",
+                "\n",
+                "\n",
+                "        # 2. Attempt Git LFS (Colab)\n",
+                "        print(\"\ud83d\udce6 Attempting Git LFS pull...\")\n",
+                "        shell.system(\"git lfs install\")\n",
+                "        lfs_status = shell.system(\"git lfs pull\")\n",
+                "\n",
+                "        # 3. Check for Fallback (If LFS failed or budget exceeded)\n",
+                "        sample_trigger = \"Dataset/samples/Steve Jobs.wav\"\n",
+                "        if lfs_status != 0 or not os.path.exists(sample_trigger) or os.path.getsize(sample_trigger) < 1000:\n",
+                "            print(\"\u26a0\ufe0f GitHub LFS Budget Exceeded or Pull Failed. Using Kaggle Fallback...\")\n",
+                "            shell.system(\"pip install kagglehub\")\n",
+                "            import kagglehub\n",
+                "            print(\"\ud83d\ude80 Downloading assets from Kagglehub (ameythakur20/deepfakeaudio)...\")\n",
+                "            k_path = kagglehub.dataset_download(\"ameythakur20/deepfakeaudio\")\n",
+                "\n",
+                "            # Link/Copy samples\n",
+                "            k_samples = os.path.join(k_path, \"samples\")\n",
+                "            if os.path.exists(k_samples):\n",
+                "                 if os.path.exists(\"Dataset/samples\"):\n",
+                "                      shutil.rmtree(\"Dataset/samples\")\n",
+                "                 os.makedirs(\"Dataset\", exist_ok=True)\n",
+                "                 os.symlink(k_samples, \"Dataset/samples\")\n",
+                "                 print(\"\u2705 Samples linked from Kaggle.\")\n",
+                "\n",
+                "            # Link/Copy models\n",
+                "            for model in [\"encoder.pt\", \"synthesizer.pt\", \"vocoder.pt\"]:\n",
+                "                 k_model = os.path.join(k_path, model)\n",
+                "                 if os.path.exists(k_model):\n",
+                "                      target = os.path.join(\"Dataset\", model)\n",
+                "                      if os.path.exists(target): os.remove(target)\n",
+                "                      os.symlink(k_model, target)\n",
+                "            print(\"\u2705 Models linked from Kaggle.\")\n",
+                "\n",
+                "    elif \"kaggle\" in os.environ.get(\"KAGGLE_KERNEL_RUN_TYPE\", \"\"):\n",
+                "        print(\"\ud83d\udcbb Detected Kaggle Environment. Initiating setup...\")\n",
+                "        os.chdir(\"/kaggle/working\")\n",
+                "\n",
+                "        # 1. Clone the Repository (GitHub with HF Fallback)\n",
+                "        if not os.path.exists(\"DEEPFAKE-AUDIO\"):\n",
+                "            print(\"\u2b07\ufe0f Cloning DEEPFAKE-AUDIO repository from MAIN (GitHub)...\")\n",
+                "            shell.system(\"git clone https://github.com/Amey-Thakur/DEEPFAKE-AUDIO\")\n",
+                "\n",
+                "            if not os.path.exists(\"DEEPFAKE-AUDIO\") or not os.listdir(\"DEEPFAKE-AUDIO\"):\n",
+                "                print(\"\u26a0\ufe0f GitHub Clone Failed. Attempting Fallback: Personal Hugging Face Space...\")\n",
+                "                if os.path.exists(\"DEEPFAKE-AUDIO\"): shutil.rmtree(\"DEEPFAKE-AUDIO\")\n",
+                "                shell.system(\"git clone https://huggingface.co/spaces/ameythakur/Deepfake-Audio DEEPFAKE-AUDIO\")\n",
+                "                print(\"\u2705 Cloned from Hugging Face Space.\")\n",
+                "\n",
+                "        os.chdir(\"/kaggle/working/DEEPFAKE-AUDIO\")\n",
+                "\n",
+                "        # 2. Priority: Link Kaggle Dataset (Skip LFS pull if dataset exists)\n",
+                "        kaggle_input = \"/kaggle/input/deepfakeaudio\"\n",
+                "        if os.path.exists(kaggle_input):\n",
+                "            print(f\"\u2705 Kaggle Dataset Detected at {kaggle_input}. Linking assets...\")\n",
+                "            # Link logic specific to Kaggle structure\n",
+                "            if os.path.exists(\"Dataset/samples\"):\n",
+                "                 shutil.rmtree(\"Dataset/samples\")\n",
+                "            if not os.path.exists(\"Dataset\"):\n",
+                "                 os.makedirs(\"Dataset\")\n",
+                "            # Attempt to symlink folder or copy items\n",
+                "            try:\n",
+                "                if os.path.exists(os.path.join(kaggle_input, \"samples\")):\n",
+                "                    os.symlink(os.path.join(kaggle_input, \"samples\"), \"Dataset/samples\")\n",
+                "                for model in [\"encoder.pt\", \"synthesizer.pt\", \"vocoder.pt\"]:\n",
+                "                    src = os.path.join(kaggle_input, model)\n",
+                "                    dst = os.path.join(\"Dataset\", model)\n",
+                "                    if os.path.exists(src):\n",
+                "                        if os.path.exists(dst): os.remove(dst)\n",
+                "                        os.symlink(src, dst)\n",
+                "            except Exception as e: print(f\"Warning during linking: {e}\")\n",
+                "            print(\"\u2705 Assets linked from Kaggle Input.\")\n",
+                "        else:\n",
+                "            print(\"\u26a0\ufe0f Kaggle Input not found. Attempting standard LFS pull...\")\n",
+                "            shell.system(\"git lfs install\")\n",
+                "            shell.system(\"git lfs pull\")\n",
+                "\n",
+                "        # Install Dependencies\n",
+                "        print(\"\ud83d\udd27 Installing dependencies...\")\n",
+                "        shell.system(\"apt-get install -y libsndfile1\")\n",
+                "        shell.system(\"pip install librosa==0.9.2 unidecode webrtcvad inflect umap-learn scikit-learn>=1.3 tqdm scipy 'matplotlib>=3.7,<3.9' Pillow>=10.2 soundfile huggingface_hub\")\n",
+                "\n",
+                "        # 2. Attempt Git LFS\n",
+                "        print(\"\ud83d\udce6 Attempting Git LFS pull...\")\n",
+                "        shell.system(\"git lfs install\")\n",
+                "        lfs_status = shell.system(\"git lfs pull\")\n",
+                "\n",
+                "        # 3. Check for Fallback (If LFS failed or budget exceeded)\n",
+                "        # Detection: If samples folder is empty or contains small pointer files\n",
+                "        sample_trigger = \"Dataset/samples/Steve Jobs.wav\"\n",
+                "        if lfs_status != 0 or not os.path.exists(sample_trigger) or os.path.getsize(sample_trigger) < 1000:\n",
+                "            print(\"\u26a0\ufe0f GitHub LFS Budget Exceeded or Pull Failed. Using Kaggle Fallback...\")\n",
+                "            shell.system(\"pip install kagglehub\")\n",
+                "            import kagglehub\n",
+                "\n",
+                "            # Pull from public Kaggle dataset\n",
+                "            print(\"\ud83d\ude80 Downloading assets from Kagglehub (ameythakur20/deepfakeaudio)...\")\n",
+                "            k_path = kagglehub.dataset_download(\"ameythakur20/deepfakeaudio\")\n",
+                "\n",
+                "            # Link/Copy samples\n",
+                "            k_samples = os.path.join(k_path, \"samples\")\n",
+                "            if os.path.exists(k_samples):\n",
+                "                 if os.path.exists(\"Dataset/samples\"):\n",
+                "                      shutil.rmtree(\"Dataset/samples\")\n",
+                "                 os.makedirs(\"Dataset\", exist_ok=True)\n",
+                "                 os.symlink(k_samples, \"Dataset/samples\")\n",
+                "                 print(\"\u2705 Samples linked from Kaggle.\")\n",
+                "\n",
+                "            # Link/Copy models\n",
+                "            for model in [\"encoder.pt\", \"synthesizer.pt\", \"vocoder.pt\"]:\n",
+                "                 k_model = os.path.join(k_path, model)\n",
+                "                 if os.path.exists(k_model):\n",
+                "                      target = os.path.join(\"Dataset\", model)\n",
+                "                      if os.path.exists(target): os.remove(target)\n",
+                "                      os.symlink(k_model, target)\n",
+                "            print(\"\u2705 Models linked from Kaggle.\")\n",
+                "\n",
+                "        # 4. Pull Latest Code Changes\n",
+                "        print(\"\ud83d\udd04 Synchronizing with remote repository...\")\n",
+                "        shell.system(\"git pull\")\n",
+                "\n",
+                "        # 5. Install System Dependencies\n",
+                "        print(\"\ud83d\udd27 Installing system dependencies (libsndfile1)...\")\n",
+                "        shell.system(\"apt-get install -y libsndfile1\")\n",
+                "\n",
+                "        # 6. Install Python Dependencies\n",
+                "        print(\"\ud83d\udce6 Installing Python libraries...\")\n",
+                "        shell.system(\"pip install librosa==0.9.2 unidecode webrtcvad inflect umap-learn scikit-learn>=1.3 tqdm scipy 'matplotlib>=3.7,<3.9' Pillow>=10.2 soundfile huggingface_hub\")\n",
+                "\n",
+                "        print(\"\u2705 Environment setup complete. Ready for cloning.\")\n",
+                "    else:\n",
+                "        print(\"\ud83c\udfe0 Running in local or custom environment. Skipping cloud setup.\")\n",
+                "except NameError:\n",
+                "    print(\"\ud83c\udfe0 Running in local or custom environment. Skipping cloud setup.\")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {
+                "id": "3sJUw_G8hXrG"
+            },
+            "source": [
+                "## 1\ufe0f\u20e3 Model & Data Initialization\n",
+                "\n",
+                "We prioritize data availability to ensure the notebook runs smoothly regardless of the platform. The system checks for checkpoints in this order:\n",
+                "\n",
+                "1.  **Repository Local** (`Dataset/` / `Source Code/`): Fast local access if cloned.\n",
+                "2.  **Kaggle Dataset** (`/kaggle/input/deepfakeaudio/`): Pre-loaded environment data.\n",
+                "    *   *Reference*: [Amey Thakur's Kaggle Dataset](https://www.kaggle.com/datasets/ameythakur20/deepfakeaudio)\n",
+                "3.  **Personal Backup** (Hugging Face Space): `ameythakur/Deepfake-Audio`.\n",
+                "    *   *Reference*: [Amey Thakur's HF Space](https://huggingface.co/spaces/ameythakur/Deepfake-Audio)\n",
+                "4.  **HuggingFace Auto-Download**: Robust fallback for fresh environments.\n",
+                "    *   *Reference*: [CorentinJ's SV2TTS Repository](https://huggingface.co/CorentinJ/SV2TTS)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 2,
+            "metadata": {
+                "colab": {
+                    "base_uri": "https://localhost:8080/"
+                },
+                "id": "bY79_5WrhXrH",
+                "outputId": "c1767603-817a-4f2c-8ce9-a09f2436bc5d"
+            },
+            "outputs": [
+                {
+                    "output_type": "stream",
+                    "name": "stdout",
+                    "text": [
+                        "\ud83d\udcc2 Working Directory: /content/DEEPFAKE-AUDIO\n",
+                        "\u2705 Module Path Registered: /content/DEEPFAKE-AUDIO/Source Code\n",
+                        "\u2b07\ufe0f Verifying Model Availability...\n",
+                        "\u2705 Found high-priority local models in 'Dataset/'. Verified.\n"
+                    ]
+                }
+            ],
+            "source": [
+                "import sys\n",
+                "import os\n",
+                "from pathlib import Path\n",
+                "import zipfile\n",
+                "import shutil\n",
+                "\n",
+                "# Determine if running in Google Colab\n",
+                "IS_COLAB = 'google.colab' in sys.modules\n",
+                "\n",
+                "# Register 'Source Code' to Python path for module imports\n",
+                "source_path = os.path.abspath(\"Source Code\")\n",
+                "if source_path not in sys.path:\n",
+                "    sys.path.append(source_path)\n",
+                "\n",
+                "print(f\"\ud83d\udcc2 Working Directory: {os.getcwd()}\")\n",
+                "print(f\"\u2705 Module Path Registered: {source_path}\")\n",
+                "\n",
+                "# Define paths for model checkpoints\n",
+                "extract_path = \"pretrained_models\"\n",
+                "\n",
+                "if not os.path.exists(extract_path):\n",
+                "    os.makedirs(extract_path)\n",
+                "\n",
+                "# --- \ud83e\udde0 Checkpoint Verification Strategy ---\n",
+                "print(\"\u2b07\ufe0f Verifying Model Availability...\")\n",
+                "\n",
+                "# Priority 1: Check Local Repository 'Dataset/' folder\n",
+                "core_models = [\"encoder.pt\", \"synthesizer.pt\", \"vocoder.pt\"]\n",
+                "\n",
+                "def is_valid_pt(p):\n",
+                "    \"\"\"Checks if a file exists and is not an LFS pointer (typically < 1KB).\"\"\"\n",
+                "    return os.path.exists(p) and os.path.getsize(p) > 1000\n",
+                "\n",
+                "dataset_models_present = all([is_valid_pt(os.path.join(\"Dataset\", m)) for m in core_models])\n",
+                "\n",
+                "if dataset_models_present:\n",
+                "    print(\"\u2705 Found high-priority local models in 'Dataset/'. Verified.\")\n",
+                "else:\n",
+                "    # Priority 2: Check Kaggle Dataset (Online Pre-loaded environment data)\n",
+                "    kaggle_path = \"/kaggle/input/deepfakeaudio\"\n",
+                "    kaggle_models_present = all([is_valid_pt(os.path.join(kaggle_path, m)) for m in core_models])\n",
+                "\n",
+                "    if kaggle_models_present:\n",
+                "        print(f\"\u2705 Found hardcoded Kaggle Dataset models at {kaggle_path}. Skipping download.\")\n",
+                "    else:\n",
+                "        print(\"\u26a0\ufe0f Models not found or are LFS pointers. Attempting fallback download...\")\n",
+                "\n",
+                "        # Priority 3: Personal Hugging Face Space (ameythakur/Deepfake-Audio)\n",
+                "        personal_hf_success = False\n",
+                "        try:\n",
+                "            print(\"\ud83d\ude80 Attempting download from Personal Hugging Face Space (ameythakur/Deepfake-Audio)...\")\n",
+                "            from huggingface_hub import hf_hub_download\n",
+                "            os.makedirs(\"pretrained_models\", exist_ok=True)\n",
+                "            for model in core_models:\n",
+                "                 try:\n",
+                "                     fpath = hf_hub_download(repo_id=\"ameythakur/Deepfake-Audio\", filename=f\"Dataset/{model}\", repo_type=\"space\", local_dir=\"pretrained_models\")\n",
+                "                 except:\n",
+                "                     fpath = hf_hub_download(repo_id=\"ameythakur/Deepfake-Audio\", filename=model, repo_type=\"space\", local_dir=\"pretrained_models\")\n",
+                "                 target = os.path.join(\"pretrained_models\", model)\n",
+                "                 if fpath != target and os.path.exists(fpath): shutil.move(fpath, target)\n",
+                "            if os.path.exists(os.path.join(\"pretrained_models\", \"Dataset\")): shutil.rmtree(os.path.join(\"pretrained_models\", \"Dataset\"))\n",
+                "            print(\"\u2705 Models successfully acquired via Personal Hugging Face fallback.\")\n",
+                "            personal_hf_success = True\n",
+                "        except Exception as e_hf:\n",
+                "            print(f\"\u26a0\ufe0f Personal HF Checkpoint failed: {e_hf}. Trying External Fallback...\")\n",
+                "\n",
+                "        # Priority 4 (Fallback): Auto-download from HuggingFace via utils script\n",
+                "        if not personal_hf_success:\n",
+                "            try:\n",
+                "                from utils.default_models import ensure_default_models\n",
+                "                ensure_default_models(Path(\"pretrained_models\"))\n",
+                "                print(\"\u2705 Models successfully acquired via External HuggingFace fallback.\")\n",
+                "            except Exception as e:\n",
+                "                print(f\"\u26a0\ufe0f Critical: Could not auto-download models. Error: {e}\")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {
+                "id": "ycvMxmYJhXrI"
+            },
+            "source": [
+                "## 2\ufe0f\u20e3 Architecture Loading\n",
+                "\n",
+                "We now initialize the three distinct neural networks that comprise the SV2TTS framework. Please ensure you are running on a **GPU Runtime** (e.g., T4 on Colab) for optimal performance."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 3,
+            "metadata": {
+                "colab": {
+                    "base_uri": "https://localhost:8080/"
+                },
+                "id": "yEShAzbfhXrI",
+                "outputId": "9d2ce872-19a3-4259-a10b-8afebb394b28"
+            },
+            "outputs": [
+                {
+                    "output_type": "stream",
+                    "name": "stdout",
+                    "text": [
+                        "\ud83c\udfaf Computation Device: cuda\n",
+                        "\u23f3 Loading Neural Networks (SV2TTS Pipeline)...\n",
+                        "\ud83d\udfe2 Loading Encoder from Repository: Dataset/encoder.pt\n",
+                        "Loaded encoder \"encoder.pt\" trained to step 1564501\n",
+                        "\ud83d\udfe2 Loading Synthesizer from Repository: Dataset/synthesizer.pt\n",
+                        "Synthesizer using device: cuda\n",
+                        "\ud83d\udfe2 Loading Vocoder from Repository: Dataset/vocoder.pt\n",
+                        "Building Wave-RNN\n",
+                        "Trainable Parameters: 4.481M\n",
+                        "Loading model weights at Dataset/vocoder.pt\n",
+                        "\u2705 Pipeline operational. All components loaded correctly.\n"
+                    ]
+                }
+            ],
+            "source": [
+                "from encoder import inference as encoder\n",
+                "from synthesizer.inference import Synthesizer\n",
+                "from vocoder import inference as vocoder\n",
+                "import numpy as np\n",
+                "import torch\n",
+                "from pathlib import Path\n",
+                "\n",
+                "# Hardware Acceleration Check\n",
+                "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+                "print(f\"\ud83c\udfaf Computation Device: {device}\")\n",
+                "\n",
+                "def resolve_checkpoint(component_name, legacy_path_suffix):\n",
+                "    \"\"\"\n",
+                "    Intelligently resolves the path to model checkpoints based on priority.\n",
+                "    1. Repository /Dataset/ folder.\n",
+                "    2. Kaggle Input directory (Hardcoded: /kaggle/input/deepfakeaudio/).\n",
+                "    3. Auto-downloaded 'pretrained_models'.\n",
+                "    \"\"\"\n",
+                "\n",
+                "    def is_valid(p):\n",
+                "        return p.exists() and p.stat().st_size > 1000\n",
+                "\n",
+                "    # 1. Repository Local (Dataset/)\n",
+                "    dataset_p = Path(\"Dataset\") / f\"{component_name.lower()}.pt\"\n",
+                "    if is_valid(dataset_p):\n",
+                "        print(f\"\ud83d\udfe2 Loading {component_name} from Repository: {dataset_p}\")\n",
+                "        return dataset_p\n",
+                "\n",
+                "    # 2. Kaggle Environment (Hardcoded Path: /kaggle/input/deepfakeaudio/)\n",
+                "    kaggle_p = Path(\"/kaggle/input/deepfakeaudio\") / f\"{component_name.lower()}.pt\"\n",
+                "    if is_valid(kaggle_p):\n",
+                "        print(f\"\ud83d\udfe2 Loading {component_name} from Kaggle: {kaggle_p}\")\n",
+                "        return kaggle_p\n",
+                "\n",
+                "    # 3. Default / Auto-Downloaded Fallback\n",
+                "    default_p = Path(\"pretrained_models/default\") / f\"{component_name.lower()}.pt\"\n",
+                "    if is_valid(default_p):\n",
+                "        print(f\"\ud83d\udfe2 Loading {component_name} from Fallback: {default_p}\")\n",
+                "        return default_p\n",
+                "\n",
+                "    # 4. Legacy/Manual Paths\n",
+                "    legacy_p = Path(\"pretrained_models\") / legacy_path_suffix\n",
+                "    if legacy_p.exists():\n",
+                "         if legacy_p.is_dir():\n",
+                "             pts = [f for f in legacy_p.glob(\"*.pt\") if is_valid(f)]\n",
+                "             if pts: return pts[0]\n",
+                "             pts_rec = [f for f in legacy_p.rglob(\"*.pt\") if is_valid(f)]\n",
+                "             if pts_rec: return pts_rec[0]\n",
+                "         elif is_valid(legacy_p):\n",
+                "             return legacy_p\n",
+                "\n",
+                "    print(f'\u26a0\ufe0f Warning: {component_name} checkpoint not found! Falling back to dynamic search...')\n",
+                "    return None\n",
+                "\n",
+                "print(\"\u23f3 Loading Neural Networks (SV2TTS Pipeline)...\")\n",
+                "\n",
+                "try:\n",
+                "    # 1. Encoder: Extract speaker embedding\n",
+                "    encoder_path = resolve_checkpoint(\"Encoder\", \"encoder/saved_models\")\n",
+                "    encoder.load_model(encoder_path)\n",
+                "\n",
+                "    # 2. Synthesizer: Generates spectrograms from text\n",
+                "    synth_path = resolve_checkpoint(\"Synthesizer\", \"synthesizer/saved_models/logs-pretrained/taco_pretrained\")\n",
+                "    synthesizer = Synthesizer(synth_path)\n",
+                "\n",
+                "    # 3. Vocoder: Converts spectrograms to audio waveforms\n",
+                "    vocoder_path = resolve_checkpoint(\"Vocoder\", \"vocoder/saved_models/pretrained\")\n",
+                "    vocoder.load_model(vocoder_path)\n",
+                "\n",
+                "    print(\"\u2705 Pipeline operational. All components loaded correctly.\")\n",
+                "except Exception as e:\n",
+                "    print(f\"\u274c Architecture Error: {e}\")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {
+                "id": "GjaGAUyVhXrJ"
+            },
+            "source": [
+                "## 3\ufe0f\u20e3 Inference Interface\n",
+                "\n",
+                "Select your **Input Method** below to begin cloning.\n",
+                "\n",
+                "*   **Presets**: Choose from a high-quality list of celebrity samples.\n",
+                "*   **Upload**: Use your own `.wav` or `.mp3` file (5-10 seconds recommended).\n",
+                "*   **Record**: Capture your voice directly in the browser (Colab only)."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 4,
+            "metadata": {
+                "colab": {
+                    "base_uri": "https://localhost:8080/",
+                    "height": 1000,
+                    "referenced_widgets": [
+                        "17941275da2c4712a8f7aeee24e985dc",
+                        "d35d66d0fc6f4956a22315288f75761e",
+                        "e5738978acde489493cc00b7580b41bf",
+                        "a1c213e8e9ed4e6a80611f91e37c16ee",
+                        "2a6b69d651c24930b892c0bb52e9d9e4",
+                        "39339f0b568c4d5084de7664d336ba50",
+                        "0923c7a8ae574c4fa2c9eb8c25076b95",
+                        "b0a46e803d84423cacb55e37ae6c043b",
+                        "bb70b9f36452494da95ee1033601218f",
+                        "f3008160ab52453d932a0cb62c711eee",
+                        "f035a503fafe48038036bdd50bd07b1c",
+                        "dac9a6ef6db347e08b2268c5e5654008",
+                        "779855519a5844d3bcc1ed69a8c44608",
+                        "05f5b43427fe47fbae468c4cec2be72c",
+                        "98051b53e539482aadf5d4b132dd3021",
+                        "3ed45fa49669481dbee831dfb2f6ebeb",
+                        "9d9b4954b5a74bf2b2f0fef974564bda",
+                        "3753f04d0dbb48a6a9a5c5589425ad91",
+                        "c294dc1d01e3421097eefe7eb2e5e377",
+                        "de81a54ce89a4aaeaba52f01c571b212",
+                        "7dbdc18b94a54cb6a492c7f33a661a56",
+                        "b9b8b1f96c3d4b89a9bc3e32d6076ad3",
+                        "91e19a809309432995d435aeba1e8bde",
+                        "c51b8d7f054b41039f354fce639d6947",
+                        "20d72122af6f449c90d53871c5a29b7d",
+                        "f73ef86eeaab452eb11e45f1e17464a8",
+                        "edf2d4f03fae4c5da75d0e3e1ad60382"
+                    ]
+                },
+                "id": "3wq8NsHohXrJ",
+                "outputId": "b92ea5cd-958b-4f83-9c48-1726f5f821a1"
+            },
+            "outputs": [
+                {
+                    "output_type": "stream",
+                    "name": "stdout",
+                    "text": [
+                        "Select Input Method:\n",
+                        "\u2705 Samples located at: /content/DEEPFAKE-AUDIO/Dataset/samples\n"
+                    ]
+                },
+                {
+                    "output_type": "display_data",
+                    "data": {
+                        "text/plain": [
+                            "Tab(children=(VBox(children=(Dropdown(description='Preset:', options=('Donald Trump.wav', 'Steve Jobs.wav', 'A\u2026"
+                        ],
+                        "application/vnd.jupyter.widget-view+json": {
+                            "version_major": 2,
+                            "version_minor": 0,
+                            "model_id": "17941275da2c4712a8f7aeee24e985dc"
+                        }
+                    },
+                    "metadata": {}
+                },
+                {
+                    "output_type": "display_data",
+                    "data": {
+                        "text/plain": [
+                            "Textarea(value=\"Hello, I'm Elon Musk. Welcome to Deepfake Audio by Amey Thakur and Mega Satish. Explore AI voi\u2026"
+                        ],
+                        "application/vnd.jupyter.widget-view+json": {
+                            "version_major": 2,
+                            "version_minor": 0,
+                            "model_id": "de81a54ce89a4aaeaba52f01c571b212"
+                        }
+                    },
+                    "metadata": {}
+                },
+                {
+                    "output_type": "display_data",
+                    "data": {
+                        "text/plain": [
+                            "Button(button_style='primary', description='Clone Voice! \ud83d\ude80', style=ButtonStyle())"
+                        ],
+                        "application/vnd.jupyter.widget-view+json": {
+                            "version_major": 2,
+                            "version_minor": 0,
+                            "model_id": "91e19a809309432995d435aeba1e8bde"
+                        }
+                    },
+                    "metadata": {}
+                },
+                {
+                    "output_type": "display_data",
+                    "data": {
+                        "text/plain": [
+                            "Output()"
+                        ],
+                        "application/vnd.jupyter.widget-view+json": {
+                            "version_major": 2,
+                            "version_minor": 0,
+                            "model_id": "f73ef86eeaab452eb11e45f1e17464a8"
+                        }
+                    },
+                    "metadata": {}
+                }
+            ],
+            "source": [
+                "import ipywidgets as widgets\n",
+                "from IPython.display import display, Javascript, Audio\n",
+                "try:\n",
+                "    from google.colab import output\n",
+                "    HAS_COLAB = True\n",
+                "except ImportError:\n",
+                "    HAS_COLAB = False\n",
+                "from base64 import b64decode\n",
+                "import io\n",
+                "import librosa\n",
+                "import librosa.display\n",
+                "import os\n",
+                "import soundfile as sf\n",
+                "import matplotlib.pyplot as plt\n",
+                "import numpy as np\n",
+                "import glob\n",
+                "\n",
+                "RECORD = \"\"\"\n",
+                "const sleep = time => new Promise(resolve => setTimeout(resolve, time))\n",
+                "const b2text = blob => new Promise(resolve => {\n",
+                "  const reader = new FileReader()\n",
+                "  reader.onloadend = e => resolve(e.srcElement.result)\n",
+                "  reader.readAsDataURL(blob)\n",
+                "})\n",
+                "var record = time => new Promise(async resolve => {\n",
+                "  stream = await navigator.mediaDevices.getUserMedia({ audio: true })\n",
+                "  recorder = new MediaRecorder(stream)\n",
+                "  chunks = []\n",
+                "  recorder.ondataavailable = e => chunks.push(e.data)\n",
+                "  recorder.start()\n",
+                "  await sleep(time)\n",
+                "  recorder.onstop = async ()=>{\n",
+                "    blob = new Blob(chunks)\n",
+                "    text = await b2text(blob)\n",
+                "    resolve(text)\n",
+                "  }\n",
+                "  recorder.stop()\n",
+                "})\"\"\"\n",
+                "\n",
+                "def record_audio(sec=10):\n",
+                "    if not HAS_COLAB:\n",
+                "        raise RuntimeError(\"Recording is only available in a Google Colab environment.\")\n",
+                "    print(\"\ud83d\udd34 Recording active for %d seconds...\" % sec)\n",
+                "    display(Javascript(RECORD))\n",
+                "    s = output.eval_js('record(%d)' % (sec*1000))\n",
+                "    print(\"\u2705 Recording saved.\")\n",
+                "    binary = b64decode(s.split(',')[1])\n",
+                "    with open('recording.wav', 'wb') as f:\n",
+                "        f.write(binary)\n",
+                "    return 'recording.wav'\n",
+                "\n",
+                "def visualize_results(original_wav, generated_wav, spec, embed, title=\"Analysis\"):\n",
+                "    try:\n",
+                "        fig, axes = plt.subplots(3, 1, figsize=(10, 12))\n",
+                "        axes[0].set_title(\"Input Voice vs. Cloned Voice (Waveform)\")\n",
+                "        try:\n",
+                "            librosa.display.waveshow(original_wav, alpha=0.5, ax=axes[0], label=\"Original\")\n",
+                "            librosa.display.waveshow(generated_wav, alpha=0.5, ax=axes[0], label=\"Cloned\", color='r')\n",
+                "            axes[0].legend()\n",
+                "        except:\n",
+                "            axes[0].plot(original_wav, alpha=0.5, label=\"Original\")\n",
+                "            axes[0].plot(generated_wav, alpha=0.5, label=\"Cloned\", color='r')\n",
+                "            axes[0].legend()\n",
+                "\n",
+                "        axes[1].set_title(\"Generated Mel Spectrogram\")\n",
+                "        im = axes[1].imshow(spec, aspect=\"auto\", origin=\"lower\", interpolation='none')\n",
+                "        fig.colorbar(im, ax=axes[1])\n",
+                "\n",
+                "        axes[2].set_title(\"Speaker Embedding (256-D Heatmap)\")\n",
+                "        if len(embed) == 256:\n",
+                "            axes[2].imshow(embed.reshape(16, 16), aspect='auto', cmap='viridis')\n",
+                "        else:\n",
+                "            axes[2].plot(embed)\n",
+                "\n",
+                "        plt.tight_layout()\n",
+                "        plt.show()\n",
+                "    except Exception as e:\n",
+                "        print(f\"\u26a0\ufe0f Graphs partially failed: {e}. Audio was successful.\")\n",
+                "\n",
+                "# --- \ud83d\udee1\ufe0f IMPROVED SAMPLE DISCOVERY ---\n",
+                "def find_samples_dir():\n",
+                "    \"\"\"Locates reference samples with high persistence across all environments.\"\"\"\n",
+                "    # Priority paths\n",
+                "    priority_roots = [\n",
+                "        \"Source Code/samples\",\n",
+                "        \"Dataset/samples\",\n",
+                "        \"D:/GitHub/DEEPFAKE-AUDIO/Source Code/samples\",\n",
+                "        \"D:/GitHub/DEEPFAKE-AUDIO/Dataset/samples\",\n",
+                "        \"/content/DEEPFAKE-AUDIO/Source Code/samples\",\n",
+                "        \"/kaggle/input/deepfakeaudio/samples\",\n",
+                "        \"/kaggle/input/deepfakeaudio\"\n",
+                "    ]\n",
+                "\n",
+                "    def filter_real_audio(d):\n",
+                "        if not os.path.exists(d): return []\n",
+                "        # Check if files are real audio (not small LFS pointers < 1KB)\n",
+                "        return [f for f in os.listdir(d) if f.lower().endswith((\".wav\", \".mp3\")) and os.path.getsize(os.path.join(d, f)) > 1024]\n",
+                "\n",
+                "    for d in priority_roots:\n",
+                "        files = filter_real_audio(d)\n",
+                "        if files:\n",
+                "            print(f\"\u2705 Samples located at: {os.path.abspath(d)}\")\n",
+                "            return d, files\n",
+                "\n",
+                "    # More aggressive glob search\n",
+                "    print(\"\ud83d\udd0d Searching folders for audio samples...\")\n",
+                "    potential_matches = glob.glob(\"**/samples/*.wav\", recursive=True) + glob.glob(\"**/samples/*.mp3\", recursive=True)\n",
+                "    valid_matches = [m for m in potential_matches if os.path.getsize(m) > 1024]\n",
+                "\n",
+                "    if valid_matches:\n",
+                "        root = os.path.dirname(valid_matches[0])\n",
+                "        files = [os.path.basename(f) for f in glob.glob(os.path.join(root, \"*.*\")) if f.lower().endswith((\".wav\", \".mp3\")) and os.path.getsize(f) > 1024]\n",
+                "        print(f\"\u2728 Located samples via glob at: {os.path.abspath(root)}\")\n",
+                "        return root, files\n",
+                "\n",
+                "    return None, []\n",
+                "\n",
+                "print(\"Select Input Method:\")\n",
+                "tab = widgets.Tab()\n",
+                "\n",
+                "samples_dir, preset_files = find_samples_dir()\n",
+                "if samples_dir:\n",
+                "    preset_files.sort()\n",
+                "    for name in reversed([\"Donald Trump.wav\", \"Steve Jobs.wav\"]):\n",
+                "        if name in preset_files:\n",
+                "            preset_files.insert(0, preset_files.pop(preset_files.index(name)))\n",
+                "else:\n",
+                "    print(\"\u26a0\ufe0f Warning: No reference samples found. Please run the setup cell or upload manually.\")\n",
+                "\n",
+                "dropdown = widgets.Dropdown(options=preset_files,\n",
+                "                            value=preset_files[0] if preset_files else None,\n",
+                "                            description='Preset:')\n",
+                "uploader = widgets.FileUpload(accept='.wav,.mp3', multiple=False)\n",
+                "record_btn = widgets.Button(description=\"Start Recording (10s)\", button_style='danger')\n",
+                "record_out = widgets.Output()\n",
+                "\n",
+                "def on_record_click(b):\n",
+                "    with record_out:\n",
+                "        record_btn.disabled = True\n",
+                "        try: record_audio(10)\n",
+                "        except Exception as e: print(f\"Error: {e}.\")\n",
+                "        record_btn.disabled = False\n",
+                "record_btn.on_click(on_record_click)\n",
+                "\n",
+                "# Tab assignment MUST use .children attribute\n",
+                "tab.children = [\n",
+                "    widgets.VBox([dropdown]),\n",
+                "    widgets.VBox([uploader]),\n",
+                "    widgets.VBox([record_btn, record_out])\n",
+                "]\n",
+                "tab.set_title(0, '\ud83c\udfb5 Presets')\n",
+                "tab.set_title(1, '\ud83d\udcc2 Upload')\n",
+                "tab.set_title(2, '\ud83d\udd34 Record')\n",
+                "display(tab)\n",
+                "\n",
+                "text_input = widgets.Textarea(\n",
+                "    value=\"Hello, I'm Elon Musk. Welcome to Deepfake Audio by Amey Thakur and Mega Satish. Explore AI voice Go!\",\n",
+                "    placeholder='Enter text to synthesize...',\n",
+                "    description='Text:',\n",
+                "    layout=widgets.Layout(width='50%', height='100px')\n",
+                ")\n",
+                "clone_btn = widgets.Button(description=\"Clone Voice! \ud83d\ude80\", button_style='primary')\n",
+                "out = widgets.Output()\n",
+                "display(text_input, clone_btn, out)\n",
+                "\n",
+                "def run_cloning(b):\n",
+                "    with out:\n",
+                "        out.clear_output()\n",
+                "        active_tab = tab.selected_index\n",
+                "        input_path = None\n",
+                "        try:\n",
+                "            if active_tab == 0:\n",
+                "                 if not dropdown.value: return print(\"\u274c No preset selected.\")\n",
+                "                 input_path = os.path.join(samples_dir, dropdown.value)\n",
+                "                 print(f\"\ud83c\udf99\ufe0f Source: Preset ({dropdown.value})\")\n",
+                "            elif active_tab == 1:\n",
+                "                 if not uploader.value: return print(\"\u274c No file uploaded.\")\n",
+                "                 fname = list(uploader.value.keys())[0]\n",
+                "                 content = uploader.value[fname]['content']\n",
+                "                 input_path = \"uploaded_sample.wav\"\n",
+                "                 with open(input_path, \"wb\") as f: f.write(content)\n",
+                "                 print(f\"\ud83c\udf99\ufe0f Source: Upload ({fname})\")\n",
+                "            elif active_tab == 2:\n",
+                "                 if not os.path.exists(\"recording.wav\"): return print(\"\u274c No recording found.\")\n",
+                "                 input_path = \"recording.wav\"\n",
+                "                 print(\"\ud83c\udf99\ufe0f Source: Microphone\")\n",
+                "\n",
+                "            print(\"\u23f3 Step 1/3: Encoding speaker identity...\")\n",
+                "            original_wav, sampling_rate = librosa.load(input_path)\n",
+                "            preprocessed_wav = encoder.preprocess_wav(original_wav, sampling_rate)\n",
+                "            embed = encoder.embed_utterance(preprocessed_wav)\n",
+                "            print(\"\u23f3 Step 2/3: Synthesizing speech...\")\n",
+                "            specs = synthesizer.synthesize_spectrograms([text_input.value], [embed])\n",
+                "            spec = specs[0]\n",
+                "            print(\"\u23f3 Step 3/3: Generating waveform...\")\n",
+                "            generated_wav = vocoder.infer_waveform(spec)\n",
+                "            print(\"\ud83c\udf89 Synthesis Complete!\")\n",
+                "            display(Audio(generated_wav, rate=synthesizer.sample_rate))\n",
+                "            print(\"\\n\ud83d\udcca Generating Analysis...\")\n",
+                "            visualize_results(original_wav, generated_wav, spec, embed)\n",
+                "        except Exception as e: print(f\"\u274c Error: {e}\")\n",
+                "clone_btn.on_click(run_cloning)"
+            ]
+        }
+    ],
+    "metadata": {
+        "kernelspec": {
+            "display_name": "Python 3",
+            "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.10.12"
+        },
+        "colab": {
+            "provenance": [],
+            "gpuType": "T4",
+            "include_colab_link": true
+        },
+        "accelerator": "GPU"
+    },
+    "nbformat": 4,
+    "nbformat_minor": 0
+}

Source Code/Dockerfile

@@ -0,0 +1,31 @@
+# Use Python 3.11-slim as base
+FROM python:3.11-slim
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libsndfile1 \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+# Adding gradio explicitly since it was missing from requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt gradio
+
+# Copy the rest of the application code
+COPY . .
+
+# Expose Gradio port
+EXPOSE 7860
+
+# Command to run the application
+CMD ["python", "app.py"]

Source Code/app.py

@@ -0,0 +1,907 @@
+# ==================================================================================================
+# DEEPFAKE AUDIO - app.py (The Studio Interface)
+# ==================================================================================================
+# 
+# 📝 DESCRIPTION
+# This is the primary entry point for the Deepfake Audio Studio. It implements a modern,
+# high-performance Gradio-based web interface designed to facilitate zero-shot voice cloning
+# using the SV2TTS (Speaker Verification to Transfer Learning) framework.
+# 
+# The application is architected for "Graceful Degradation": if AI models or hardware-level 
+# dependencies (like TensorFlow/CUDA) are unavailable, it falls back to a "UI-Only Demo Mode" 
+# to preserve the accessibility of the research documentation.
+#
+# 👤 AUTHORS
+# - Amey Thakur (https://github.com/Amey-Thakur)
+# - Mega Satish (https://github.com/msatmod)
+#
+# 🤝🏻 CREDITS
+# Original Real-Time Voice Cloning methodology by CorentinJ
+# Repository: https://github.com/CorentinJ/Real-Time-Voice-Cloning
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Demo: https://huggingface.co/spaces/ameythakur/Deepfake-Audio
+# Research: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================
+
+import os
+import sys
+from pathlib import Path
+
+# --- SYSTEM INITIALIZATION ---
+# We configure the environment variables early to suppress verbose C++ logs from TensorFlow,
+# ensuring a clean terminal output focus on the application state.
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+os.environ['PYTHONWARNINGS'] = 'ignore'
+
+import warnings
+warnings.filterwarnings('ignore')
+
+import logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# --- ARCHITECTURAL DIRECTORIES ---
+# Establish absolute paths to ensure the application resolves assets correctly regardless of 
+# the execution context (Source Code vs Docker vs Cloud).
+PROJ_DIR = Path(__file__).parent.absolute()
+ROOT_DIR = PROJ_DIR.parent
+DATASET_DIR = ROOT_DIR / "Dataset"
+SAMPLES_DIR = DATASET_DIR / "samples"
+
+# Inject current directory into sys.path to allow internal module resolution for encoder/synthesizer.
+if str(PROJ_DIR) not in sys.path:
+    sys.path.insert(0, str(PROJ_DIR))
+
+import numpy as np
+import gradio as gr
+import base64
+
+# --- AI ENGINE DEPENDENCIES ---
+# The application attempts to load the multi-stage neural pipeline.
+# Stage 1: Encoder (Speaker Verification)
+# Stage 2: Synthesizer (Tacotron 2)
+# Stage 3: Vocoder (WaveRNN)
+TF_AVAILABLE = False
+MODELS_READY = False
+STARTUP_ERROR = ""
+synthesizer = None
+
+try:
+    import librosa
+    LIBROSA_AVAILABLE = True
+except ImportError:
+    LIBROSA_AVAILABLE = False
+    logger.warning("librosa not available - audio loading will fail.")
+
+try:
+    # TensorFlow 2.x requires eager execution to be disabled for legacy SV2TTS support elements.
+    import tensorflow as tf
+    tf.compat.v1.disable_eager_execution()
+    tf.get_logger().setLevel('ERROR')
+    TF_AVAILABLE = True
+except Exception as e:
+    logger.warning(f"TensorFlow unavailable (possibly blocked by policy): {e}")
+    TF_AVAILABLE = False
+
+try:
+    # Import the cloned submodules. They must exist in the PROJ_DIR.
+    import encoder.inference
+    import encoder.audio
+    from synthesizer.inference import Synthesizer
+    from vocoder import inference as vocoder
+    AI_MODULES_AVAILABLE = True
+except ImportError as e:
+    logger.warning(f"AI modules not available: {e}")
+    AI_MODULES_AVAILABLE = False
+
+# --- Model Paths (Updated to 'Dataset' directory) ---
+ENC_MODEL = DATASET_DIR / "encoder.pt"
+SYN_MODEL = DATASET_DIR / "synthesizer.pt"
+VOC_MODEL = DATASET_DIR / "vocoder.pt"
+
+# --- Sample Loading (Dynamic Discovery from Dataset/samples) ---
+SAMPLES = {}
+if SAMPLES_DIR.exists():
+    for f in SAMPLES_DIR.glob("*.wav"):
+        # Use filename as key directly (e.g., "Barack Obama")
+        name = f.stem
+        # If user still uses old _preset convention, clean it up just in case
+        if "_preset" in name:
+            name = name.replace("_preset", "").replace("_", " ").title()
+        SAMPLES[name] = str(f)
+
+def load_preset(name):
+    if name in SAMPLES:
+        logger.info(f"Loading preset: {name}")
+        return SAMPLES[name]
+    return None
+
+# --- Model Loading (If Available) ---
+if TF_AVAILABLE and AI_MODULES_AVAILABLE:
+    def load_models():
+        try:
+            if not encoder.inference.is_loaded():
+                encoder.inference.load_model(ENC_MODEL)
+            synth = Synthesizer(SYN_MODEL)
+            vocoder.load_model(VOC_MODEL)
+            return synth
+        except Exception as e:
+            logger.error(f"Load error: {e}")
+            raise e
+
+    try:
+        # Check if files exist before trying to load
+        if not ENC_MODEL.exists() or not SYN_MODEL.exists() or not VOC_MODEL.exists():
+             raise FileNotFoundError(f"Models missing in {DATASET_DIR}")
+             
+        synthesizer = load_models()
+        MODELS_READY = True
+        logger.info("✅ All AI models loaded successfully!")
+    except Exception as e:
+        MODELS_READY = False
+        STARTUP_ERROR = str(e)
+        logger.warning(f"Models not loaded: {e}")
+else:
+    STARTUP_ERROR = "TensorFlow blocked by system policy" if not TF_AVAILABLE else "AI modules not found"
+    logger.warning(f"Running in UI-only mode: {STARTUP_ERROR}")
+
+# --- Synthesis Logic ---
+def synthesize(audio_file, text, progress=gr.Progress()):
+    logger.info(f"Synthesize called with audio_file: {audio_file}, text: '{text}'")
+    
+    if text is None: text = ""
+    text = str(text).strip()
+    
+    if not MODELS_READY:
+        return None, f"⚠️ Demo Mode: {STARTUP_ERROR}"
+    if not audio_file or not text:
+        logger.warning(f"Validation failed. Audio: {bool(audio_file)}, Text: {bool(text)}")
+        return None, "Reference audio and text script are required."
+
+    try:
+        progress(0.2, desc="Extracting Voice Identity")
+        original_wav, sampling_rate = librosa.load(audio_file, sr=None)
+        preprocessed_wav = encoder.audio.preprocess_wav(original_wav, sampling_rate)
+        embed = encoder.inference.embed_utterance(preprocessed_wav)
+        
+        progress(0.5, desc="Synthesizing Speech")
+        specs = synthesizer.synthesize_spectrograms([text], [embed])
+        
+        progress(0.8, desc="Generating High-Fidelity Audio")
+        # Ensure we handle batching correctly
+        generated_wav = vocoder.infer_waveform(specs[0], batched=True, target=11000, overlap=1100)
+        
+        # progress(0.85, desc="Removing Vocoder Noise")
+        # generated_wav = vocoder.infer_denoised(generated_wav)
+        
+        progress(0.9, desc="Refining Audio Quality")
+        generated_wav = encoder.inference.preprocess_wav(generated_wav)
+        
+        if np.abs(generated_wav).max() > 0:
+            generated_wav = generated_wav / np.abs(generated_wav).max() * 0.98
+            
+        generated_wav = np.pad(generated_wav, (0, synthesizer.sample_rate), mode="constant")
+        
+        progress(1.0, desc="Finalizing")
+        return (synthesizer.sample_rate, generated_wav), "✅ Synthesis Complete."
+    except Exception as e:
+        logger.exception("Synthesis failed")
+        return None, f"Error: {str(e)}"
+
+def play_intro():
+    intro_path = PROJ_DIR / "intro_message.wav"
+    logger.info(f"Intro button clicked. Searching for: {intro_path}")
+    if intro_path.exists():
+        logger.info("Intro file found. Returning path.")
+        return str(intro_path)
+    logger.warning("Intro file NOT found.")
+    return None
+
+# --- NEON MIC ICON (RUNTIME BASE64) ---
+try:
+    with open(PROJ_DIR / "favicon.png", "rb") as f:
+        encoded_icon = base64.b64encode(f.read()).decode('utf-8')
+        NEON_MIC_ICON = f"data:image/png;base64,{encoded_icon}"
+except Exception as e:
+    print(f"Warning: Could not encode favicon: {e}")
+    NEON_MIC_ICON = "/file=favicon.png"
+
+# --- Minimalist Navy & Orange UI ---
+custom_css = """
+/* General Styles */
+@import url('https://fonts.googleapis.com/css2?family=Play:wght@400;700&display=swap');
+
+* {
+    font-family: 'Play', sans-serif !important;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+}
+
+/* Allow selection in inputs */
+input, textarea, .gr-box, .gr-input, .gr-text-input {
+    -webkit-user-select: text !important;
+    -moz-user-select: text !important;
+    -ms-user-select: text !important;
+    user-select: text !important;
+    cursor: text !important;
+}
+
+body {
+    background-color: #0a192f !important;
+    color: #ccd6f6 !important;
+    overflow-x: hidden;
+}
+
+.gradio-container {
+    background-color: transparent !important;
+    position: relative !important;
+    z-index: 1 !important;
+}
+
+/* Pseudo-element for the pattern to control opacity properly without affecting text */
+body::before {
+    content: "";
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-image: url('FAVICON_PLACEHOLDER') !important;
+    background-repeat: repeat !important;
+    background-size: 60px !important;
+    opacity: 0.05 !important; /* Dimmed to 5% - Perfect watermark */
+    pointer-events: none;
+    z-index: 0;
+}
+""".replace("FAVICON_PLACEHOLDER", NEON_MIC_ICON) + """
+.main-container { 
+    max-width: 950px !important; 
+    margin: 0 auto !important; 
+    padding: 20px !important;
+}
+#header h1 { 
+    font-size: 2.2rem; 
+    color: #ff8c00; 
+    margin-bottom: 0px; 
+    letter-spacing: -1px;
+}
+#header p { font-size: 0.9rem; color: #8892b0; margin-top: 5px; }
+
+#intro-btn {
+    background: transparent !important;
+    border: none !important;
+    font-size: 2.2rem !important;
+    color: #ff8c00 !important;
+    font-weight: 800 !important;
+    cursor: pointer !important;
+    box-shadow: none !important;
+    padding: 0 !important;
+    margin: 0 !important;
+    transition: all 0.3s ease !important;
+}
+
+#intro-btn:hover { 
+    color: #ccd6f6 !important;
+    transform: scale(1.02);
+}
+
+#intro-audio { display: none !important; }
+
+.studio-card {
+    background: #112240 !important;
+    border: 1px solid #233554 !important;
+    border-radius: 12px !important;
+    padding: 10px !important;
+    box-shadow: 0 10px 30px -15px rgba(2, 12, 27, 0.7) !important;
+    margin-bottom: 6px !important;
+    transition: transform 0.2s ease, border-color 0.2s ease !important;
+    min-height: 180px !important;
+    display: flex !important;
+    flex-direction: column !important;
+    overflow: visible !important;
+}
+
+.studio-card .prose {
+    margin-bottom: 5px !important;
+}
+
+/* Force Play Font on everything */
+* { font-family: 'Play', sans-serif !important; }
+span, button, input, label, textarea, select { font-family: 'Play', sans-serif !important; }
+
+.studio-card:hover { 
+    transform: translateY(-2px); 
+    border-color: #ff8c00 !important; 
+}
+
+/* --- PRO CODE DEFINITIVE "ZERO-BLEED" FIX --- */
+
+/* 1. FLATTEN THE WRAPPERS: Make specific outer containers invisible */
+#script-box, #status-box, 
+#script-box > .form, #status-box > .form,
+.gray-border, .form {
+    background-color: transparent !important;
+    background: transparent !important;
+    border: none !important;
+    box-shadow: none !important;
+    padding: 0 !important;
+}
+
+/* 2. STYLE THE INNER INPUTS: Apply the theme ONLY to the interactive element */
+#script-box textarea, #status-box input, 
+#preset-dropdown-container .gr-dropdown {
+    background-color: #112240 !important; /* Perfect Match to Studio Card */
+    border: 2px solid #ff8c00 !important;
+    border-radius: 12px !important;
+    color: #ccd6f6 !important;
+    box-shadow: none !important;
+}
+
+/* Remove placeholder color interference */
+#script-box textarea::placeholder { color: #555 !important; }
+
+/* Focus States */
+#script-box textarea:focus, #status-box input:focus {
+    border-color: #ffb347 !important;
+    box-shadow: 0 0 15px rgba(255, 140, 0, 0.4) !important;
+}
+
+/* --- PRO CODE "VOICE DECK" (SCROLLABLE LIST) --- */
+
+/* The Voice Deck Container */
+#voice-deck {
+    max-height: 70px !important;
+    overflow-y: auto !important;
+    background-color: #0d1b2a !important; /* Slightly darker than card for depth */
+    border: 2px solid #ff8c00 !important;
+    border-radius: 12px !important;
+    padding: 8px !important;
+    margin-bottom: 10px !important;
+    scrollbar-width: thin !important;
+    scrollbar-color: #ff8c00 #0a192f !important;
+}
+
+/* Radio Item Styling (Premium Chips) */
+#voice-deck label {
+    display: flex !important;
+    align-items: center !important;
+    width: 100% !important;
+    background: transparent !important;
+    border: 1px solid #233554 !important;
+    border-radius: 8px !important;
+    margin-bottom: 4px !important;
+    padding: 8px 12px !important;
+    transition: all 0.2s ease !important;
+    cursor: pointer !important;
+    color: #8892b0 !important;
+}
+
+#voice-deck label:hover {
+    background: #112240 !important;
+    border-color: #ff8c00 !important;
+    color: #ff8c00 !important;
+}
+
+#voice-deck label.selected, #voice-deck input:checked + span {
+    background: #233554 !important;
+    border-color: #ff8c00 !important;
+    color: #ff8c00 !important;
+    font-weight: bold !important;
+    box-shadow: 0 0 10px rgba(255, 140, 0, 0.2) !important;
+}
+
+/* Hide the default radio circle */
+#voice-deck input[type="radio"] {
+    display: none !important;
+}
+
+/* Ensure text is nicely aligned */
+#voice-deck span {
+    margin-left: 0 !important;
+    font-size: 0.95rem !important;
+}
+
+/* Audio Input Transparency Fix */
+#audio-input, #audio-input .gr-input, #audio-input .gr-box, #audio-input .gr-block {
+    background: transparent !important;
+    background-color: transparent !important;
+    border: none !important;
+    box-shadow: none !important;
+}
+
+
+div[role="option"] {
+    padding: 10px !important;
+    color: #ccd6f6 !important;
+    border-bottom: 1px solid #233554 !important;
+}
+
+div[role="option"]:hover, div[role="option"][aria-selected="true"] {
+    background-color: #233554 !important;
+    color: #ff8c00 !important;
+}
+
+div[role="listbox"]::-webkit-scrollbar {
+    width: 6px !important;
+}
+
+div[role="listbox"]::-webkit-scrollbar-track {
+    background: #0a192f !important;
+    border-radius: 10px !important;
+}
+
+div[role="listbox"]::-webkit-scrollbar-thumb {
+    background: #ff8c00 !important;
+    border-radius: 10px !important;
+    border: 1px solid #0a192f !important;
+}
+
+div[role="listbox"]::-webkit-scrollbar-thumb:hover {
+    background: #ffa500 !important;
+}
+
+/* --- PREMIUM SCROLLBARS --- */
+/* Global Scrollbar Styling */
+::-webkit-scrollbar {
+    width: 6px !important;
+    height: 6px !important;
+}
+
+::-webkit-scrollbar-track {
+    background: #0a192f !important;
+}
+
+::-webkit-scrollbar-thumb {
+    background: #ff8c00 !important;
+    border-radius: 20px !important;
+    border: 1px solid #0a192f !important;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: #ffa500 !important;
+    box-shadow: 0 0 10px rgba(255, 140, 0, 0.5) !important;
+}
+
+/* Ensure Audio Player Scrollbars match */
+audio::-webkit-scrollbar {
+    height: 6px !important;
+}
+
+div[role="option"] {
+    background-color: transparent !important;
+    color: #ccd6f6 !important;
+}
+
+div[role="option"]:hover, div[role="option"][aria-selected="true"] {
+    background-color: #233554 !important;
+    color: #ff8c00 !important;
+}
+
+.btn-primary {
+    background: #ff8c00 !important;
+    border: 2px solid #ff8c00 !important;
+    color: #0a192f !important;
+    font-weight: 800 !important;
+    border-radius: 8px !important;
+    padding: 0 20px !important;
+    height: 50px !important;
+    cursor: pointer !important;
+    transition: all 0.3s ease !important;
+    width: 100% !important;
+}
+
+.btn-primary:hover {
+    background: transparent !important;
+    color: #ff8c00 !important;
+    border-color: #ff8c00 !important;
+}
+
+.btn-secondary {
+    background: transparent !important;
+    border: 1px solid #233554 !important;
+    color: #8892b0 !important;
+    border-radius: 8px !important;
+    height: 50px !important;
+    padding: 0 20px !important;
+    transition: all 0.3s ease !important;
+    width: 100% !important;
+}
+
+.btn-secondary:hover {
+    background: #ff8c00 !important;
+    color: #0a192f !important;
+    border-color: #ff8c00 !important;
+}
+
+.info-section {
+    font-size: 0.85rem;
+    color: #8892b0;
+    margin-top: 20px;
+    padding: 0 15px;
+    animation: fadeIn 0.8s ease-out;
+}
+
+.info-header {
+    color: #ff8c00 !important;
+    font-weight: 800 !important;
+    margin-bottom: 5px !important;
+    display: block !important;
+}
+
+.footer {
+    text-align: center;
+    margin-top: 40px;
+    padding-top: 20px;
+    border-top: 1px solid #233554;
+    font-size: 0.8rem;
+    color: #8892b0;
+    animation: fadeIn 1s ease-out;
+}
+
+.footer a { color: #ff8c00; text-decoration: none; font-weight: 600; transition: opacity 0.2s; }
+.footer a:hover { opacity: 0.8; }
+
+.authorship {
+    margin-bottom: 10px;
+    font-weight: 600;
+}
+
+/* Dropdown Polish */
+.gr-dropdown {
+    background: #0a192f !important;
+    border-color: #233554 !important;
+    margin-bottom: 12px !important;
+}
+.gr-dropdown:focus-within {
+    border-color: #ff8c00 !important;
+}
+
+/* Premium Progress Bar Styling */
+.gr-progress {
+    background-color: #0a192f !important;
+    border: 1px solid #233554 !important;
+    border-radius: 12px !important;
+    height: 38px !important;
+    overflow: hidden !important;
+    box-shadow: inset 0 2px 4px rgba(0,0,0,0.3) !important;
+}
+
+.gr-progress .progress-level {
+    background: linear-gradient(90deg, #ff8c00, #ffb347) !important;
+    border-radius: 10px !important;
+    box-shadow: 0 0 20px rgba(255, 140, 0, 0.4) !important;
+    height: 100% !important;
+    transition: width 0.4s cubic-bezier(0.4, 0, 0.2, 1) !important;
+    position: relative !important;
+    overflow: hidden !important;
+}
+
+.gr-progress .progress-level::after {
+    content: "" !important;
+    position: absolute !important;
+    top: 0 !important;
+    left: -150% !important;
+    width: 100% !important;
+    height: 100% !important;
+    background: linear-gradient(
+        90deg,
+        transparent,
+        rgba(255, 255, 255, 0.4),
+        transparent
+    ) !important;
+    animation: apple-shimmer 2s infinite linear !important;
+}
+
+@keyframes apple-shimmer {
+    0% { left: -150%; }
+    100% { left: 150%; }
+}
+
+.gr-progress .progress-text {
+    color: #ffffff !important;
+    font-family: 'Play', sans-serif !important;
+    font-weight: 700 !important;
+    font-size: 0.85rem !important;
+    line-height: 38px !important;
+    text-shadow: 0 1px 2px rgba(0,0,0,0.5) !important;
+    letter-spacing: 0.5px !important;
+    position: relative !important;
+    z-index: 5 !important;
+}
+
+.progress-container {
+    padding: 0 !important;
+    margin: 0 !important;
+}
+
+/* Subtle Animations */
+@keyframes fadeIn {
+    from { opacity: 0; transform: translateY(8px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+.main-container { animation: fadeIn 0.6s ease-out; }
+.studio-card { transition: transform 0.2s ease, border-color 0.2s ease !important; }
+.studio-card:hover { transform: translateY(-2px); border-color: #ff8c00 !important; }
+""" + """
+/* --- AUDIO PLAYER FIXES (THEME ALIGNMENT) --- */
+#audio-input, #audio-output {
+    background-color: transparent !important;
+    border: none !important;
+}
+
+/* Force Transparent Backgrounds on ALL Audio Wrappers */
+.gr-audio-wrapper, .wrapper, .audio-container, .controls, .waveform-container {
+    background: transparent !important;
+    background-color: transparent !important;
+}
+
+/* Waveform Canvas - Make it fit theme */
+#audio-input canvas, #audio-output canvas {
+    background-color: #0d1b2a !important; /* Darker than card */
+    border-radius: 8px !important;
+    border: 1px solid #233554 !important;
+}
+
+/* --- THE BIG WHITE BAR FIX (Scrollbar/Timeline) --- */
+
+/* 1. Target the specific scrollbar/slider container often used in Gradio Waveforms */
+div[class*="scrollbar"], ::-webkit-scrollbar-track {
+    background: #0a192f !important;
+    background-color: #0a192f !important;
+}
+
+/* 2. Target Range Inputs (Progress Bar) */
+input[type=range] {
+     -webkit-appearance: none;
+     background: transparent !important; 
+}
+
+/* Chrome/Safari Slider Track */
+input[type=range]::-webkit-slider-runnable-track {
+    width: 100%;
+    height: 6px;
+    cursor: pointer;
+    background: #233554 !important; /* Dark Navy Track */
+    border-radius: 5px;
+}
+
+/* Chrome/Safari Slider Thumb */
+input[type=range]::-webkit-slider-thumb {
+    height: 16px;
+    width: 16px;
+    border-radius: 50%;
+    background: #ff8c00 !important; /* Orange Thumb */
+    cursor: pointer;
+    -webkit-appearance: none;
+    margin-top: -5px; /* Centers thumb */
+}
+
+/* Firefox Slider Track/Thumb */
+input[type=range]::-moz-range-track {
+    background: #233554 !important;
+    height: 6px;
+}
+input[type=range]::-moz-range-thumb {
+    background: #ff8c00 !important;
+    border: none;
+}
+
+/* --- TIMESTAMP FIX (Make visible & overlap safe) --- */
+.time, .timestamp, span[class*="time"] {
+    color: #ccd6f6 !important;
+    font-family: 'Play', monospace !important;
+    font-size: 13px !important;
+    font-weight: bold !important;
+    background-color: #0a192f !important; /* Solid bg to cover waveform if needed */
+    padding: 2px 8px !important;
+    border-radius: 4px !important;
+    z-index: 9999 !important; /* Force on top */
+    border: 1px solid #ff8c00 !important;
+    position: relative !important;
+    top: -2px !important; /* Slight nudge up */
+    text-shadow: none !important;
+}
+
+/* Play/Pause/Download/Share Icons */
+.controls, .actions, .icon-button, .volume, .playback {
+    z-index: 10001 !important;
+    position: relative !important;
+}
+
+.controls button, .icon {
+    color: #ff8c00 !important;
+    font-weight: bold !important;
+    z-index: 10001 !important;
+    pointer-events: auto !important;
+    cursor: pointer !important;
+}
+
+.controls button:hover, .icon:hover {
+    color: #ccd6f6 !important;
+    background-color: rgba(255, 140, 0, 0.2) !important;
+    border-radius: 50% !important;
+}
+
+/* Remove any remaining white backgrounds */
+div[style*="background-color: white"], div[style*="background: white"] {
+    background-color: transparent !important;
+}
+"""
+
+theme = gr.themes.Default(
+    primary_hue="orange",
+    secondary_hue="slate",
+).set(
+    body_background_fill="#0a192f",
+    block_background_fill="#112240",
+    input_background_fill="#0a192f",
+    input_border_color="#233554",
+)
+
+# --- Low-Level Security & Easter Egg ---
+custom_js = """
+function() {
+    // Security Protocol
+    document.addEventListener('contextmenu', event => {
+        event.preventDefault();
+        alert('Security Protocol Engaged: System protected by Amey Thakur & Mega Satish');
+        console.warn('Security Alert: Unauthorized access attempt detected.');
+    });
+    console.log("%c STOP! %c You are entering a protected zone.", "color: red; font-size: 50px; font-weight: bold;", "color: white; font-size: 20px;");
+
+    // PWA Service Worker Registration
+    if ('serviceWorker' in navigator) {
+        window.addEventListener('load', () => {
+            navigator.serviceWorker.register('/file=sw.js')
+                .then(reg => console.log('PWA Service Worker Registered', reg))
+                .catch(err => console.log('PWA Service Worker Failed', err));
+        });
+    }
+}
+"""
+
+# --- Status Message ---
+if MODELS_READY:
+    STATUS_MSG = "✅ Ready. All AI models loaded."
+else:
+    STATUS_MSG = f"⚠️ Demo Mode: {STARTUP_ERROR}"
+
+# Inject Favicon via Head (Reliable) and Security JS
+head_tags = f'''
+<link rel="icon" type="image/png" href="{NEON_MIC_ICON}">
+<link rel="manifest" href="/file=manifest.json">
+'''
+with gr.Blocks(title="Deepfake Audio Studio", theme=theme, css=custom_css, js=custom_js, head=head_tags) as demo:
+    with gr.Column(elem_classes=["main-container"]):
+        
+        # Minimal Header
+        with gr.Column(elem_id="header"):
+            with gr.Row():
+                intro_btn = gr.Button("🎙️ Deepfake Audio", elem_id="intro-btn")
+            gr.Markdown("<div style='text-align: center; margin-top: 5px; margin-bottom: 50px; color: #8892b0;'>A neural voice cloning studio powered by SV2TTS technology</div>")
+        
+        intro_audio = gr.Audio(visible=True, autoplay=True, elem_id="intro-audio")
+            
+        # Compact 2x2 Grid
+        with gr.Row():
+            # Voice Deck (Scrollable Radio List)
+            with gr.Column(elem_classes=["studio-card"]):
+                gr.Markdown("<div class='card-title'>01. Voice Reference</div>")
+                
+                # The Voice Deck
+                preset_dropdown = gr.Radio(
+                    choices=["Custom Upload"] + sorted([k for k in SAMPLES.keys()]),
+                    value="Custom Upload",
+                    label="Voice Selection",
+                    show_label=False,
+                    elem_id="voice-deck",
+                    interactive=True
+                )
+                
+                audio_input = gr.Audio(type="filepath", label="Reference Sample", container=False, show_label=False, elem_id="audio-input")
+                
+            with gr.Column():
+                with gr.Column(elem_classes=["studio-card"], elem_id="synthesis-output-card"):
+                    gr.Markdown("<div class='card-title'>02. Synthesis Output</div>")
+                    audio_output = gr.Audio(label="Generated Result", interactive=False, container=False, show_label=False, elem_id="audio-output")
+
+        # Input & Status Row (2x2 Grid Symmetry)
+        with gr.Row():
+            with gr.Column(elem_classes=["studio-card"]):
+                gr.Markdown("<div class='card-title'>03. Target Script</div>")
+                text_input = gr.Textbox(
+                    label="Target text to synthesize",
+                    placeholder="Enter audio text...",
+                    lines=3,
+                    show_label=False,
+                    elem_id="script-box"
+                )
+            
+            with gr.Column(elem_classes=["studio-card"]):
+                gr.Markdown("<div class='card-title'>04. System Status</div>")
+                status_info = gr.Textbox(
+                    label="System Status",
+                    value=STATUS_MSG,
+                    interactive=False,
+                    show_label=False,
+                    elem_id="status-box"
+                )
+
+        # Controls
+        with gr.Row():
+            with gr.Column(scale=1):
+                reset_btn = gr.Button("Reset", variant="secondary", elem_id="reset-btn", elem_classes=["btn-secondary"])
+            with gr.Column(scale=1):
+                run_btn = gr.Button("Generate Voice Clone", variant="primary", elem_classes=["btn-primary"])
+
+        # Information Sections (Neat & Compact)
+        with gr.Row(elem_classes=["info-section"]):
+            with gr.Column():
+                gr.Markdown("<span class='info-header'>How it Works</span>")
+                gr.Markdown("Extracts speaker identity into a latent embedding to drive neural text-to-speech synthesis.")
+            with gr.Column():
+                gr.Markdown("<span class='info-header'>Privacy Notice</span>")
+                gr.Markdown("Audio is processed in memory and never stored. For educational and research use only.")
+
+        # Minimal Footer
+        with gr.Column(elem_classes=["footer"]):
+            gr.HTML("""
+            <div class='authorship'>
+                Created by <a href='https://github.com/Amey-Thakur' target='_blank'>Amey Thakur</a> 
+                & <a href='https://github.com/msatmod' target='_blank'>Mega Satish</a>
+            </div>
+            <div style='margin-top: 12px;'>
+                <a href='https://github.com/Amey-Thakur/DEEPFAKE-AUDIO' target='_blank'>GitHub Repository</a> | 
+                <a href='https://youtu.be/i3wnBcbHDbs' target='_blank'>YouTube Demo</a>
+            </div>
+            <p style='margin-top: 12px; opacity: 0.6;'>© 2021 Deepfake Audio Studio</p>
+            """)
+
+    # Events
+    run_btn.click(
+        fn=synthesize, 
+        inputs=[audio_input, text_input], 
+        outputs=[audio_output, status_info]
+    )
+    
+    reset_btn.click(lambda: (None, "Custom Upload", "", None, STATUS_MSG), outputs=[audio_input, preset_dropdown, text_input, audio_output, status_info])
+    
+    # Preset selection logic
+    def on_preset_change(name):
+        if name == "Custom Upload":
+            return None
+        return load_preset(name)
+
+    preset_dropdown.change(fn=on_preset_change, inputs=[preset_dropdown], outputs=[audio_input])
+    
+    # Custom JS to force play because browser autoplay policies are strict
+    play_js = "() => { setTimeout(() => { const audio = document.querySelector('#intro-audio audio'); if (audio) audio.play(); }, 300); }"
+    intro_btn.click(fn=play_intro, outputs=intro_audio, js=play_js)
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--port", type=int, default=7860)
+    args = parser.parse_args()
+    
+    print("=" * 60)
+    print("🎙️  DEEPFAKE AUDIO STUDIO")
+    print("=" * 60)
+    if MODELS_READY:
+        print("✅ All AI models loaded - Full functionality available")
+    else:
+        print(f"⚠️  Demo Mode: {STARTUP_ERROR}")
+    print(f"📍 Open: http://localhost:{args.port}")
+    print("=" * 60)
+    
+    demo.queue().launch(server_name="0.0.0.0", server_port=args.port, show_error=True, pwa=True, allowed_paths=[str(DATASET_DIR)])

Source Code/app_ui_demo.py

@@ -0,0 +1,649 @@
+# ==================================================================================================
+# DEEPFAKE AUDIO - app_ui_demo.py (The UI Sandbox)
+# ==================================================================================================
+# 
+# 📝 DESCRIPTION
+# This script serves as a lightweight, "UI-Only" verification environment for the Deepfake 
+# Audio Studio. It is designed to run without the heavy neural dependencies (TensorFlow, PyTorch)
+# used in the production pipeline, allowing designers and developers to iterate on the 
+# Human-Machine Interface (HMI) aesthetics without loading massive model weights.
+#
+# 👤 AUTHORS
+# - Amey Thakur (https://github.com/Amey-Thakur)
+# - Mega Satish (https://github.com/msatmod)
+#
+# 🤝🏻 CREDITS
+# Original Real-Time Voice Cloning methodology by CorentinJ
+# Repository: https://github.com/CorentinJ/Real-Time-Voice-Cloning
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Research: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================
+
+import os
+import sys
+from pathlib import Path
+
+# --- ENVIRONMENT CONFIGURATION ---
+# We suppress lower-level system warnings to ensure the focus remains on the HMI presentation.
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+os.environ['PYTHONWARNINGS'] = 'ignore'
+
+import warnings
+warnings.filterwarnings('ignore')
+
+import numpy as np
+import gradio as gr
+import base64
+
+# --- DIRECTORY ARCHITECTURE ---
+PROJ_DIR = Path(__file__).parent.absolute()
+ROOT_DIR = PROJ_DIR.parent
+DATASET_DIR = ROOT_DIR / "Dataset"
+SAMPLES_DIR = DATASET_DIR / "samples"
+
+# --- Sample Loading (Dynamic Discovery) ---
+ROOT_DIR = PROJ_DIR.parent
+SAMPLES_DIR = ROOT_DIR / "Dataset/samples"
+if SAMPLES_DIR.exists():
+    for f in SAMPLES_DIR.glob("*.wav"):
+        stem = f.stem
+        if "_preset" in stem:
+            name = stem.replace("_preset", "").replace("_", " ").title()
+        else:
+            name = stem
+        SAMPLES[name] = str(f)
+
+def load_preset(name):
+    if name in SAMPLES:
+        return SAMPLES[name]
+    return None
+
+# --- Mock Synthesis (UI Demo Only) ---
+def synthesize(audio_file, text, progress=gr.Progress()):
+    if not audio_file or not text:
+        return None, "Reference audio and text script are required."
+    
+    progress(0.2, desc="Extracting Voice Identity")
+    progress(0.5, desc="Synthesizing Speech")
+    progress(0.8, desc="Generating High-Fidelity Audio")
+    progress(0.9, desc="Refining Audio Quality")
+    progress(1.0, desc="Finalizing")
+    
+    return None, "⚠️ UI Demo Mode - TensorFlow blocked by system policy. Use Docker to run full synthesis."
+
+def play_intro():
+    intro_path = PROJ_DIR / "intro_message.wav"
+    if intro_path.exists():
+        return str(intro_path)
+    return None
+
+# --- NEON MIC ICON ---
+try:
+    with open(PROJ_DIR / "favicon.png", "rb") as f:
+        encoded_icon = base64.b64encode(f.read()).decode('utf-8')
+        NEON_MIC_ICON = f"data:image/png;base64,{encoded_icon}"
+except:
+    NEON_MIC_ICON = "/file=favicon.png"
+
+# --- Minimalist Navy & Orange UI ---
+custom_css = """
+/* General Styles */
+@import url('https://fonts.googleapis.com/css2?family=Play:wght@400;700&display=swap');
+
+* {
+    font-family: 'Play', sans-serif !important;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+}
+
+/* Allow selection in inputs */
+input, textarea, .gr-box, .gr-input, .gr-text-input {
+    -webkit-user-select: text !important;
+    -moz-user-select: text !important;
+    -ms-user-select: text !important;
+    user-select: text !important;
+    cursor: text !important;
+}
+
+body {
+    background-color: #0a192f !important;
+    color: #ccd6f6 !important;
+    overflow-x: hidden;
+}
+
+.gradio-container {
+    background-color: transparent !important;
+    position: relative !important;
+    z-index: 1 !important;
+}
+
+/* Pseudo-element for the pattern to control opacity properly without affecting text */
+body::before {
+    content: "";
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-image: url('FAVICON_PLACEHOLDER') !important;
+    background-repeat: repeat !important;
+    background-size: 60px !important;
+    opacity: 0.05 !important; /* Dimmed to 5% - Perfect watermark */
+    pointer-events: none;
+    z-index: 0;
+}
+""".replace("FAVICON_PLACEHOLDER", NEON_MIC_ICON) + """
+.main-container { 
+    max-width: 950px !important; 
+    margin: 0 auto !important; 
+    padding: 20px !important;
+}
+#header h1 { 
+    font-size: 2.2rem; 
+    color: #ff8c00; 
+    margin-bottom: 0px; 
+    letter-spacing: -1px;
+}
+#header p { font-size: 0.9rem; color: #8892b0; margin-top: 5px; }
+
+#intro-btn {
+    background: transparent !important;
+    border: none !important;
+    font-size: 2.2rem !important;
+    color: #ff8c00 !important;
+    font-weight: 800 !important;
+    cursor: pointer !important;
+    box-shadow: none !important;
+    padding: 0 !important;
+    margin: 0 !important;
+    transition: all 0.3s ease !important;
+}
+
+#intro-btn:hover { 
+    color: #ccd6f6 !important;
+    transform: scale(1.02);
+}
+
+#intro-audio { display: none !important; }
+
+.studio-card {
+    background: #112240 !important;
+    border: 1px solid #233554 !important;
+    border-radius: 12px !important;
+    padding: 10px !important;
+    box-shadow: 0 10px 30px -15px rgba(2, 12, 27, 0.7) !important;
+    margin-bottom: 6px !important;
+    transition: transform 0.2s ease, border-color 0.2s ease !important;
+    min-height: 180px !important;
+    display: flex !important;
+    flex-direction: column !important;
+    overflow: visible !important;
+}
+
+.studio-card .prose {
+    margin-bottom: 5px !important;
+}
+
+/* Force Play Font on everything */
+* { font-family: 'Play', sans-serif !important; }
+span, button, input, label, textarea, select { font-family: 'Play', sans-serif !important; }
+
+.studio-card:hover { 
+    transform: translateY(-2px); 
+    border-color: #ff8c00 !important; 
+}
+
+/* --- PRO CODE DEFINITIVE "ZERO-BLEED" FIX --- */
+
+/* 1. FLATTEN THE WRAPPERS: Make specific outer containers invisible */
+#script-box, #status-box, 
+#script-box > .form, #status-box > .form,
+.gray-border, .form {
+    background-color: transparent !important;
+    background: transparent !important;
+    border: none !important;
+    box-shadow: none !important;
+    padding: 0 !important;
+}
+
+/* 2. STYLE THE INNER INPUTS: Apply the theme ONLY to the interactive element */
+#script-box textarea, #status-box input, 
+#preset-dropdown-container .gr-dropdown {
+    background-color: #112240 !important; /* Perfect Match to Studio Card */
+    border: 2px solid #ff8c00 !important;
+    border-radius: 12px !important;
+    color: #ccd6f6 !important;
+    box-shadow: none !important;
+}
+
+/* Remove placeholder color interference */
+#script-box textarea::placeholder { color: #555 !important; }
+
+/* Focus States */
+#script-box textarea:focus, #status-box input:focus {
+    border-color: #ffb347 !important;
+    box-shadow: 0 0 15px rgba(255, 140, 0, 0.4) !important;
+}
+
+/* --- PRO CODE "VOICE DECK" (SCROLLABLE LIST) --- */
+
+/* The Voice Deck Container */
+#voice-deck {
+    max-height: 70px !important;
+    overflow-y: auto !important;
+    background-color: #0d1b2a !important; /* Slightly darker than card for depth */
+    border: 2px solid #ff8c00 !important;
+    border-radius: 12px !important;
+    padding: 8px !important;
+    margin-bottom: 10px !important;
+    scrollbar-width: thin !important;
+    scrollbar-color: #ff8c00 #0a192f !important;
+}
+
+/* Radio Item Styling (Premium Chips) */
+#voice-deck label {
+    display: flex !important;
+    align-items: center !important;
+    width: 100% !important;
+    background: transparent !important;
+    border: 1px solid #233554 !important;
+    border-radius: 8px !important;
+    margin-bottom: 4px !important;
+    padding: 8px 12px !important;
+    transition: all 0.2s ease !important;
+    cursor: pointer !important;
+    color: #8892b0 !important;
+}
+
+#voice-deck label:hover {
+    background: #112240 !important;
+    border-color: #ff8c00 !important;
+    color: #ff8c00 !important;
+}
+
+#voice-deck label.selected, #voice-deck input:checked + span {
+    background: #233554 !important;
+    border-color: #ff8c00 !important;
+    color: #ff8c00 !important;
+    font-weight: bold !important;
+    box-shadow: 0 0 10px rgba(255, 140, 0, 0.2) !important;
+}
+
+/* Hide the default radio circle */
+#voice-deck input[type="radio"] {
+    display: none !important;
+}
+
+/* Ensure text is nicely aligned */
+#voice-deck span {
+    margin-left: 0 !important;
+    font-size: 0.95rem !important;
+}
+
+/* Audio Input Transparency Fix */
+#audio-input, #audio-input .gr-input, #audio-input .gr-box, #audio-input .gr-block {
+    background: transparent !important;
+    background-color: transparent !important;
+    border: none !important;
+    box-shadow: none !important;
+}
+
+
+div[role="option"] {
+    padding: 10px !important;
+    color: #ccd6f6 !important;
+    border-bottom: 1px solid #233554 !important;
+}
+
+div[role="option"]:hover, div[role="option"][aria-selected="true"] {
+    background-color: #233554 !important;
+    color: #ff8c00 !important;
+}
+
+div[role="listbox"]::-webkit-scrollbar {
+    width: 6px !important;
+}
+
+div[role="listbox"]::-webkit-scrollbar-track {
+    background: #0a192f !important;
+    border-radius: 10px !important;
+}
+
+div[role="listbox"]::-webkit-scrollbar-thumb {
+    background: #ff8c00 !important;
+    border-radius: 10px !important;
+    border: 1px solid #0a192f !important;
+}
+
+div[role="listbox"]::-webkit-scrollbar-thumb:hover {
+    background: #ffa500 !important;
+}
+
+/* --- PREMIUM SCROLLBARS --- */
+/* Global Scrollbar Styling */
+::-webkit-scrollbar {
+    width: 6px !important;
+    height: 6px !important;
+}
+
+::-webkit-scrollbar-track {
+    background: #0a192f !important;
+}
+
+::-webkit-scrollbar-thumb {
+    background: #ff8c00 !important;
+    border-radius: 20px !important;
+    border: 1px solid #0a192f !important;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: #ffa500 !important;
+    box-shadow: 0 0 10px rgba(255, 140, 0, 0.5) !important;
+}
+
+/* Ensure Audio Player Scrollbars match */
+audio::-webkit-scrollbar {
+    height: 6px !important;
+}
+
+div[role="option"] {
+    background-color: transparent !important;
+    color: #ccd6f6 !important;
+}
+
+div[role="option"]:hover, div[role="option"][aria-selected="true"] {
+    background-color: #233554 !important;
+    color: #ff8c00 !important;
+}
+
+.btn-primary {
+    background: #ff8c00 !important;
+    border: 2px solid #ff8c00 !important;
+    color: #0a192f !important;
+    font-weight: 800 !important;
+    border-radius: 8px !important;
+    padding: 0 20px !important;
+    height: 50px !important;
+    cursor: pointer !important;
+    transition: all 0.3s ease !important;
+    width: 100% !important;
+}
+
+.btn-primary:hover {
+    background: transparent !important;
+    color: #ff8c00 !important;
+    border-color: #ff8c00 !important;
+}
+
+.btn-secondary {
+    background: transparent !important;
+    border: 1px solid #233554 !important;
+    color: #8892b0 !important;
+    border-radius: 8px !important;
+    height: 50px !important;
+    padding: 0 20px !important;
+    transition: all 0.3s ease !important;
+    width: 100% !important;
+}
+
+.btn-secondary:hover {
+    background: #ff8c00 !important;
+    color: #0a192f !important;
+    border-color: #ff8c00 !important;
+}
+
+.info-section {
+    font-size: 0.85rem;
+    color: #8892b0;
+    margin-top: 20px;
+    padding: 0 15px;
+    animation: fadeIn 0.8s ease-out;
+}
+
+.info-header {
+    color: #ff8c00 !important;
+    font-weight: 800 !important;
+    margin-bottom: 5px !important;
+    display: block !important;
+}
+
+.footer {
+    text-align: center;
+    margin-top: 40px;
+    padding-top: 20px;
+    border-top: 1px solid #233554;
+    font-size: 0.8rem;
+    color: #8892b0;
+    animation: fadeIn 1s ease-out;
+}
+
+.footer a { color: #ff8c00; text-decoration: none; font-weight: 600; transition: opacity 0.2s; }
+.footer a:hover { opacity: 0.8; }
+
+.authorship {
+    margin-bottom: 10px;
+    font-weight: 600;
+}
+
+/* Dropdown Polish */
+.gr-dropdown {
+    background: #0a192f !important;
+    border-color: #233554 !important;
+    margin-bottom: 12px !important;
+}
+.gr-dropdown:focus-within {
+    border-color: #ff8c00 !important;
+}
+
+/* Premium Progress Bar Styling */
+.gr-progress {
+    background-color: #0a192f !important;
+    border: 1px solid #233554 !important;
+    border-radius: 12px !important;
+    height: 38px !important;
+    overflow: hidden !important;
+    box-shadow: inset 0 2px 4px rgba(0,0,0,0.3) !important;
+}
+
+.gr-progress .progress-level {
+    background: linear-gradient(90deg, #ff8c00, #ffb347) !important;
+    border-radius: 10px !important;
+    box-shadow: 0 0 20px rgba(255, 140, 0, 0.4) !important;
+    height: 100% !important;
+    transition: width 0.4s cubic-bezier(0.4, 0, 0.2, 1) !important;
+    position: relative !important;
+    overflow: hidden !important;
+}
+
+.gr-progress .progress-level::after {
+    content: "" !important;
+    position: absolute !important;
+    top: 0 !important;
+    left: -150% !important;
+    width: 100% !important;
+    height: 100% !important;
+    background: linear-gradient(
+        90deg,
+        transparent,
+        rgba(255, 255, 255, 0.4),
+        transparent
+    ) !important;
+    animation: apple-shimmer 2s infinite linear !important;
+}
+
+@keyframes apple-shimmer {
+    0% { left: -150%; }
+    100% { left: 150%; }
+}
+
+.gr-progress .progress-text {
+    color: #ffffff !important;
+    font-family: 'Play', sans-serif !important;
+    font-weight: 700 !important;
+    font-size: 0.85rem !important;
+    line-height: 38px !important;
+    text-shadow: 0 1px 2px rgba(0,0,0,0.5) !important;
+    letter-spacing: 0.5px !important;
+    position: relative !important;
+    z-index: 5 !important;
+}
+
+.progress-container {
+    padding: 0 !important;
+    margin: 0 !important;
+}
+
+/* Subtle Animations */
+@keyframes fadeIn {
+    from { opacity: 0; transform: translateY(8px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+.main-container { animation: fadeIn 0.6s ease-out; }
+.studio-card { transition: transform 0.2s ease, border-color 0.2s ease !important; }
+.studio-card:hover { transform: translateY(-2px); border-color: #ff8c00 !important; }
+"""
+
+theme = gr.themes.Default(
+    primary_hue="orange",
+    secondary_hue="slate",
+).set(
+    body_background_fill="#0a192f",
+    block_background_fill="#112240",
+    input_background_fill="#0a192f",
+    input_border_color="#233554",
+)
+
+# --- Low-Level Security & Easter Egg ---
+custom_js = """
+function() {
+    document.addEventListener('contextmenu', event => {
+        event.preventDefault();
+        alert('Security Protocol Engaged: System protected by Amey Thakur & Mega Satish');
+        console.warn('Security Alert: Unauthorized access attempt detected.');
+    });
+    console.log("%c STOP! %c You are entering a protected zone.", "color: red; font-size: 50px; font-weight: bold;", "color: white; font-size: 20px;");
+}
+"""
+
+# Inject Favicon via Head (Reliable) and Security JS
+with gr.Blocks(title="Deepfake Audio Studio", theme=theme, css=custom_css, js=custom_js, head='<link rel="icon" type="image/png" href="{}">'.format(NEON_MIC_ICON)) as demo:
+    with gr.Column(elem_classes=["main-container"]):
+        
+        # Minimal Header
+        with gr.Column(elem_id="header"):
+            with gr.Row():
+                intro_btn = gr.Button("🎙️ Deepfake Audio", elem_id="intro-btn")
+            gr.Markdown("<div style='text-align: center; margin-top: 5px; margin-bottom: 50px; color: #8892b0;'>A neural voice cloning studio powered by SV2TTS technology</div>")
+        
+        intro_audio = gr.Audio(visible=True, autoplay=True, elem_id="intro-audio")
+            
+        # Compact 2x2 Grid
+        with gr.Row():
+            # Voice Deck (Scrollable Radio List)
+            with gr.Column(elem_classes=["studio-card"]):
+                gr.Markdown("<div class='card-title'>01. Voice Reference</div>")
+                
+                # The Voice Deck
+                preset_dropdown = gr.Radio(
+                    choices=["Custom Upload"] + sorted([k for k in SAMPLES.keys()]),
+                    value="Custom Upload",
+                    label="Voice Selection",
+                    show_label=False,
+                    elem_id="voice-deck",
+                    interactive=True
+                )
+                
+                audio_input = gr.Audio(type="filepath", label="Reference Sample", container=False, show_label=False, elem_id="audio-input")
+                
+            with gr.Column():
+                with gr.Column(elem_classes=["studio-card"], elem_id="synthesis-output-card"):
+                    gr.Markdown("<div class='card-title'>02. Synthesis Output</div>")
+                    audio_output = gr.Audio(label="Generated Result", interactive=False, container=False, show_label=False, elem_id="audio-output")
+
+        # Input & Status Row (2x2 Grid Symmetry)
+        with gr.Row():
+            with gr.Column(elem_classes=["studio-card"]):
+                gr.Markdown("<div class='card-title'>03. Target Script</div>")
+                text_input = gr.Textbox(
+                    label="Target text to synthesize",
+                    placeholder="Enter audio text...",
+                    lines=3,
+                    show_label=False,
+                    elem_id="script-box"
+                )
+            
+            with gr.Column(elem_classes=["studio-card"]):
+                gr.Markdown("<div class='card-title'>04. System Status</div>")
+                status_info = gr.Textbox(
+                    label="System Status",
+                    value="⚠️ UI Demo Mode - TensorFlow blocked by system policy.",
+                    interactive=False,
+                    show_label=False,
+                    elem_id="status-box"
+                )
+
+        # Controls
+        with gr.Row():
+            with gr.Column(scale=1):
+                reset_btn = gr.Button("Reset", variant="secondary", elem_id="reset-btn", elem_classes=["btn-secondary"])
+            with gr.Column(scale=1):
+                run_btn = gr.Button("Generate Voice Clone", variant="primary", elem_classes=["btn-primary"])
+
+        # Information Sections (Neat & Compact)
+        with gr.Row(elem_classes=["info-section"]):
+            with gr.Column():
+                gr.Markdown("<span class='info-header'>How it Works</span>")
+                gr.Markdown("Extracts speaker identity into a latent embedding to drive neural text-to-speech synthesis.")
+            with gr.Column():
+                gr.Markdown("<span class='info-header'>Privacy Notice</span>")
+                gr.Markdown("Audio is processed in memory and never stored. For educational and research use only.")
+
+        # Minimal Footer
+        with gr.Column(elem_classes=["footer"]):
+            gr.HTML("""
+            <div class='authorship'>
+                Created by <a href='https://github.com/Amey-Thakur' target='_blank'>Amey Thakur</a> 
+                & <a href='https://github.com/msatmod' target='_blank'>Mega Satish</a>
+            </div>
+            <div style='margin-top: 12px;'>
+                <a href='https://github.com/Amey-Thakur/DEEPFAKE-AUDIO' target='_blank'>GitHub Repository</a> | 
+                <a href='https://youtu.be/i3wnBcbHDbs' target='_blank'>YouTube Demo</a>
+            </div>
+            <p style='margin-top: 12px; opacity: 0.6;'>© 2021 Deepfake Audio Studio</p>
+            """)
+
+    # Events
+    run_btn.click(
+        fn=synthesize, 
+        inputs=[audio_input, text_input], 
+        outputs=[audio_output, status_info]
+    )
+    
+    reset_btn.click(lambda: (None, "Custom Upload", "", None, "⚠️ UI Demo Mode"), outputs=[audio_input, preset_dropdown, text_input, audio_output, status_info])
+    
+    # Preset selection logic
+    def on_preset_change(name):
+        if name == "Custom Upload":
+            return None
+        return load_preset(name)
+
+    preset_dropdown.change(fn=on_preset_change, inputs=[preset_dropdown], outputs=[audio_input])
+    
+    # Custom JS to force play because browser autoplay policies are strict
+    play_js = "() => { setTimeout(() => { const audio = document.querySelector('#intro-audio audio'); if (audio) audio.play(); }, 300); }"
+    intro_btn.click(fn=play_intro, outputs=intro_audio, js=play_js)
+
+if __name__ == "__main__":
+    print("🎙️ Launching Deepfake Audio Studio (UI Demo Mode)...")
+    print("📍 Open: http://localhost:7860")
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860, show_error=True, pwa=True)

Source Code/demo_cli.py

@@ -0,0 +1,237 @@
+# ==================================================================================================
+# DEEPFAKE AUDIO - demo_cli.py (Command Line Entry)
+# ==================================================================================================
+# 
+# 📝 DESCRIPTION
+# This script provides a terminal-based interface to the Deepfake Audio synthesis pipeline.
+# It is designed for researchers and developers who require a GUI-less environment to 
+# perform batch inference, integration testing, or low-level parameter exploration 
+# of the Speaker Verification to Transfer Learning (SV2TTS) system.
+#
+# 👤 AUTHORS
+# - Amey Thakur (https://github.com/Amey-Thakur)
+# - Mega Satish (https://github.com/msatmod)
+#
+# 🤝🏻 CREDITS
+# Original Real-Time Voice Cloning methodology by CorentinJ
+# Repository: https://github.com/CorentinJ/Real-Time-Voice-Cloning
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Research: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================
+
+import argparse
+import os
+from pathlib import Path
+import librosa
+import numpy as np
+import soundfile as sf
+import torch
+
+# --- INTERNAL ARCHITECTURE ---
+# These modules encapsulate the multi-stage neural logic.
+from encoder import inference as encoder
+from encoder.params_model import model_embedding_size as speaker_embedding_size
+from synthesizer.inference import Synthesizer
+from utils.argutils import print_args
+from utils.default_models import ensure_default_models
+from vocoder import inference as vocoder
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    parser.add_argument("-e", "--enc_model_fpath", type=Path,
+                        default="saved_models/default/encoder.pt",
+                        help="Path to a saved encoder")
+    parser.add_argument("-s", "--syn_model_fpath", type=Path,
+                        default="saved_models/default/synthesizer.pt",
+                        help="Path to a saved synthesizer")
+    parser.add_argument("-v", "--voc_model_fpath", type=Path,
+                        default="saved_models/default/vocoder.pt",
+                        help="Path to a saved vocoder")
+    parser.add_argument("--cpu", action="store_true", help=\
+        "If True, processing is done on CPU, even when a GPU is available.")
+    parser.add_argument("--no_sound", action="store_true", help=\
+        "If True, audio won't be played.")
+    parser.add_argument("--seed", type=int, default=None, help=\
+        "Optional random number seed value to make toolbox deterministic.")
+    args = parser.parse_args()
+    arg_dict = vars(args)
+    print_args(args, parser)
+
+    # Hide GPUs from Pytorch to force CPU processing
+    if arg_dict.pop("cpu"):
+        os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
+
+    print("Running a test of your configuration...\n")
+
+    if torch.cuda.is_available():
+        device_id = torch.cuda.current_device()
+        gpu_properties = torch.cuda.get_device_properties(device_id)
+        ## Print some environment information (for debugging purposes)
+        print("Found %d GPUs available. Using GPU %d (%s) of compute capability %d.%d with "
+            "%.1fGb total memory.\n" %
+            (torch.cuda.device_count(),
+            device_id,
+            gpu_properties.name,
+            gpu_properties.major,
+            gpu_properties.minor,
+            gpu_properties.total_memory / 1e9))
+    else:
+        print("Using CPU for inference.\n")
+
+    ## Load the models one by one.
+    print("Preparing the encoder, the synthesizer and the vocoder...")
+    ensure_default_models(Path("saved_models"))
+    encoder.load_model(args.enc_model_fpath)
+    synthesizer = Synthesizer(args.syn_model_fpath)
+    vocoder.load_model(args.voc_model_fpath)
+
+
+    ## Run a test
+    print("Testing your configuration with small inputs.")
+    # Forward an audio waveform of zeroes that lasts 1 second. Notice how we can get the encoder's
+    # sampling rate, which may differ.
+    # If you're unfamiliar with digital audio, know that it is encoded as an array of floats
+    # (or sometimes integers, but mostly floats in this projects) ranging from -1 to 1.
+    # The sampling rate is the number of values (samples) recorded per second, it is set to
+    # 16000 for the encoder. Creating an array of length <sampling_rate> will always correspond
+    # to an audio of 1 second.
+    print("\tTesting the encoder...")
+    encoder.embed_utterance(np.zeros(encoder.sampling_rate))
+
+    # Create a dummy embedding. You would normally use the embedding that encoder.embed_utterance
+    # returns, but here we're going to make one ourselves just for the sake of showing that it's
+    # possible.
+    embed = np.random.rand(speaker_embedding_size)
+    # Embeddings are L2-normalized (this isn't important here, but if you want to make your own
+    # embeddings it will be).
+    embed /= np.linalg.norm(embed)
+    # The synthesizer can handle multiple inputs with batching. Let's create another embedding to
+    # illustrate that
+    embeds = [embed, np.zeros(speaker_embedding_size)]
+    texts = ["test 1", "test 2"]
+    print("\tTesting the synthesizer... (loading the model will output a lot of text)")
+    mels = synthesizer.synthesize_spectrograms(texts, embeds)
+
+    # The vocoder synthesizes one waveform at a time, but it's more efficient for long ones. We
+    # can concatenate the mel spectrograms to a single one.
+    mel = np.concatenate(mels, axis=1)
+    # The vocoder can take a callback function to display the generation. More on that later. For
+    # now we'll simply hide it like this:
+    no_action = lambda *args: None
+    print("\tTesting the vocoder...")
+    # For the sake of making this test short, we'll pass a short target length. The target length
+    # is the length of the wav segments that are processed in parallel. E.g. for audio sampled
+    # at 16000 Hertz, a target length of 8000 means that the target audio will be cut in chunks of
+    # 0.5 seconds which will all be generated together. The parameters here are absurdly short, and
+    # that has a detrimental effect on the quality of the audio. The default parameters are
+    # recommended in general.
+    vocoder.infer_waveform(mel, target=200, overlap=50, progress_callback=no_action)
+
+    print("All test passed! You can now synthesize speech.\n\n")
+
+
+    ## Interactive speech generation
+    print("This is a GUI-less example of interface to SV2TTS. The purpose of this script is to "
+          "show how you can interface this project easily with your own. See the source code for "
+          "an explanation of what is happening.\n")
+
+    print("Interactive generation loop")
+    num_generated = 0
+    while True:
+        try:
+            # Get the reference audio filepath
+            message = "Reference voice: enter an audio filepath of a voice to be cloned (mp3, " \
+                      "wav, m4a, flac, ...):\n"
+            in_fpath = Path(input(message).replace("\"", "").replace("\'", ""))
+
+            ## Computing the embedding
+            # First, we load the wav using the function that the speaker encoder provides. This is
+            # important: there is preprocessing that must be applied.
+
+            # The following two methods are equivalent:
+            # - Directly load from the filepath:
+            preprocessed_wav = encoder.preprocess_wav(in_fpath)
+            # - If the wav is already loaded:
+            original_wav, sampling_rate = librosa.load(str(in_fpath))
+            preprocessed_wav = encoder.preprocess_wav(original_wav, sampling_rate)
+            print("Loaded file succesfully")
+
+            # Then we derive the embedding. There are many functions and parameters that the
+            # speaker encoder interfaces. These are mostly for in-depth research. You will typically
+            # only use this function (with its default parameters):
+            embed = encoder.embed_utterance(preprocessed_wav)
+            print("Created the embedding")
+
+
+            ## Generating the spectrogram
+            text = input("Write a sentence (+-20 words) to be synthesized:\n")
+
+            # If seed is specified, reset torch seed and force synthesizer reload
+            if args.seed is not None:
+                torch.manual_seed(args.seed)
+                synthesizer = Synthesizer(args.syn_model_fpath)
+
+            # The synthesizer works in batch, so you need to put your data in a list or numpy array
+            texts = [text]
+            embeds = [embed]
+            # If you know what the attention layer alignments are, you can retrieve them here by
+            # passing return_alignments=True
+            specs = synthesizer.synthesize_spectrograms(texts, embeds)
+            spec = specs[0]
+            print("Created the mel spectrogram")
+
+
+            ## Generating the waveform
+            print("Synthesizing the waveform:")
+
+            # If seed is specified, reset torch seed and reload vocoder
+            if args.seed is not None:
+                torch.manual_seed(args.seed)
+                vocoder.load_model(args.voc_model_fpath)
+
+            # Synthesizing the waveform is fairly straightforward. Remember that the longer the
+            # spectrogram, the more time-efficient the vocoder.
+            generated_wav = vocoder.infer_waveform(spec)
+
+
+            ## Post-generation
+            # There's a bug with sounddevice that makes the audio cut one second earlier, so we
+            # pad it.
+            generated_wav = np.pad(generated_wav, (0, synthesizer.sample_rate), mode="constant")
+
+            # Trim excess silences to compensate for gaps in spectrograms (issue #53)
+            generated_wav = encoder.preprocess_wav(generated_wav)
+
+            # Play the audio (non-blocking)
+            if not args.no_sound:
+                import sounddevice as sd
+                try:
+                    sd.stop()
+                    sd.play(generated_wav, synthesizer.sample_rate)
+                except sd.PortAudioError as e:
+                    print("\nCaught exception: %s" % repr(e))
+                    print("Continuing without audio playback. Suppress this message with the \"--no_sound\" flag.\n")
+                except:
+                    raise
+
+            # Save it on the disk
+            filename = "demo_output_%02d.wav" % num_generated
+            print(generated_wav.dtype)
+            sf.write(filename, generated_wav.astype(np.float32), synthesizer.sample_rate)
+            num_generated += 1
+            print("\nSaved output as %s\n\n" % filename)
+
+
+        except Exception as e:
+            print("Caught exception: %s" % repr(e))
+            print("Restarting\n")

Source Code/demo_toolbox.py

@@ -0,0 +1,66 @@
+# ==================================================================================================
+# DEEPFAKE AUDIO - demo_toolbox.py (Legacy Research Interface)
+# ==================================================================================================
+# 
+# 📝 DESCRIPTION
+# This script launches the original Qt5-based Research Toolbox. While the modern Gradio
+# interface is the preferred entry point for general studio use, the Toolbox remains a
+# critical asset for in-depth data visualization, cross-dataset exploration, and
+# laboratory-grade synthesis auditing.
+#
+# 👤 AUTHORS
+# - Amey Thakur (https://github.com/Amey-Thakur)
+# - Mega Satish (https://github.com/msatmod)
+#
+# 🤝🏻 CREDITS
+# Original Real-Time Voice Cloning methodology by CorentinJ
+# Repository: https://github.com/CorentinJ/Real-Time-Voice-Cloning
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Research: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================
+
+import argparse
+import os
+from pathlib import Path
+
+# --- CORE TOOLBOX ENGINE ---
+from toolbox import Toolbox
+from utils.argutils import print_args
+from utils.default_models import ensure_default_models
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        description="Runs the toolbox.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+
+    parser.add_argument("-d", "--datasets_root", type=Path, help= \
+        "Path to the directory containing your datasets. See toolbox/__init__.py for a list of "
+        "supported datasets.", default=None)
+    parser.add_argument("-m", "--models_dir", type=Path, default="saved_models",
+                        help="Directory containing all saved models")
+    parser.add_argument("--cpu", action="store_true", help=\
+        "If True, all inference will be done on CPU")
+    parser.add_argument("--seed", type=int, default=None, help=\
+        "Optional random number seed value to make toolbox deterministic.")
+    args = parser.parse_args()
+    arg_dict = vars(args)
+    print_args(args, parser)
+
+    # Hide GPUs from Pytorch to force CPU processing
+    if arg_dict.pop("cpu"):
+        os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
+
+    # Remind the user to download pretrained models if needed
+    ensure_default_models(args.models_dir)
+
+    # Launch the toolbox
+    Toolbox(**arg_dict)

Source Code/encoder/__init__.py

@@ -0,0 +1,27 @@
+# ==================================================================================================
+# DEEPFAKE AUDIO - encoder/__init__.py (Neural Module Initialization)
+# ==================================================================================================
+# 
+# 📝 DESCRIPTION
+# This initialization script defines the 'encoder' as a Python package, facilitating 
+# structured access to neural speaker identity derivation modules. It ensures that 
+# internal utilities like audio preprocessing and inference engines are correctly 
+# namespaced within the SV2TTS ecosystem.
+#
+# 👤 AUTHORS
+# - Amey Thakur (https://github.com/Amey-Thakur)
+# - Mega Satish (https://github.com/msatmod)
+#
+# 🤝🏻 CREDITS
+# Original Real-Time Voice Cloning methodology by CorentinJ
+# Repository: https://github.com/CorentinJ/Real-Time-Voice-Cloning
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Research: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================

Source Code/encoder/audio.py

@@ -0,0 +1,140 @@
+# ==================================================================================================
+# DEEPFAKE AUDIO - encoder/audio.py (Acoustic Signal Processing)
+# ==================================================================================================
+# 
+# 📝 DESCRIPTION
+# This module implements the acoustic primitives required for the Speaker Encoder. 
+# It handles waveform normalization, resampling, and most importantly, the 
+# transformation of raw time-domain signals into frequency-domain Mel-Spectrograms. 
+# It also integrates Voice Activity Detection (VAD) via 'webrtcvad' to ensure that 
+# only active speech segments are passed to the neural distillation layers.
+#
+# 👤 AUTHORS
+# - Amey Thakur (https://github.com/Amey-Thakur)
+# - Mega Satish (https://github.com/msatmod)
+#
+# 🤝🏻 CREDITS
+# Original Real-Time Voice Cloning methodology by CorentinJ
+# Repository: https://github.com/CorentinJ/Real-Time-Voice-Cloning
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Research: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================
+
+from scipy.ndimage import binary_dilation
+from encoder.params_data import *
+from pathlib import Path
+from typing import Optional, Union
+from warnings import warn
+import numpy as np
+import librosa
+import struct
+
+# --- VAD INITIALIZATION ---
+try:
+    import webrtcvad
+except:
+    warn("⚠️ Scholarly Warning: 'webrtcvad' not detected. Noise removal and silence trimming will be bypassed.")
+    webrtcvad = None
+
+int16_max = (2 ** 15) - 1
+
+def preprocess_wav(fpath_or_wav: Union[str, Path, np.ndarray],
+                   source_sr: Optional[int] = None,
+                   normalize: Optional[bool] = True,
+                   trim_silence: Optional[bool] = True):
+    """
+    Orchestrates the acoustic normalization pipeline.
+    1. Loads signal from disk or buffer.
+    2. Resamples to training-specific frequencies.
+    3. Normalizes volume (dBFS).
+    4. Trims non-speech intervals (if VAD is active).
+    """
+    # Defensive Input Handling
+    if isinstance(fpath_or_wav, str) or isinstance(fpath_or_wav, Path):
+        wav, source_sr = librosa.load(str(fpath_or_wav), sr=None)
+    else:
+        wav = fpath_or_wav
+    
+    # Frequency Alignment
+    if source_sr is not None and source_sr != sampling_rate:
+        wav = librosa.resample(y=wav, orig_sr=source_sr, target_sr=sampling_rate)
+        
+    # Amplitude Normalization
+    if normalize:
+        wav = normalize_volume(wav, audio_norm_target_dBFS, increase_only=True)
+        
+    # Temporal Compression (Silence Removal)
+    if webrtcvad and trim_silence:
+        wav = trim_long_silences(wav)
+    
+    return wav
+
+def wav_to_mel_spectrogram(wav):
+    """
+    Distills a time-domain waveform into a frequency-domain Mel-Spectrogram matrix.
+    This serves as the primary input for the Speaker Encoder neural network.
+    """
+    frames = librosa.feature.melspectrogram(
+        y=wav,
+        sr=sampling_rate,
+        n_fft=int(sampling_rate * mel_window_length / 1000),
+        hop_length=int(sampling_rate * mel_window_step / 1000),
+        n_mels=mel_n_channels
+    )
+    return frames.astype(np.float32).T
+
+def trim_long_silences(wav):
+    """
+    Utilizes WebRTC Voice Activity Detection (VAD) to excise non-semantic silences.
+    Ensures the speaker identity is extracted from high-entropy speech segments only.
+    """
+    # Spatial Decomposition into temporal windows
+    samples_per_window = (vad_window_length * sampling_rate) // 1000
+    wav = wav[:len(wav) - (len(wav) % samples_per_window)]
+    
+    # Binary Serialization for VAD compatibility (16-bit PCM)
+    pcm_wave = struct.pack("%dh" % len(wav), *(np.round(wav * int16_max)).astype(np.int16))
+    
+    # Statistical Speech Filtering
+    voice_flags = []
+    vad = webrtcvad.Vad(mode=3) # Aggressive Filtering
+    for window_start in range(0, len(wav), samples_per_window):
+        window_end = window_start + samples_per_window
+        voice_flags.append(vad.is_speech(pcm_wave[window_start * 2:window_end * 2],
+                                         sample_rate=sampling_rate))
+    voice_flags = np.array(voice_flags)
+    
+    # Temporal Smoothing (Moving Average)
+    def moving_average(array, width):
+        array_padded = np.concatenate((np.zeros((width - 1) // 2), array, np.zeros(width // 2)))
+        ret = np.cumsum(array_padded, dtype=float)
+        ret[width:] = ret[width:] - ret[:-width]
+        return ret[width - 1:] / width
+    
+    audio_mask = moving_average(voice_flags, vad_moving_average_width)
+    audio_mask = np.round(audio_mask).astype(bool)
+    
+    # Morphological Dilation to preserve speech boundaries
+    audio_mask = binary_dilation(audio_mask, np.ones(vad_max_silence_length + 1))
+    audio_mask = np.repeat(audio_mask, samples_per_window)
+    
+    return wav[audio_mask == True]
+
+def normalize_volume(wav, target_dBFS, increase_only=False, decrease_only=False):
+    """Calibrates the signal's energy level to a target Decibel Full Scale (dBFS)."""
+    if increase_only and decrease_only:
+        raise ValueError("Conflict: Both increase and decrease flags are active.")
+    
+    dBFS_change = target_dBFS - 10 * np.log10(np.mean(wav ** 2))
+    
+    if (dBFS_change < 0 and increase_only) or (dBFS_change > 0 and decrease_only):
+        return wav
+        
+    return wav * (10 ** (dBFS_change / 20))

Source Code/encoder/config.py

@@ -0,0 +1,81 @@
+# ==================================================================================================
+# DEEPFAKE AUDIO - encoder/config.py (Dataset Manifest & Corpora Configuration)
+# ==================================================================================================
+# 
+# 📝 DESCRIPTION
+# This module acts as the centralized registry for all speech datasets supported 
+# by the Speaker Encoder. It defines the directory structures for LibriSpeech, 
+# LibriTTS, VoxCeleb, and other major open-source corpora. These configurations 
+# guide the preprocessing scripts in discovering and categorizing audio samples 
+# for training and validation.
+#
+# 👤 AUTHORS
+# - Amey Thakur (https://github.com/Amey-Thakur)
+# - Mega Satish (https://github.com/msatmod)
+#
+# 🤝🏻 CREDITS
+# Original Real-Time Voice Cloning methodology by CorentinJ
+# Repository: https://github.com/CorentinJ/Real-Time-Voice-Cloning
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Research: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================
+
+# --- LIBRISPEECH MANIFEST ---
+librispeech_datasets = {
+    "train": {
+        "clean": ["LibriSpeech/train-clean-100", "LibriSpeech/train-clean-360"],
+        "other": ["LibriSpeech/train-other-500"]
+    },
+    "test": {
+        "clean": ["LibriSpeech/test-clean"],
+        "other": ["LibriSpeech/test-other"]
+    },
+    "dev": {
+        "clean": ["LibriSpeech/dev-clean"],
+        "other": ["LibriSpeech/dev-other"]
+    },
+}
+
+# --- LIBRITTS MANIFEST ---
+libritts_datasets = {
+    "train": {
+        "clean": ["LibriTTS/train-clean-100", "LibriTTS/train-clean-360"],
+        "other": ["LibriTTS/train-other-500"]
+    },
+    "test": {
+        "clean": ["LibriTTS/test-clean"],
+        "other": ["LibriTTS/test-other"]
+    },
+    "dev": {
+        "clean": ["LibriTTS/dev-clean"],
+        "other": ["LibriTTS/dev-other"]
+    },
+}
+
+# --- VOXCELEB MANIFEST (SPEAKER RECOGNITION) ---
+voxceleb_datasets = {
+    "voxceleb1" : {
+        "train": ["VoxCeleb1/wav"],
+        "test": ["VoxCeleb1/test_wav"]
+    },
+    "voxceleb2" : {
+        "train": ["VoxCeleb2/dev/aac"],
+        "test": ["VoxCeleb2/test_wav"]
+    }
+}
+
+# --- MISCELLANEOUS CORPORA ---
+other_datasets = [
+    "LJSpeech-1.1",
+    "VCTK-Corpus/wav48",
+]
+
+# --- LINGUISTIC CATEGORIZATION ---
+anglophone_nationalites = ["australia", "canada", "ireland", "uk", "usa"]

Source Code/encoder/data_objects/__init__.py

@@ -0,0 +1,29 @@
+# ==================================================================================================
+# DEEPFAKE AUDIO - encoder/data_objects/__init__.py (Data Layer Initialization)
+# ==================================================================================================
+# 
+# 📝 DESCRIPTION
+# This initialization script exposes the primary data orchestration classes for 
+# speaker verification. It facilitates structured access to datasets and 
+# loaders, abstraction layers that underpin the neural training pipeline.
+#
+# 👤 AUTHORS
+# - Amey Thakur (https://github.com/Amey-Thakur)
+# - Mega Satish (https://github.com/msatmod)
+#
+# 🤝🏻 CREDITS
+# Original Real-Time Voice Cloning methodology by CorentinJ
+# Repository: https://github.com/CorentinJ/Real-Time-Voice-Cloning
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Research: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================
+
+from encoder.data_objects.speaker_verification_dataset import SpeakerVerificationDataset
+from encoder.data_objects.speaker_verification_dataset import SpeakerVerificationDataLoader

Source Code/encoder/data_objects/random_cycler.py

@@ -0,0 +1,72 @@
+# ==================================================================================================
+# DEEPFAKE AUDIO - encoder/data_objects/random_cycler.py (Constrained Stochastic Iteration)
+# ==================================================================================================
+# 
+# 📝 DESCRIPTION
+# This utility provides a 'RandomCycler' class designed for uniform yet stochastic 
+# sampling of dataset items. It ensures that every item in a collection is 
+# seen with a guaranteed frequency, avoiding potential biases or 'starvation' 
+# during neural optimization steps while maintaining sufficient randomness.
+#
+# 👤 AUTHORS
+# - Amey Thakur (https://github.com/Amey-Thakur)
+# - Mega Satish (https://github.com/msatmod)
+#
+# 🤝🏻 CREDITS
+# Original Real-Time Voice Cloning methodology by CorentinJ
+# Repository: https://github.com/CorentinJ/Real-Time-Voice-Cloning
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Research: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================
+
+import random
+
+class RandomCycler:
+    """
+    Uniform Stochastic Sampler:
+    Maintains a sequence where each item is guaranteed to appear within a controlled 
+    interval, ensuring balanced categorical exposure during training.
+    """
+    def __init__(self, source):
+        if len(source) == 0:
+            raise Exception("Fatal: Cannot initialize RandomCycler with an empty collection.")
+        self.all_items = list(source)
+        self.next_items = []
+    
+    def sample(self, count: int):
+        """
+        Retrieves a 'count' number of items, replenishing and shuffling the internal 
+        pool as needed to maintain stochastisity without repetition within a cycle.
+        """
+        shuffle = lambda l: random.sample(l, len(l))
+        
+        out = []
+        while count > 0:
+            # High-Volume Requests
+            if count >= len(self.all_items):
+                out.extend(shuffle(list(self.all_items)))
+                count -= len(self.all_items)
+                continue
+            
+            # Partial Pool Refresh
+            n = min(count, len(self.next_items))
+            out.extend(self.next_items[:n])
+            count -= n
+            self.next_items = self.next_items[n:]
+            
+            if len(self.next_items) == 0:
+                self.next_items = shuffle(list(self.all_items))
+                
+        return out
+    
+    def __next__(self):
+        """Standard Python iterator hook for single-sample acquisition."""
+        return self.sample(1)[0]
+

Source Code/encoder/data_objects/speaker.py

@@ -0,0 +1,68 @@
+# ==================================================================================================
+# DEEPFAKE AUDIO - encoder/data_objects/speaker.py (Categorical Identity Representation)
+# ==================================================================================================
+# 
+# 📝 DESCRIPTION
+# This module implements the 'Speaker' abstraction, encapulating all linguistic 
+# and acoustic metadata for a single individual. It manages the retrieval 
+# and segmented sampling of utterances, acting as a gateway to the serialized 
+# Mel-Spectrograms used in neural distillation.
+#
+# 👤 AUTHORS
+# - Amey Thakur (https://github.com/Amey-Thakur)
+# - Mega Satish (https://github.com/msatmod)
+#
+# 🤝🏻 CREDITS
+# Original Real-Time Voice Cloning methodology by CorentinJ
+# Repository: https://github.com/CorentinJ/Real-Time-Voice-Cloning
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Research: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================
+
+from encoder.data_objects.random_cycler import RandomCycler
+from encoder.data_objects.utterance import Utterance
+from pathlib import Path
+
+class Speaker:
+    """
+    Categorical Data Container:
+    Aggregates all speech samples associated with a unique institutional speaker ID.
+    """
+    def __init__(self, root: Path):
+        self.root = root
+        self.name = root.name
+        self.utterances = None
+        self.utterance_cycler = None
+        
+    def _load_utterances(self):
+        """Lazy-loading of utterance metadata from the serialized index (_sources.txt)."""
+        with self.root.joinpath("_sources.txt").open("r") as sources_file:
+            sources = [l.split(",") for l in sources_file]
+        
+        # Identity Mapping: frames_fname -> original_wave_fpath
+        sources = {frames_fname: wave_fpath for frames_fname, wave_fpath in sources}
+        self.utterances = [Utterance(self.root.joinpath(f), w) for f, w in sources.items()]
+        self.utterance_cycler = RandomCycler(self.utterances)
+               
+    def random_partial(self, count, n_frames):
+        """
+        Samples a batch of <count> unique partial utterances.
+        Ensures diverse temporal coverage within the speaker's available vocal range.
+        """
+        if self.utterances is None:
+            self._load_utterances()
+
+        # Stochastic selection of utterances
+        utterances = self.utterance_cycler.sample(count)
+
+        # Spatio-temporal cropping: (utterance, frames, crop_range)
+        a = [(u,) + u.random_partial(n_frames) for u in utterances]
+
+        return a

Source Code/encoder/data_objects/speaker_batch.py

@@ -0,0 +1,46 @@
+# ==================================================================================================
+# DEEPFAKE AUDIO - encoder/data_objects/speaker_batch.py (Neural Batch Collation)
+# ==================================================================================================
+# 
+# 📝 DESCRIPTION
+# This module defines the SpeakerBatch class, which aggregates multiple speakers 
+# and their respective partial utterances into a unified tensor structure. It 
+# facilitates the high-throughput gradient descent cycles required for the 
+# GE2E loss optimization.
+#
+# 👤 AUTHORS
+# - Amey Thakur (https://github.com/Amey-Thakur)
+# - Mega Satish (https://github.com/msatmod)
+#
+# 🤝🏻 CREDITS
+# Original Real-Time Voice Cloning methodology by CorentinJ
+# Repository: https://github.com/CorentinJ/Real-Time-Voice-Cloning
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Research: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================
+
+import numpy as np
+from typing import List
+from encoder.data_objects.speaker import Speaker
+
+class SpeakerBatch:
+    """
+    Categorical Batch Orchestrator:
+    Collates acoustic data for B speakers, each with M utterances, into a 
+    consistent [B*M, T, C] matrix for neural ingestion.
+    """
+    def __init__(self, speakers: List[Speaker], utterances_per_speaker: int, n_frames: int):
+        self.speakers = speakers
+        
+        # Parallel Identity Sampling
+        self.partials = {s: s.random_partial(utterances_per_speaker, n_frames) for s in speakers}
+
+        # Sparse-to-Dense Materialization: (n_speakers * n_utterances, n_frames, mel_channels)
+        self.data = np.array([frames for s in speakers for _, frames, _ in self.partials[s]])

Source Code/encoder/data_objects/speaker_verification_dataset.py

@@ -0,0 +1,96 @@
+# ==================================================================================================
+# DEEPFAKE AUDIO - encoder/data_objects/speaker_verification_dataset.py (PyTorch Data Layer)
+# ==================================================================================================
+# 
+# 📝 DESCRIPTION
+# This module implements the PyTorch Dataset and DataLoader abstractions tailored 
+# for Speaker Verification. It manages the discovery of speaker directories, 
+# categorical sampling via RandomCycler, and high-performance batch collation.
+#
+# 👤 AUTHORS
+# - Amey Thakur (https://github.com/Amey-Thakur)
+# - Mega Satish (https://github.com/msatmod)
+#
+# 🤝🏻 CREDITS
+# Original Real-Time Voice Cloning methodology by CorentinJ
+# Repository: https://github.com/CorentinJ/Real-Time-Voice-Cloning
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Research: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================
+
+from encoder.data_objects.random_cycler import RandomCycler
+from encoder.data_objects.speaker_batch import SpeakerBatch
+from encoder.data_objects.speaker import Speaker
+from encoder.params_data import partials_n_frames
+from torch.utils.data import Dataset, DataLoader
+from pathlib import Path
+
+class SpeakerVerificationDataset(Dataset):
+    """
+    Neural Corpus Interface:
+    Scans a root directory for processed speaker identities and provides 
+    an infinite stochastic stream of categorical data.
+    """
+    def __init__(self, datasets_root: Path):
+        self.root = datasets_root
+        
+        # Identity Discovery
+        speaker_dirs = [f for f in self.root.glob("*") if f.is_dir()]
+        if len(speaker_dirs) == 0:
+            raise Exception("⚠️ Technical Alert: No speakers detected in %s." % self.root)
+        
+        self.speakers = [Speaker(speaker_dir) for speaker_dir in speaker_dirs]
+        self.speaker_cycler = RandomCycler(self.speakers)
+
+    def __len__(self):
+        """Returns a high constant to simulate an infinite stream for the DataLoader."""
+        return int(1e10)
+        
+    def __getitem__(self, index):
+        """Retrieves the next stochastic categorical identity."""
+        return next(self.speaker_cycler)
+    
+    def get_logs(self):
+        """Aggregates all preprocessing logs into a single analytical string."""
+        log_string = ""
+        for log_fpath in self.root.glob("*.txt"):
+            with log_fpath.open("r") as log_file:
+                log_string += "".join(log_file.readlines())
+        return log_string
+    
+class SpeakerVerificationDataLoader(DataLoader):
+    """
+    High-Throughput Orchestrator:
+    Custom DataLoader designed to yield SpeakerBatch objects containing 
+    diverse identities and utterances.
+    """
+    def __init__(self, dataset, speakers_per_batch, utterances_per_speaker, sampler=None, 
+                 batch_sampler=None, num_workers=0, pin_memory=False, timeout=0, 
+                 worker_init_fn=None):
+        self.utterances_per_speaker = utterances_per_speaker
+
+        super().__init__(
+            dataset=dataset, 
+            batch_size=speakers_per_batch, 
+            shuffle=False, 
+            sampler=sampler, 
+            batch_sampler=batch_sampler, 
+            num_workers=num_workers,
+            collate_fn=self.collate, # Custom collation for GE2E loss
+            pin_memory=pin_memory, 
+            drop_last=False, 
+            timeout=timeout, 
+            worker_init_fn=worker_init_fn
+        )
+
+    def collate(self, speakers):
+        """Constructs a SpeakerBatch from a set of sampled identities."""
+        return SpeakerBatch(speakers, self.utterances_per_speaker, partials_n_frames) 
+    

Source Code/encoder/data_objects/utterance.py

@@ -0,0 +1,59 @@
+# ==================================================================================================
+# DEEPFAKE AUDIO - encoder/data_objects/utterance.py (Vocal Unit Representation)
+# ==================================================================================================
+# 
+# 📝 DESCRIPTION
+# This module defines the 'Utterance' class, representing a single spoken phrase 
+# or acoustic segment. It provides mechanisms for loading preprocessed Mel-scale 
+# filterbanks from the disk and handles stochastic temporal cropping (random 
+# partials) to increase data variety during training.
+#
+# 👤 AUTHORS
+# - Amey Thakur (https://github.com/Amey-Thakur)
+# - Mega Satish (https://github.com/msatmod)
+#
+# 🤝🏻 CREDITS
+# Original Real-Time Voice Cloning methodology by CorentinJ
+# Repository: https://github.com/CorentinJ/Real-Time-Voice-Cloning
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Research: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================
+
+import numpy as np
+
+class Utterance:
+    """
+    Acoustic Data Container:
+    Manages the lifecycle of a single vocal sample, from disk retrieval to 
+    stochastic temporal segmentation.
+    """
+    def __init__(self, frames_fpath, wave_fpath):
+        self.frames_fpath = frames_fpath
+        self.wave_fpath = wave_fpath
+        
+    def get_frames(self):
+        """Deserializes the Mel-Spectrogram matrix from the filesystem."""
+        return np.load(self.frames_fpath)
+
+    def random_partial(self, n_frames):
+        """
+        Spatio-Temporal Cropping:
+        Cuts a random segment of 'n_frames' from the full utterance.
+        This technique acts as a form of temporal data augmentation.
+        """
+        frames = self.get_frames()
+        if frames.shape[0] == n_frames:
+            start = 0
+        else:
+            # Stochastic offset selection
+            start = np.random.randint(0, frames.shape[0] - n_frames)
+        
+        end = start + n_frames
+        return frames[start:end], (start, end)

Source Code/encoder/inference.py

@@ -0,0 +1,167 @@
+# ==================================================================================================
+# DEEPFAKE AUDIO - encoder/inference.py (Neural Identity Distillation Interface)
+# ==================================================================================================
+# 
+# 📝 DESCRIPTION
+# This module provides the high-level API for using the Speaker Encoder in a 
+# production environment. It encapsulates the complexities of model loading, 
+# tensor orchestration, and d-vector derivation. It is the primary bridge 
+# used by the web interface (app.py) to extract speaker identities from 
+# uploaded reference audio samples.
+#
+# 👤 AUTHORS
+# - Amey Thakur (https://github.com/Amey-Thakur)
+# - Mega Satish (https://github.com/msatmod)
+#
+# 🤝🏻 CREDITS
+# Original Real-Time Voice Cloning methodology by CorentinJ
+# Repository: https://github.com/CorentinJ/Real-Time-Voice-Cloning
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Research: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================
+
+from encoder.params_data import *
+from encoder.model import SpeakerEncoder
+from encoder.audio import preprocess_wav
+from matplotlib import cm
+from encoder import audio
+from pathlib import Path
+import numpy as np
+import torch
+
+# --- INTERNAL STATE (SINGLETON PATTERN) ---
+_model = None # type: SpeakerEncoder
+_device = None # type: torch.device
+
+def load_model(weights_fpath: Path, device=None):
+    """
+    Initializes the Speaker Encoder neural network.
+    Deserializes the PyTorch state dictionary and prepares the model for eval mode.
+    """
+    global _model, _device
+    
+    # Precise hardware targeting
+    if device is None:
+        _device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    elif isinstance(device, str):
+        _device = torch.device(device)
+    
+    # Constructing the architecture
+    _model = SpeakerEncoder(_device, torch.device("cpu"))
+    
+    # Loading serialized weights
+    checkpoint = torch.load(weights_fpath, map_location=_device, weights_only=False)
+    _model.load_state_dict(checkpoint["model_state"])
+    _model.eval()
+    
+    print("🤝🏻 Encoder Active: Loaded \"%s\" (Step %d)" % (weights_fpath.name, checkpoint["step"]))
+
+def is_loaded():
+    """Checks the initialization status of the neural engine."""
+    return _model is not None
+
+def embed_frames_batch(frames_batch):
+    """
+    Neural Forward Pass: Computes speaker embeddings for a batch of spectrograms.
+    Returns l2-normalized d-vectors.
+    """
+    if _model is None:
+        raise Exception("Fatal: Neural Encoder is not initialized. Invoke load_model().")
+
+    frames = torch.from_numpy(frames_batch).to(_device)
+    embed = _model.forward(frames).detach().cpu().numpy()
+    return embed
+
+def compute_partial_slices(n_samples, partial_utterance_n_frames=partials_n_frames,
+                           min_pad_coverage=0.75, overlap=0.5):
+    """
+    Spatio-Temporal Segmentation: Defines how a long utterance is sliced into 
+    overlapping windows for stable embedding derivation.
+    """
+    assert 0 <= overlap < 1
+    assert 0 < min_pad_coverage <= 1
+
+    samples_per_frame = int((sampling_rate * mel_window_step / 1000))
+    n_frames = int(np.ceil((n_samples + 1) / samples_per_frame))
+    frame_step = max(int(np.round(partial_utterance_n_frames * (1 - overlap))), 1)
+
+    # Window Orchestration
+    wav_slices, mel_slices = [], []
+    steps = max(1, n_frames - partial_utterance_n_frames + frame_step + 1)
+    for i in range(0, steps, frame_step):
+        mel_range = np.array([i, i + partial_utterance_n_frames])
+        wav_range = mel_range * samples_per_frame
+        mel_slices.append(slice(*mel_range))
+        wav_slices.append(slice(*wav_range))
+
+    # Defensive Padding Evaluation
+    last_wav_range = wav_slices[-1]
+    coverage = (n_samples - last_wav_range.start) / (last_wav_range.stop - last_wav_range.start)
+    if coverage < min_pad_coverage and len(mel_slices) > 1:
+        mel_slices = mel_slices[:-1]
+        wav_slices = wav_slices[:-1]
+
+    return wav_slices, mel_slices
+
+def embed_utterance(wav, using_partials=True, return_partials=False, **kwargs):
+    """
+    Core Identity Extraction: Distills a processed waveform into a single 
+    256-dimensional identity vector (d-vector).
+    """
+    # 1. Full-Waveform Processing (Fallback for short utterances)
+    if not using_partials:
+        frames = audio.wav_to_mel_spectrogram(wav)
+        embed = embed_frames_batch(frames[None, ...])[0]
+        if return_partials:
+            return embed, None, None
+        return embed
+
+    # 2. Windowed Distillation
+    wave_slices, mel_slices = compute_partial_slices(len(wav), **kwargs)
+    max_wave_length = wave_slices[-1].stop
+    if max_wave_length >= len(wav):
+        wav = np.pad(wav, (0, max_wave_length - len(wav)), "constant")
+
+    # 3. Batch Inference on Windows
+    frames = audio.wav_to_mel_spectrogram(wav)
+    frames_batch = np.array([frames[s] for s in mel_slices])
+    partial_embeds = embed_frames_batch(frames_batch)
+
+    # 4. Statistical Averaging & Re-Normalization
+    raw_embed = np.mean(partial_embeds, axis=0)
+    embed = raw_embed / np.linalg.norm(raw_embed, 2)
+
+    if return_partials:
+        return embed, partial_embeds, wave_slices
+    return embed
+
+def embed_speaker(wavs, **kwargs):
+    """Aggregate identity extraction for multiple utterances from the same speaker."""
+    raise NotImplementedError("Collaborative development in progress for multi-wav aggregation.")
+
+def plot_embedding_as_heatmap(embed, ax=None, title="", shape=None, color_range=(0, 0.30)):
+    """Visualizes the high-dimensional latent vector as a spatial intensity map."""
+    import matplotlib.pyplot as plt
+    if ax is None:
+        ax = plt.gca()
+
+    if shape is None:
+        height = int(np.sqrt(len(embed)))
+        shape = (height, -1)
+    embed = embed.reshape(shape)
+
+    cmap = plt.get_cmap()
+    mappable = ax.imshow(embed, cmap=cmap)
+    cbar = plt.colorbar(mappable, ax=ax, fraction=0.046, pad=0.04)
+    sm = cm.ScalarMappable(cmap=cmap)
+    sm.set_clim(*color_range)
+
+    ax.set_xticks([]), ax.set_yticks([])
+    ax.set_title(title)

Source Code/encoder/model.py

@@ -0,0 +1,152 @@
+# ==================================================================================================
+# DEEPFAKE AUDIO - encoder/model.py (Neural Architecture Definition)
+# ==================================================================================================
+# 
+# 📝 DESCRIPTION
+# This module defines the SpeakerEncoder class, a three-layer LSTM-based neural 
+# network inspired by the 'Generalized End-to-End Loss for Speaker Verification' 
+# research. It maps variable-length speech features into fixed-dimensional 
+# embeddings (d-vectors) that represent the unique vocal characteristics of the 
+# speaker, enabling zero-shot voice cloning.
+#
+# 👤 AUTHORS
+# - Amey Thakur (https://github.com/Amey-Thakur)
+# - Mega Satish (https://github.com/msatmod)
+#
+# 🤝🏻 CREDITS
+# Original Real-Time Voice Cloning methodology by CorentinJ
+# Repository: https://github.com/CorentinJ/Real-Time-Voice-Cloning
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Research: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================
+
+from encoder.params_model import *
+from encoder.params_data import *
+from scipy.interpolate import interp1d
+from sklearn.metrics import roc_curve
+from torch.nn.utils import clip_grad_norm_
+from scipy.optimize import brentq
+from torch import nn
+import numpy as np
+import torch
+
+class SpeakerEncoder(nn.Module):
+    """
+    Spatio-Temporal Identity Extractor:
+    An LSTM architecture designed to condense acoustic feature sequences into 
+    latent speaker representations.
+    """
+    def __init__(self, device, loss_device):
+        super().__init__()
+        self.loss_device = loss_device
+        
+        # --- RECURRENT BACKBONE ---
+        # Multi-layer LSTM to capture temporal acoustic dependencies.
+        self.lstm = nn.LSTM(input_size=mel_n_channels,
+                            hidden_size=model_hidden_size, 
+                            num_layers=model_num_layers, 
+                            batch_first=True).to(device)
+        
+        # --- PROJECTION LAYER ---
+        # Maps the final hidden state to the d-vector space.
+        self.linear = nn.Linear(in_features=model_hidden_size, 
+                                out_features=model_embedding_size).to(device)
+        self.relu = torch.nn.ReLU().to(device)
+        
+        # --- COSINE SIMILARITY SCALE & BIAS ---
+        # Learnable parameters to transform cosine similarities into optimized logit ranges.
+        self.similarity_weight = nn.Parameter(torch.tensor([10.])).to(loss_device)
+        self.similarity_bias = nn.Parameter(torch.tensor([-5.])).to(loss_device)
+
+        # Optimization Criterion
+        self.loss_fn = nn.CrossEntropyLoss().to(loss_device)
+        
+    def do_gradient_ops(self):
+        """Manages gradient scaling and norm clipping for stable training dynamics."""
+        # Sensitivity reduction for similarity parameters
+        self.similarity_weight.grad *= 0.01
+        self.similarity_bias.grad *= 0.01
+            
+        # Global Gradient Constraint
+        clip_grad_norm_(self.parameters(), 3, norm_type=2)
+    
+    def forward(self, utterances, hidden_init=None):
+        """
+        Neural Distillation:
+        Processes a batch of mel-spectrograms [B, T, C] and returns d-vectors [B, E].
+        """
+        # Sequential temporal extraction
+        out, (hidden, cell) = self.lstm(utterances, hidden_init)
+        
+        # State aggregation: Extract identity from the final LSTM layer's last state
+        embeds_raw = self.relu(self.linear(hidden[-1]))
+        
+        # L2-Normalization: Project onto the identity hypersphere (unit length)
+        embeds = embeds_raw / (torch.norm(embeds_raw, dim=1, keepdim=True) + 1e-5)        
+
+        return embeds
+    
+    def similarity_matrix(self, embeds):
+        """
+        Geometric Contrast: Computes the GE2E similarity matrix.
+        Quantifies the proximity of d-vectors to speaker centroids.
+        """
+        speakers_per_batch, utterances_per_speaker = embeds.shape[:2]
+        
+        # Inclusive centroids: Mean identity representation per speaker
+        centroids_incl = torch.mean(embeds, dim=1, keepdim=True)
+        centroids_incl = centroids_incl.clone() / (torch.norm(centroids_incl, dim=2, keepdim=True) + 1e-5)
+
+        # Exclusive centroids: LOO (Leave-One-Out) means to avoid biased similarity scoring
+        centroids_excl = (torch.sum(embeds, dim=1, keepdim=True) - embeds)
+        centroids_excl /= (utterances_per_speaker - 1)
+        centroids_excl = centroids_excl.clone() / (torch.norm(centroids_excl, dim=2, keepdim=True) + 1e-5)
+
+        # Similarity calculation via Dot Product (efficient Cosine Similarity equivalent)
+        sim_matrix = torch.zeros(speakers_per_batch, utterances_per_speaker,
+                                 speakers_per_batch).to(self.loss_device)
+        mask_matrix = 1 - np.eye(speakers_per_batch, dtype=int)
+        for j in range(speakers_per_batch):
+            mask = np.where(mask_matrix[j])[0]
+            sim_matrix[mask, :, j] = (embeds[mask] * centroids_incl[j]).sum(dim=2)
+            sim_matrix[j, :, j] = (embeds[j] * centroids_excl[j]).sum(dim=1)
+        
+        # Scaling towards cross-entropy optimization
+        sim_matrix = sim_matrix * self.similarity_weight + self.similarity_bias
+        return sim_matrix
+    
+    def loss(self, embeds):
+        """
+        Discriminant Optimization:
+        Computes GE2E Softmax Loss and monitors Equal Error Rate (EER).
+        """
+        speakers_per_batch, utterances_per_speaker = embeds.shape[:2]
+        
+        # Global Similarity Awareness
+        sim_matrix = self.similarity_matrix(embeds)
+        sim_matrix = sim_matrix.reshape((speakers_per_batch * utterances_per_speaker, 
+                                         speakers_per_batch))
+        
+        # Target Generation (Diagonal Mapping)
+        ground_truth = np.repeat(np.arange(speakers_per_batch), utterances_per_speaker)
+        target = torch.from_numpy(ground_truth).long().to(self.loss_device)
+        loss = self.loss_fn(sim_matrix, target)
+        
+        # Equal Error Rate (Diagnostic Telemetry)
+        with torch.no_grad():
+            inv_argmax = lambda i: np.eye(1, speakers_per_batch, i, dtype=int)[0]
+            labels = np.array([inv_argmax(i) for i in ground_truth])
+            preds = sim_matrix.detach().cpu().numpy()
+
+            # Statistical Error Estimation
+            fpr, tpr, thresholds = roc_curve(labels.flatten(), preds.flatten())           
+            eer = brentq(lambda x: 1. - x - interp1d(fpr, tpr)(x), 0., 1.)
+            
+        return loss, eer

Source Code/encoder/params_data.py

@@ -0,0 +1,47 @@
+# ==================================================================================================
+# DEEPFAKE AUDIO - encoder/params_data.py (Acoustic Feature Hyperparameters)
+# ==================================================================================================
+# 
+# 📝 DESCRIPTION
+# This configuration module defines the signal processing constants for the 
+# speaker encoder. It standardizes window lengths, sampling rates, and VAD 
+# sensitivities, ensuring consistency between training data preparation and 
+# real-time inference.
+#
+# 👤 AUTHORS
+# - Amey Thakur (https://github.com/Amey-Thakur)
+# - Mega Satish (https://github.com/msatmod)
+#
+# 🤝🏻 CREDITS
+# Original Real-Time Voice Cloning methodology by CorentinJ
+# Repository: https://github.com/CorentinJ-Real-Time-Voice-Cloning
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Research: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================
+
+# --- MEL-FILTERBANK CONFIGURATION ---
+mel_window_length = 25  # Spectral analysis window (ms)
+mel_window_step = 10    # Temporal stride between windows (ms)
+mel_n_channels = 40     # Number of mel-scale frequency bins
+
+# --- AUDIO TEMPORAL RESOLUTION ---
+sampling_rate = 16000      # Global acoustic sampling frequency (Hz)
+partials_n_frames = 160    # Sequence length for training utterances (1.6s)
+inference_n_frames = 80    # Minimal sequence length for identity derivation (0.8s)
+
+# --- VOICE ACTIVITY DETECTION (VAD) ---
+# Sensitivity parameters for distinguishing speech from silence.
+vad_window_length = 30         # Temporal resolution of VAD decisions (ms)
+vad_moving_average_width = 8   # Smoothing factor for binary speech decisions
+vad_max_silence_length = 6     # Maximum allowed internal silence gap before segmentation
+
+# --- AMPLITUDE NORMALIZATION ---
+audio_norm_target_dBFS = -30   # Target spectral energy level in Decibels
+

Source Code/encoder/params_model.py

@@ -0,0 +1,37 @@
+# ==================================================================================================
+# DEEPFAKE AUDIO - encoder/params_model.py (Neural Hyperparameters)
+# ==================================================================================================
+# 
+# 📝 DESCRIPTION
+# This module defines the architectural and optimization hyperparameters for 
+# the Speaker Encoder. These values determine the depth of the LSTM backbone, 
+# the dimensionality of the identity manifold (d-vector space), and the data 
+# orchestrations (batch size) required for training stability.
+#
+# 👤 AUTHORS
+# - Amey Thakur (https://github.com/Amey-Thakur)
+# - Mega Satish (https://github.com/msatmod)
+#
+# 🤝🏻 CREDITS
+# Original Real-Time Voice Cloning methodology by CorentinJ
+# Repository: https://github.com/CorentinJ/Real-Time-Voice-Cloning
+#
+# 🔗 PROJECT LINKS
+# Repository: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO
+# Video Demo: https://youtu.be/i3wnBcbHDbs
+# Research: https://github.com/Amey-Thakur/DEEPFAKE-AUDIO/blob/main/DEEPFAKE-AUDIO.ipynb
+#
+# 📜 LICENSE
+# Released under the MIT License
+# Release Date: 2021-02-06
+# ==================================================================================================
+
+# --- ARCHITECTURUAL DIMENSIONS ---
+model_hidden_size = 256        # LSTM hidden state capacity
+model_embedding_size = 256     # Final identity vector (d-vector) dimensionality
+model_num_layers = 3           # Depth of the recurrent stack
+
+# --- OPTIMIZATION ORCHESTRATION ---
+learning_rate_init = 1e-4      # Initial stochastic gradient descent scaling
+speakers_per_batch = 64        # Categorical diversity per optimization step
+utterances_per_speaker = 10    # Sample diversity per categorical identity