FakeYou_Español_Tacotron2_Formación.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "private_outputs": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/rmcpantoja/FakeYou-Tacotron2-Notebook/blob/main/FakeYou_Espa%C3%B1ol_Tacotron2_Formaci%C3%B3n.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# <b><font color=\"pink\" size=\"+2\"> **FakeYou Tacotron 2: Cuaderno Colab de entrenamiento en español.**\n",
        "___\n",
        "\n",
        "#### **Sigue los pasos, ejecutando las celdas en orden para un funcionamiento correcto.**\n",
        "\n",
        "___\n",
        "\n",
        "Última actualización: 19/12/2023<br>\n",
        "Novedades: Más indicaciones exactas de uso del cuaderno y textos mejorados.\n",
        "\n",
        "---\n",
        "\n",
        "### Repositorio de [Tacotron 2.](https://github.com/NVIDIA/tacotron2)\n",
        "\n",
        "---\n",
        "<a href=\"https://fakeyou.com/\"><img src=\"https://fakeyou.com/fakeyou/FakeYou-Logo.png\" alt=\"FakeYou Logo. Clickea para ir a la web oficial.\"></a>\n",
        "\n",
        "---\n",
        "\n",
        "### **Descargo de responsabilidad:**  Puede encontrar dificultades al subir archivos (> 1MB) si utiliza Firefox.\n",
        "---\n",
        "\n",
        "## 🤝**Créditos**🤝\n",
        "Código creado originalmente por `CookieGalaxy#8351` para el Proyecto de Preservación de Ponis\n",
        "\n",
        "Cuaderno Colab elaborado por `justinjohn-03`\n",
        "\n",
        "Correcciones y mejoras por `rmcpantoja` y `Xx_Nessu_xX`.\n",
        "\n",
        "Un agradecimiento especial a `mega b#6696`, `oJoão#3244`, `Cris140#6815` y `RanmaAR`\n",
        "\n",
        "---\n",
        "\n",
        "## **Notas:**\n",
        "\n",
        "- <font color=\"orange\">**Las cosas en naranja significa que son importantes.**"
      ],
      "metadata": {
        "id": "MdG3MY0Xo4ss"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#📚 <font color=\"pink\"> ***Preparación.*** 📚"
      ],
      "metadata": {
        "id": "1mcEohGLalzo"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "75SFQOP_Wnpz",
        "cellView": "form"
      },
      "source": [
        "#@markdown ## <font color=\"pink\"> **Comprueba la GPU.** 👁️ </font>\n",
        "#@markdown ---\n",
        "#@markdown #### Por defecto obtendrás una  <font color=\"orange\">**Tesla 4**</font>. Con esta basta suficiente para hacer un buen entrenamiento.\n",
        "\n",
        "!nvidia-smi -L"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown ## <font color=\"pink\"> **Google Colab Anti-Disconnect.** 🔌\n",
        "#@markdown ---\n",
        "#@markdown #### Evita la desconexión automática. Aun así, se desconectará después de <font color=\"orange\">**6 a 12 horas**</font>.\n",
        "\n",
        "import IPython\n",
        "js_code = '''\n",
        "function ClickConnect(){\n",
        "console.log(\"Working\");\n",
        "document.querySelector(\"colab-toolbar-button#connect\").click()\n",
        "}\n",
        "setInterval(ClickConnect,60000)\n",
        "'''\n",
        "display(IPython.display.Javascript(js_code))"
      ],
      "metadata": {
        "id": "q1uBxHKNXZxY",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OhZSeuWHoj6g"
      },
      "source": [
        "\n",
        "# <font color=\"pink\">🤖 ***Entrenamiento.*** </font> 🤖"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z6aq6vRzqEV9",
        "cellView": "form"
      },
      "source": [
        "#@markdown ## <font color=\"pink\"> **1. Monta tu Google Drive.** 📂\n",
        "#@markdown ---\n",
        "#Token de autenticación de Google Drive\n",
        "from google.colab import drive\n",
        "drive.mount('drive', force_remount=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c6zQ-DWo4lcs",
        "cellView": "form"
      },
      "source": [
        "#@markdown ## <font color=\"pink\"> **2. Instalar Tacotron 2 y sus dependencias.**  📦\n",
        "#@markdown ---\n",
        "%cd /content/\n",
        "!pip install pydub\n",
        "from pydub import AudioSegment\n",
        "import os\n",
        "from os.path import exists\n",
        "import sys\n",
        "!pip install phonemizer\n",
        "!pip install ffmpeg-normalize\n",
        "!pip install git+https://github.com/IAHispano/gdown.git\n",
        "!git clone -q https://github.com/rmcpantoja/tacotron2.git\n",
        "sys.path.append('tacotron2')\n",
        "%cd content/tacotron2\n",
        "!git clone -q --recursive https://github.com/justinjohn0306/hifi-gan\n",
        "sys.path.append('hifi-gan')\n",
        "!pip install git+https://github.com/savoirfairelinux/num2words\n",
        "!git submodule init\n",
        "!git submodule update\n",
        "!pip install matplotlib numpy inflect librosa scipy unidecode pillow tensorboardX resampy\n",
        "!apt-get install pv\n",
        "!apt-get -qq install sox\n",
        "!apt-get install jq\n",
        "!wget https://raw.githubusercontent.com/tonikelope/megadown/master/megadown -O megadown.sh\n",
        "!chmod 755 megadown.sh\n",
        "\n",
        "%matplotlib inline\n",
        "\n",
        "import IPython.display as ipd\n",
        "import json\n",
        "from layers import TacotronSTFT\n",
        "from audio_processing import griffin_lim\n",
        "from env import AttrDict\n",
        "from meldataset import mel_spectrogram, MAX_WAV_VALUE\n",
        "from models import Generator\n",
        "from denoiser import Denoiser\n",
        "import resampy\n",
        "import scipy.signal\n",
        "\n",
        "import os\n",
        "if os.getcwd() != '/content/tacotron2':\n",
        "    os.chdir('tacotron2')\n",
        "import time\n",
        "import argparse\n",
        "import math\n",
        "from numpy import finfo\n",
        "\n",
        "import torch\n",
        "from distributed import apply_gradient_allreduce\n",
        "import torch.distributed as dist\n",
        "from torch.utils.data.distributed import DistributedSampler\n",
        "from torch.utils.data import DataLoader\n",
        "\n",
        "from model import Tacotron2\n",
        "from data_utils import TextMelLoader, TextMelCollate\n",
        "from loss_function import Tacotron2Loss\n",
        "from logger import Tacotron2Logger\n",
        "from hparams import create_hparams\n",
        "\n",
        "import random\n",
        "import numpy as np\n",
        "\n",
        "import layers\n",
        "from utils import load_wav_to_torch, load_filepaths_and_text\n",
        "from text import text_to_sequence\n",
        "from math import e\n",
        "#from tqdm import tqdm # Terminal\n",
        "#from tqdm import tqdm_notebook as tqdm # Legacy Notebook TQDM\n",
        "from tqdm.notebook import tqdm # Modern Notebook TQDM\n",
        "from distutils.dir_util import copy_tree\n",
        "import matplotlib.pylab as plt\n",
        "\n",
        "%cd /content/\n",
        "def get_hifigan(MODEL_ID, conf_name):\n",
        "    # Download HiFi-GAN\n",
        "    hifigan_pretrained_model = 'hifimodel_' + conf_name\n",
        "    #gdown.download(d+MODEL_ID, hifigan_pretrained_model, quiet=False)\n",
        "\n",
        "    if MODEL_ID == \"universal\":\n",
        "      !wget \"https://github.com/johnpaulbin/tacotron2/releases/download/Main/g_02500000\" -O $hifigan_pretrained_model\n",
        "    else:\n",
        "      !gdown --id \"$MODEL_ID\" -O $hifigan_pretrained_model\n",
        "\n",
        "    # Load HiFi-GAN\n",
        "    conf = os.path.join(\"hifi-gan\", conf_name + \".json\")\n",
        "    with open(conf) as f:\n",
        "        json_config = json.loads(f.read())\n",
        "    h = AttrDict(json_config)\n",
        "    torch.manual_seed(h.seed)\n",
        "    hifigan = Generator(h).to(torch.device(\"cuda\"))\n",
        "    state_dict_g = torch.load(hifigan_pretrained_model, map_location=torch.device(\"cuda\"))\n",
        "    hifigan.load_state_dict(state_dict_g[\"generator\"])\n",
        "    hifigan.eval()\n",
        "    hifigan.remove_weight_norm()\n",
        "    denoiser = Denoiser(hifigan, mode=\"normal\")\n",
        "    return hifigan, h, denoiser\n",
        "\n",
        "# Download character HiFi-GAN\n",
        "hifigan, h, denoiser = get_hifigan(\"universal\", \"config_v1\")\n",
        "# Download super-resolution HiFi-GAN\n",
        "hifigan_sr, h2, denoiser_sr = get_hifigan(\"14fOprFAIlCQkVRxsfInhEPG0n-xN4QOa\", \"config_32k\")\n",
        "\n",
        "%cd /content/tacotron2\n",
        "\n",
        "def download_from_google_drive(file_id, file_name):\n",
        "  # download a file from the Google Drive link\n",
        "  !rm -f ./cookie\n",
        "  !curl -c ./cookie -s -L \"https://drive.google.com/uc?export=download&id={file_id}\" > /dev/null\n",
        "  confirm_text = !awk '/download/ {print $NF}' ./cookie\n",
        "  confirm_text = confirm_text[0]\n",
        "  !curl -Lb ./cookie \"https://drive.google.com/uc?export=download&confirm={confirm_text}&id={file_id}\" -o {file_name}\n",
        "\n",
        "def create_mels():\n",
        "    print(\"Generating Mels\")\n",
        "    stft = layers.TacotronSTFT(\n",
        "                hparams.filter_length, hparams.hop_length, hparams.win_length,\n",
        "                hparams.n_mel_channels, hparams.sampling_rate, hparams.mel_fmin,\n",
        "                hparams.mel_fmax)\n",
        "    def save_mel(filename):\n",
        "        audio, sampling_rate = load_wav_to_torch(filename)\n",
        "        if sampling_rate != stft.sampling_rate:\n",
        "            raise ValueError(\"{} {} SR does not match the objective {} SR\".format(filename,\n",
        "                sampling_rate, stft.sampling_rate))\n",
        "        audio_norm = audio / hparams.max_wav_value\n",
        "        audio_norm = audio_norm.unsqueeze(0)\n",
        "        audio_norm = torch.autograd.Variable(audio_norm, requires_grad=False)\n",
        "        melspec = stft.mel_spectrogram(audio_norm)\n",
        "        melspec = torch.squeeze(melspec, 0).cpu().numpy()\n",
        "        np.save(filename.replace('.wav', ''), melspec)\n",
        "\n",
        "    import glob\n",
        "    wavs = glob.glob('wavs/*.wav')\n",
        "    for i in tqdm(wavs):\n",
        "        save_mel(i)\n",
        "\n",
        "\n",
        "def reduce_tensor(tensor, n_gpus):\n",
        "    rt = tensor.clone()\n",
        "    dist.all_reduce(rt, op=dist.reduce_op.SUM)\n",
        "    rt /= n_gpus\n",
        "    return rt\n",
        "\n",
        "\n",
        "def init_distributed(hparams, n_gpus, rank, group_name):\n",
        "    assert torch.cuda.is_available(), \"Distributed mode requires CUDA.\"\n",
        "    print(\"Initializing Distributed\")\n",
        "\n",
        "    # Set cuda device so everything is done on the right GPU.\n",
        "    torch.cuda.set_device(rank % torch.cuda.device_count())\n",
        "\n",
        "    # Initialize distributed communication\n",
        "    dist.init_process_group(\n",
        "        backend=hparams.dist_backend, init_method=hparams.dist_url,\n",
        "        world_size=n_gpus, rank=rank, group_name=group_name)\n",
        "\n",
        "    print(\"Done initializing distributed\")\n",
        "\n",
        "\n",
        "def prepare_dataloaders(hparams):\n",
        "    # Get data, data loaders and collate function ready\n",
        "    trainset = TextMelLoader(hparams.training_files, hparams)\n",
        "    valset = TextMelLoader(hparams.validation_files, hparams)\n",
        "    collate_fn = TextMelCollate(hparams.n_frames_per_step)\n",
        "\n",
        "    if hparams.distributed_run:\n",
        "        train_sampler = DistributedSampler(trainset)\n",
        "        shuffle = False\n",
        "    else:\n",
        "        train_sampler = None\n",
        "        shuffle = True\n",
        "\n",
        "    train_loader = DataLoader(trainset, num_workers=1, shuffle=shuffle,\n",
        "                              sampler=train_sampler,\n",
        "                              batch_size=hparams.batch_size, pin_memory=False,\n",
        "                              drop_last=True, collate_fn=collate_fn)\n",
        "    return train_loader, valset, collate_fn\n",
        "\n",
        "\n",
        "def prepare_directories_and_logger(output_directory, log_directory, rank):\n",
        "    if rank == 0:\n",
        "        if not os.path.isdir(output_directory):\n",
        "            os.makedirs(output_directory)\n",
        "            os.chmod(output_directory, 0o775)\n",
        "        logger = Tacotron2Logger(os.path.join(output_directory, log_directory))\n",
        "    else:\n",
        "        logger = None\n",
        "    return logger\n",
        "\n",
        "\n",
        "def load_model(hparams):\n",
        "    model = Tacotron2(hparams).cuda()\n",
        "    if hparams.fp16_run:\n",
        "        model.decoder.attention_layer.score_mask_value = finfo('float16').min\n",
        "\n",
        "    if hparams.distributed_run:\n",
        "        model = apply_gradient_allreduce(model)\n",
        "\n",
        "    return model\n",
        "\n",
        "\n",
        "def warm_start_model(checkpoint_path, model, ignore_layers):\n",
        "    assert os.path.isfile(checkpoint_path)\n",
        "    print(\"Warm starting model from checkpoint '{}'\".format(checkpoint_path))\n",
        "    checkpoint_dict = torch.load(checkpoint_path, map_location='cpu')\n",
        "    model_dict = checkpoint_dict['state_dict']\n",
        "    if len(ignore_layers) > 0:\n",
        "        model_dict = {k: v for k, v in model_dict.items()\n",
        "                      if k not in ignore_layers}\n",
        "        dummy_dict = model.state_dict()\n",
        "        dummy_dict.update(model_dict)\n",
        "        model_dict = dummy_dict\n",
        "    model.load_state_dict(model_dict)\n",
        "    return model\n",
        "\n",
        "\n",
        "def load_checkpoint(checkpoint_path, model, optimizer):\n",
        "    assert os.path.isfile(checkpoint_path)\n",
        "    print(\"Loading checkpoint '{}'\".format(checkpoint_path))\n",
        "    checkpoint_dict = torch.load(checkpoint_path, map_location='cpu')\n",
        "    model.load_state_dict(checkpoint_dict['state_dict'])\n",
        "    optimizer.load_state_dict(checkpoint_dict['optimizer'])\n",
        "    learning_rate = checkpoint_dict['learning_rate']\n",
        "    iteration = checkpoint_dict['iteration']\n",
        "    print(\"Loaded checkpoint '{}' from iteration {}\" .format(\n",
        "        checkpoint_path, iteration))\n",
        "    return model, optimizer, learning_rate, iteration\n",
        "\n",
        "def save_checkpoint(model, optimizer, learning_rate, iteration, filepath):\n",
        "    print(\"Saving model and optimizer state at iteration {} to {}\".format(\n",
        "        iteration, filepath))\n",
        "    try:\n",
        "        torch.save({'iteration': iteration,\n",
        "                'state_dict': model.state_dict(),\n",
        "                'optimizer': optimizer.state_dict(),\n",
        "                'learning_rate': learning_rate}, filepath)\n",
        "    except KeyboardInterrupt:\n",
        "        print(\"interrupt received while saving, waiting for save to complete.\")\n",
        "        torch.save({'iteration': iteration,'state_dict': model.state_dict(),'optimizer': optimizer.state_dict(),'learning_rate': learning_rate}, filepath)\n",
        "    print(\"Model Saved\")\n",
        "\n",
        "def plot_alignment(alignment, info=None):\n",
        "    %matplotlib inline\n",
        "    fig, ax = plt.subplots(figsize=(int(alignment_graph_width/100), int(alignment_graph_height/100)))\n",
        "    im = ax.imshow(alignment, cmap='inferno', aspect='auto', origin='lower',\n",
        "                   interpolation='none')\n",
        "    ax.autoscale(enable=True, axis=\"y\", tight=True)\n",
        "    fig.colorbar(im, ax=ax)\n",
        "    xlabel = 'Decoder timestep'\n",
        "    if info is not None:\n",
        "        xlabel += '\\n\\n' + info\n",
        "    plt.xlabel(xlabel)\n",
        "    plt.ylabel('Encoder timestep')\n",
        "    plt.tight_layout()\n",
        "    fig.canvas.draw()\n",
        "    plt.show()\n",
        "\n",
        "def validate(model, criterion, valset, iteration, batch_size, n_gpus,\n",
        "             collate_fn, logger, distributed_run, rank, epoch, start_eposh, learning_rate, sample_interbal, save_audio = False, audio_path = None):\n",
        "    \"\"\"Handles all the validation scoring and printing\"\"\"\n",
        "    model.eval()\n",
        "    with torch.no_grad():\n",
        "        val_sampler = DistributedSampler(valset) if distributed_run else None\n",
        "        val_loader = DataLoader(valset, sampler=val_sampler, num_workers=1,\n",
        "                                shuffle=False, batch_size=batch_size,\n",
        "                                pin_memory=False, collate_fn=collate_fn)\n",
        "\n",
        "        val_loss = 0.0\n",
        "        for i, batch in enumerate(val_loader):\n",
        "            x, y = model.parse_batch(batch)\n",
        "            y_pred = model(x)\n",
        "            loss = criterion(y_pred, y)\n",
        "            if distributed_run:\n",
        "                reduced_val_loss = reduce_tensor(loss.data, n_gpus).item()\n",
        "            else:\n",
        "                reduced_val_loss = loss.item()\n",
        "            val_loss += reduced_val_loss\n",
        "        val_loss = val_loss / (i + 1)\n",
        "\n",
        "    model.train()\n",
        "    if rank == 0:\n",
        "        print(\"Epoch: {} Validation loss {}: {:9f}  Time: {:.1f}m LR: {:.6f}\".format(epoch, iteration, val_loss,(time.perf_counter()-start_eposh)/60, learning_rate))\n",
        "        logger.log_validation(val_loss, model, y, y_pred, iteration)\n",
        "        if hparams.show_alignments:\n",
        "            %matplotlib inline\n",
        "            _, mel_outputs, gate_outputs, alignments = y_pred\n",
        "            idx = random.randint(0, alignments.size(0) - 1)\n",
        "            plot_alignment(alignments[idx].data.cpu().numpy().T)\n",
        "\n",
        "    dv = epoch/sample_interbal\n",
        "    if dv.is_integer():\n",
        "      print(f\"Generación de muestras... \\n{sampletext}\")\n",
        "      for i in [x for x in sampletext.split(\"\\n\") if len(x)]:\n",
        "          if i[-1] != \";\": i=i+\";\"\n",
        "          with torch.no_grad():\n",
        "              sequence = np.array(text_to_sequence(i, ['basic_cleaners']))[None, :]\n",
        "              sequence = torch.autograd.Variable(torch.from_numpy(sequence)).cuda().long()\n",
        "              mel_outputs, mel_outputs_postnet, _, alignments = model.inference(sequence)\n",
        "              y_g_hat = hifigan(mel_outputs_postnet.float())\n",
        "              audio = y_g_hat.squeeze()\n",
        "              audio = audio * MAX_WAV_VALUE\n",
        "              audio_denoised = denoiser(audio.view(1, -1), strength=35)[:, 0]\n",
        "\n",
        "              # Resample to 32k\n",
        "              audio_denoised = audio_denoised.cpu().numpy().reshape(-1)\n",
        "\n",
        "              normalize = (MAX_WAV_VALUE / np.max(np.abs(audio_denoised))) ** 0.9\n",
        "              audio_denoised = audio_denoised * normalize\n",
        "              wave = resampy.resample(\n",
        "                  audio_denoised,\n",
        "                  h.sampling_rate,\n",
        "                  h2.sampling_rate,\n",
        "                  filter=\"sinc_window\",\n",
        "                  window=scipy.signal.windows.hann,\n",
        "                  num_zeros=8,\n",
        "              )\n",
        "              wave_out = wave.astype(np.int16)\n",
        "\n",
        "              # HiFi-GAN super-resolution\n",
        "              wave = wave / MAX_WAV_VALUE\n",
        "              wave = torch.FloatTensor(wave).to(torch.device(\"cuda\"))\n",
        "              new_mel = mel_spectrogram(\n",
        "                  wave.unsqueeze(0),\n",
        "                  h2.n_fft,\n",
        "                  h2.num_mels,\n",
        "                  h2.sampling_rate,\n",
        "                  h2.hop_size,\n",
        "                  h2.win_size,\n",
        "                  h2.fmin,\n",
        "                  h2.fmax,\n",
        "              )\n",
        "              y_g_hat2 = hifigan_sr(new_mel)\n",
        "              audio2 = y_g_hat2.squeeze()\n",
        "              audio2 = audio2 * MAX_WAV_VALUE\n",
        "              audio2_denoised = denoiser(audio2.view(1, -1), strength=35)[:, 0]\n",
        "\n",
        "              # High-pass filter, mixing and denormalizing\n",
        "              audio2_denoised = audio2_denoised.cpu().numpy().reshape(-1)\n",
        "              b = scipy.signal.firwin(\n",
        "                  101, cutoff=10500, fs=h2.sampling_rate, pass_zero=False\n",
        "              )\n",
        "              y = scipy.signal.lfilter(b, [1.0], audio2_denoised)\n",
        "              y *= 0\n",
        "              y_out = y.astype(np.int16)\n",
        "              y_padded = np.zeros(wave_out.shape)\n",
        "              y_padded[: y_out.shape[0]] = y_out\n",
        "              sr_mix = wave_out + y_padded\n",
        "              sr_mix = sr_mix / normalize\n",
        "\n",
        "              print(\"\")\n",
        "              ipd.display(ipd.Audio(sr_mix.astype(np.int16), rate=h2.sampling_rate))\n",
        "              if save_audio:\n",
        "                if not os.path.isdir(audio_path+\"/audio samples\"):\n",
        "                  !os.makedirs(audio_path+\"/audio samples\")\n",
        "                scipy.io.wavfile.write(audio_path+\"/audio samples/_\"+epoch+\"test.wav\", h2.sampling_rate, sr_mix.astype(np.int16))\n",
        "                wav2mp3(audio_path+\"/audio samples/_\"+epoch+\"test.wav\")\n",
        "\n",
        "def train(output_directory, log_directory, checkpoint_path, warm_start, n_gpus,\n",
        "          rank, group_name, hparams, log_directory2):\n",
        "    \"\"\"Training and validation logging results to tensorboard and stdout\n",
        "\n",
        "    Params\n",
        "    ------\n",
        "    output_directory (string): directory to save checkpoints\n",
        "    log_directory (string) directory to save tensorboard logs\n",
        "    checkpoint_path(string): checkpoint path\n",
        "    n_gpus (int): number of gpus\n",
        "    rank (int): rank of current gpu\n",
        "    hparams (object): comma separated list of \"name=value\" pairs.\n",
        "    \"\"\"\n",
        "    if hparams.distributed_run:\n",
        "        init_distributed(hparams, n_gpus, rank, group_name)\n",
        "\n",
        "    torch.manual_seed(hparams.seed)\n",
        "    torch.cuda.manual_seed(hparams.seed)\n",
        "\n",
        "    model = load_model(hparams)\n",
        "    learning_rate = hparams.learning_rate\n",
        "    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate,\n",
        "                                 weight_decay=hparams.weight_decay)\n",
        "\n",
        "    if hparams.fp16_run:\n",
        "        from apex import amp\n",
        "        model, optimizer = amp.initialize(\n",
        "            model, optimizer, opt_level='O2')\n",
        "\n",
        "    if hparams.distributed_run:\n",
        "        model = apply_gradient_allreduce(model)\n",
        "\n",
        "    criterion = Tacotron2Loss()\n",
        "\n",
        "    logger = prepare_directories_and_logger(\n",
        "        output_directory, log_directory, rank)\n",
        "\n",
        "    train_loader, valset, collate_fn = prepare_dataloaders(hparams)\n",
        "\n",
        "    # Load checkpoint if one exists\n",
        "    iteration = 0\n",
        "    svcount = 0\n",
        "    epoch_offset = 0\n",
        "    if checkpoint_path is not None and os.path.isfile(checkpoint_path):\n",
        "        if warm_start:\n",
        "            model = warm_start_model(\n",
        "                checkpoint_path, model, hparams.ignore_layers)\n",
        "        else:\n",
        "            model, optimizer, _learning_rate, iteration = load_checkpoint(\n",
        "                checkpoint_path, model, optimizer)\n",
        "            if hparams.use_saved_learning_rate:\n",
        "                learning_rate = _learning_rate\n",
        "            iteration += 1  # next iteration is iteration + 1\n",
        "            epoch_offset = max(0, int(iteration / len(train_loader)))\n",
        "    elif model_base != \"Ninguno\":\n",
        "        raise FileNotFoundError(f\"Modelo '{checkpoint_path}' no se encuentra.\")\n",
        "\n",
        "    start_eposh = time.perf_counter()\n",
        "    learning_rate = 0.0\n",
        "    model.train()\n",
        "    is_overflow = False\n",
        "    # ================ MAIN TRAINNIG LOOP! ===================\n",
        "    for epoch in tqdm(range(epoch_offset, hparams.epochs)):\n",
        "        print(\"\\nStarting Epoch: {} Iteration: {}\".format(epoch, iteration))\n",
        "        start_eposh = time.perf_counter() # eposh is russian, not a typo\n",
        "        for i, batch in tqdm(enumerate(train_loader), total=len(train_loader)):\n",
        "            start = time.perf_counter()\n",
        "            if iteration < hparams.decay_start: learning_rate = hparams.A_\n",
        "            else: iteration_adjusted = iteration - hparams.decay_start; learning_rate = (hparams.A_*(e**(-iteration_adjusted/hparams.B_))) + hparams.C_\n",
        "            learning_rate = max(hparams.min_learning_rate, learning_rate) # output the largest number\n",
        "            for param_group in optimizer.param_groups:\n",
        "                param_group['lr'] = learning_rate\n",
        "\n",
        "            model.zero_grad()\n",
        "            x, y = model.parse_batch(batch)\n",
        "            y_pred = model(x)\n",
        "\n",
        "            loss = criterion(y_pred, y)\n",
        "            if hparams.distributed_run:\n",
        "                reduced_loss = reduce_tensor(loss.data, n_gpus).item()\n",
        "            else:\n",
        "                reduced_loss = loss.item()\n",
        "            if hparams.fp16_run:\n",
        "                with amp.scale_loss(loss, optimizer) as scaled_loss:\n",
        "                    scaled_loss.backward()\n",
        "            else:\n",
        "                loss.backward()\n",
        "\n",
        "            if hparams.fp16_run:\n",
        "                grad_norm = torch.nn.utils.clip_grad_norm_(\n",
        "                    amp.master_params(optimizer), hparams.grad_clip_thresh)\n",
        "                is_overflow = math.isnan(grad_norm)\n",
        "            else:\n",
        "                grad_norm = torch.nn.utils.clip_grad_norm_(\n",
        "                    model.parameters(), hparams.grad_clip_thresh)\n",
        "\n",
        "            optimizer.step()\n",
        "\n",
        "            if not is_overflow and rank == 0:\n",
        "                duration = time.perf_counter() - start\n",
        "                logger.log_training(\n",
        "                    reduced_loss, grad_norm, learning_rate, duration, iteration)\n",
        "                #print(\"Batch {} loss {:.6f} Grad Norm {:.6f} Time {:.6f}\".format(iteration, reduced_loss, grad_norm, duration), end='\\r', flush=True)\n",
        "\n",
        "            iteration += 1\n",
        "        validate(model, criterion, valset, iteration,\n",
        "                 hparams.batch_size, n_gpus, collate_fn, logger,\n",
        "                 hparams.distributed_run, rank, epoch, start_eposh, learning_rate, sample_interbal, save_audio, output_directory)\n",
        "        svcount += 1\n",
        "        if svcount == saving_interval:\n",
        "          svcount = 0\n",
        "          save_checkpoint(model, optimizer, learning_rate, iteration, checkpoint_path)\n",
        "        if log_directory2 != None:\n",
        "            copy_tree(log_directory, log_directory2)\n",
        "\n",
        "\n",
        "def wav2mp3(path_to_file):\n",
        "    final_audio = AudioSegment.from_wav(file=path_to_file)\n",
        "    path_to_file = path_to_file.replace(\".wav\",\".mp3\")\n",
        "    final_audio.export(path_to_file, format=\"mp3\")\n",
        "    return path_to_file\n",
        "\n",
        "def check_dataset(hparams):\n",
        "    from utils import load_wav_to_torch, load_filepaths_and_text\n",
        "    import os\n",
        "    import numpy as np\n",
        "    def check_arr(filelist_arr):\n",
        "        for i, file in enumerate(filelist_arr):\n",
        "            if len(file) > 2:\n",
        "                print(\"|\".join(file), \" tiene múltiplos '|', esto puede no ser un error.\\n\")\n",
        "            if hparams.load_mel_from_disk and '.wav' in file[0]:\n",
        "                print(\"\\033[31m\\033[1m[AVISO]\", file[0], \" en la lista de archivos mientras que lo esperado era .npy\\n\")\n",
        "            else:\n",
        "                if not hparams.load_mel_from_disk and '.npy' in file[0]:\n",
        "                    print(\"\\033[31m\\033[1m[AVISO]\", file[0], \" en la lista de archivos mientras que lo esperado era .wav\\n\")\n",
        "            if (not os.path.exists(file[0])):\n",
        "                raise FileNotFoundError(f\"\\'{'|'.join(file)}\\' no existe. Compruebe su transcripción y sus audios.\")\n",
        "            if len(file[1]) < 3:\n",
        "                print(f\"\\033[34m\\033[1m[info]{'|'.join(file)} sin texto o demasiado corto.\\n\")\n",
        "            if not ((file[1].strip())[-1] in r\"!?,.;:\"):\n",
        "                print(f\"\\033[34m\\033[1m[info]{'|'.join(file)} no tiene puntuación final.\\n\")\n",
        "            mel_length = 1\n",
        "            if hparams.load_mel_from_disk and '.npy' in file[0]:\n",
        "                melspec = torch.from_numpy(np.load(file[0], allow_pickle=True))\n",
        "                mel_length = melspec.shape[1]\n",
        "            if mel_length == 0:\n",
        "                print(f\"\\033[33m\\033[1m[AVISO]{'|'.join(file)} has 0s duration.\\n\")\n",
        "\n",
        "    print(\"Comprobación de los archivos de formación\")\n",
        "    audiopaths_and_text = load_filepaths_and_text(hparams.training_files) # get split lines from training_files text file.\n",
        "    check_arr(audiopaths_and_text)\n",
        "    print(\"Comprobación de los archivos de formación\")\n",
        "    audiopaths_and_text = load_filepaths_and_text(hparams.validation_files) # get split lines from validation_files text file.\n",
        "    check_arr(audiopaths_and_text)\n",
        "    print(\"\\033[32m\\033[1mComprobación realizada\")\n",
        "n_gpus=1\n",
        "rank=0\n",
        "group_name=None\n",
        "\n",
        "# ---- DEFAULT PARAMETERS DEFINED HERE ----\n",
        "hparams = create_hparams()\n",
        "model_filename = 'current_model'\n",
        "hparams.training_files = \"filelists/clipper_train_filelist.txt\"\n",
        "hparams.validation_files = \"filelists/clipper_val_filelist.txt\"\n",
        "#hparams.use_mmi=True,          # not used in this notebook\n",
        "#hparams.use_gaf=True,          # not used in this notebook\n",
        "#hparams.max_gaf=0.5,           # not used in this notebook\n",
        "#hparams.drop_frame_rate = 0.2  # not used in this notebook\n",
        "hparams.p_attention_dropout=0.1\n",
        "hparams.p_decoder_dropout=0.1\n",
        "hparams.decay_start = 15000\n",
        "hparams.A_ = 5e-4\n",
        "hparams.B_ = 8000\n",
        "hparams.C_ = 0\n",
        "hparams.min_learning_rate = 1e-5\n",
        "generate_mels = True\n",
        "hparams.show_alignments = True\n",
        "alignment_graph_height = 600\n",
        "alignment_graph_width = 1000\n",
        "hparams.batch_size = 32\n",
        "hparams.load_mel_from_disk = True\n",
        "hparams.epochs = 10000\n",
        "hparams.sampling_rate = 22050\n",
        "hparams.max_decoder_steps = 3000 # Max Duration\n",
        "hparams.gate_threshold = 0.5 # Model must be 50% sure the clip is over before ending generation\n",
        "torch.backends.cudnn.enabled = hparams.cudnn_enabled\n",
        "torch.backends.cudnn.benchmark = hparams.cudnn_benchmark\n",
        "output_directory = '/content/drive/My Drive/colab/outdir' # Location to save Checkpoints\n",
        "log_directory = '/content/tacotron2/logs' # Location to save Log files locally\n",
        "log_directory2 = '/content/drive/My Drive/colab/logs' # Location to copy log files (done at the end of each epoch to cut down on I/O)\n",
        "checkpoint_path = output_directory+(r'/')+model_filename\n",
        "sample_interbal = 5\n",
        "save_audio = False\n",
        "# ---- Replace .wav with .npy in filelists ----\n",
        "!sed -i -- 's,.wav|,.npy|,g' filelists/*.txt\n",
        "!sed -i -- 's,.wav|,.npy|,g' {hparams.training_files}\n",
        "!sed -i -- 's,.wav|,.npy|,g' {hparams.validation_files}\n",
        "# ---- Replace .wav with .npy in filelists ----\n",
        "\n",
        "%cd /content/tacotron2\n",
        "\n",
        "data_path = 'wavs'\n",
        "!mkdir {data_path}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown ## <font color=\"pink\"> **3. Cargar el conjunto de datos.** 📥\n",
        "#@markdown ---\n",
        "#@markdown #### Los audios deben estar comprimidos en un archivo  <font color=\"orange\">**.ZIP**</font> subido en tu Google Drive.<br>En caso de que no sepas hacerlo, simplemente quita el texto de abajo que pone: \"/content/drive/MyDrive/wavs.zip\" y ejecuta la celda. Te permitirá subir los audios directamente.\n",
        "#@markdown ---\n",
        "#@markdown ####  <font color=\"orange\">**¿Habilitar procesamiento de audios?**\n",
        "#@markdown Recuerda que estos deberán tener un formato compatible, es decir, frecuencia de muestreo <font color=\"orange\">**22050, 16 bit, mono**</font>. Si no tienes los audios con este formato, activa esta casilla para hacer la conversión, a parte de normalización, eliminación de silencios y añadido de 0.5 milisegundos de silencio al final de cada uno para mejor conocimiento de pausas de habla en el modelo.\n",
        "audio_processing = True #@param {type:\"boolean\"}\n",
        "drive_path = \"/content/drive/MyDrive/wavs.zip\" #@param {type: \"string\"}\n",
        "\n",
        "from google.colab import files\n",
        "import zipfile\n",
        "import os\n",
        "import wave\n",
        "import shutil\n",
        "import datetime\n",
        "\n",
        "if os.listdir('/content/tacotron2/wavs/'):\n",
        "  !rm /content/tacotron2/wavs/*\n",
        "with open('/content/insert_silences.py', 'w') as silscript:\n",
        "    silscript.write('''\\\n",
        "import argparse\n",
        "import os\n",
        "from tqdm import tqdm\n",
        "from pydub import AudioSegment\n",
        "if __name__ == '__main__':\n",
        "    parser = argparse.ArgumentParser(\n",
        "        description='Script para agregar silencios'\n",
        "    )\n",
        "    parser.add_argument(\n",
        "        \"--input_dir\",\n",
        "        type=str,\n",
        "        default=None,\n",
        "        required=True,\n",
        "        help=\"EL directorio de entrada con el que trabajar los silencios\",\n",
        "    )\n",
        "    parser.add_argument(\n",
        "        \"--output_dir\",\n",
        "        type=str,\n",
        "        default=None,\n",
        "        required=False,\n",
        "        help=\"La carpeta de salida donde se guardarán los audios modificados\",\n",
        "    )\n",
        "    parser.add_argument(\n",
        "        \"-q\",\n",
        "        \"--quiet\",\n",
        "        action=\"store_true\",\n",
        "        help=\"Modo silencioso\"\n",
        "    )\n",
        "    args = parser.parse_args()\n",
        "# definir la ruta de la carpeta de entrada y salida\n",
        "carpeta_entrada = args.input_dir\n",
        "if not carpeta_entrada:\n",
        "    carpeta_entrada = \"/content/audios/\"\n",
        "carpeta_salida = args.output_dir\n",
        "if not carpeta_salida:\n",
        "    carpeta_salida = \"/content/audios_nuevos/\"\n",
        "def convert(input_dir, output_dir, quiet):\n",
        "    # crear la carpeta de salida si no existe\n",
        "    if not os.path.exists(carpeta_salida):\n",
        "        os.makedirs(carpeta_salida)\n",
        "    # verificar que hay archivos en la carpeta de entrada:\n",
        "    valid_extensions = ('.wav', '.mp3', '.ogg')\n",
        "    files = [f for f in os.listdir(input_dir) if f.endswith(valid_extensions)]\n",
        "    assert len(files) > 0, \"La carpeta de entrada no tiene archivos con los que trabajar\"\n",
        "    # recorrer todos los archivos de la carpeta de entrada\n",
        "    for archivo in tqdm(files):\n",
        "        # cargar el archivo de audio\n",
        "        ruta_archivo = os.path.join(input_dir, archivo)\n",
        "        audio = AudioSegment.from_file(ruta_archivo)\n",
        "        # agregar 0.5 segundos al final del archivo\n",
        "        nuevo_audio = audio.append(AudioSegment.silent(duration=500))\n",
        "        # guardar el nuevo archivo de audio en la carpeta de salida\n",
        "        ruta_nuevo_archivo = os.path.join(output_dir, archivo)\n",
        "        #ruta_nuevo_archivo = output_dir + archivo\n",
        "        nuevo_audio.export(ruta_nuevo_archivo, format=\"wav\")\n",
        "    if not quiet:\n",
        "        print(\"Se agregaron 0.5 segundos a todos los archivos de audio en la carpeta de entrada y se guardaron los nuevos archivos en la carpeta de salida.\")\n",
        "convert(carpeta_entrada, carpeta_salida, args.quiet)\n",
        "''')\n",
        "with open('/content/audios.sh', 'w') as rsh:\n",
        "    rsh.write('''\\\n",
        "for file in /content/tacotron2/wavs/*.wav\n",
        "do\n",
        "    ffmpeg -y -i \"$file\" -ar 22050 /content/tempwav/srtmp.wav -loglevel error\n",
        "    sox /content/tempwav/srtmp.wav  -c 1 /content/tempwav/ntmp.wav norm -0.1\n",
        "    sox /content/tempwav/ntmp.wav /content/tempwav/ctmp.wav silence 1 0.05 0.1% reverse silence 1 0.05 0.1% reverse\n",
        "    ffmpeg -y -i /content/tempwav/ctmp.wav -c copy -fflags +bitexact -flags:v +bitexact -flags:a +bitexact -ar 22050 /content/tempwav/poop.wav -loglevel error\n",
        "    rm \"$file\"\n",
        "    mv /content/tempwav/poop.wav \"$file\"\n",
        "    rm /content/tempwav/*\n",
        "done\n",
        "python \"/content/insert_silences.py\" --input_dir \"/content/tacotron2/wavs\" --output_dir \"/content/tacotron2/newwavs\" --quiet\n",
        "mv /content/tacotron2/newwavs/*.wav /content/tacotron2/wavs\n",
        "''')\n",
        "\n",
        "%cd /content/tacotron2/wavs\n",
        "\n",
        "drive_path = drive_path.strip()\n",
        "\n",
        "if drive_path:\n",
        "  if os.path.exists(drive_path):\n",
        "    print(f\"\\n\\033[34m\\033[1mAudio importado de Drive.\\n\\033[90m\")\n",
        "    if zipfile.is_zipfile(drive_path):\n",
        "      !unzip -q -j \"$drive_path\" -d /content/tacotron2/wavs\n",
        "\n",
        "    else:\n",
        "      fp = drive_path + \"/.\"\n",
        "      !cp -a \"$fp\" \"/content/tacotron2/wavs\"\n",
        "  else:\n",
        "    print(f\"\\n\\033[33m\\033[1m[AVISO] La ruta {drive_path} no se encuentra, compruebe los errores e inténtelo de nuevo.\")\n",
        "    print(f\"\\n\\033[34m\\033[1mCargue su conjunto de datos(audios)...\")\n",
        "    uploaded = files.upload()\n",
        "else:\n",
        "  print(f\"\\n\\033[34m\\033[1mCargue su conjunto de datos(audios)...\")\n",
        "  uploaded = files.upload()\n",
        "\n",
        "  for fn in uploaded.keys():\n",
        "    if zipfile.is_zipfile(fn):\n",
        "      !unzip -q -j \"$fn\" -d /content/tacotron2/wavs\n",
        "      !rm \"$fn\"\n",
        "\n",
        "if os.path.exists(\"/content/tacotron2/wavs/wavs\"):\n",
        "    for file in os.listdir(\"/content/tacotron2/wavs/wavs\"):\n",
        "      !mv /content/tacotron2/wavs/wavs/\"$file\"  /content/tacotron2/wavs/\"$file\"\n",
        "!rm /content/tacotron2/wavs/list.txt\n",
        "if audio_processing:\n",
        "  print(f\"\\n\\033[37mNormalización, eliminación de metadatos y comprobación de audios...\")\n",
        "  !mkdir /content/tempwav\n",
        "  !bash /content/audios.sh\n",
        "\n",
        "totalduration = 0\n",
        "for file_name in [x for x in os.listdir() if os.path.isfile(x)]:\n",
        "    with wave.open(file_name, \"rb\") as wave_file:\n",
        "        frames = wave_file.getnframes()\n",
        "        rate = wave_file.getframerate()\n",
        "        duration = frames / float(rate)\n",
        "        totalduration += duration\n",
        "\n",
        "        if duration >= 15:\n",
        "          print(f\"\\n\\033[33m\\033[1m[AVISO] {file_name} es superior a 15 segundos. La falta de RAM puede\"\n",
        "                \" ¡se producen en un lote de gran tamaño!\")\n",
        "\n",
        "wav_count = len(os.listdir(\"/content/tacotron2/wavs\"))\n",
        "print(f\"\\n{wav_count} audios procesados. duración total: {str(datetime.timedelta(seconds=round(totalduration, 0)))}\\n\")\n",
        "\n",
        "#shutil.make_archive(\"/content/processedwavs\", 'zip', '/content/tacotron2/wavs')\n",
        "#files.download('/content/processedwavs.zip')\n",
        "\n",
        "print(\"\\n\\033[32m\\033[1mTodo listo, proceda.\")"
      ],
      "metadata": {
        "id": "j18Q4ku-oL0J",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown ## <font color=\"pink\"> **4. Sube la transcripción.** 📝\n",
        "#@markdown ---\n",
        "#@markdown ### La transcripción debe ser un archivo ``.TXT`` formateado en <font color=\"red\" size=\"+3\"> ``UTF-8 sin BOM.``</font>\n",
        "%cd /content/tacotron2/filelists/\n",
        "!rm /content/tacotron2/filelists/list.txt\n",
        "\n",
        "print(\"\\n\\033[34m\\033[1mSube tu expediente académico(list)...\")\n",
        "listfn, length = files.upload().popitem()\n",
        "\n",
        "if listfn != \"list.txt\":\n",
        "  !mv \"$listfn\" list.txt\n",
        "%cd /content/tacotron2/\n",
        "print(\"\\n\\033[32m\\033[1mTodo listo, proceda.\")"
      ],
      "metadata": {
        "id": "CHtQAgFfIDJt",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UP1trdpN_jV6",
        "cellView": "form"
      },
      "source": [
        "import os\n",
        "import os.path\n",
        "from pathlib import Path\n",
        "from itertools import chain\n",
        "from glob import glob\n",
        "#@markdown ## <font color=\"pink\"> **5. Configurar los parámetros del modelo.** 🎛️\n",
        "#@markdown ---\n",
        "#@markdown ####  Nombre deseado para el modelo:\n",
        "#@markdown ##### <font color=\"orange\">**(Evita usar espacios en el nombre. Puedes poner _ o - para separar si deseas. Ejemplo: Voz_de_prueba)**\n",
        "model_filename = \"Test\" #@param {type: \"string\"}\n",
        "Training_file = \"/content/tacotron2/filelists/list.txt\"\n",
        "hparams.training_files = Training_file\n",
        "hparams.validation_files = Training_file\n",
        "# hparams to Tune\n",
        "#hparams.use_mmi=True,          # not used in this notebook\n",
        "#hparams.use_gaf=True,          # not used in this notebook\n",
        "#hparams.max_gaf=0.5,           # not used in this notebook\n",
        "#hparams.drop_frame_rate = 0.2  # not used in this notebook\n",
        "hparams.p_attention_dropout=0.1\n",
        "hparams.p_decoder_dropout=0.1\n",
        "\n",
        "hparams.B_ = 8000                   # Decay Rate\n",
        "hparams.C_ = 0                      # Shift learning rate equation by this value\n",
        "hparams.min_learning_rate = 1e-5    # Min Learning Rate\n",
        "\n",
        "# Quality of Life\n",
        "generate_mels = True\n",
        "hparams.show_alignments = True\n",
        "alignment_graph_height = 600\n",
        "alignment_graph_width = 1000\n",
        "\n",
        "#@markdown ---\n",
        "#@markdown #### Batch size. Marca la casilla si desea que el código calcule el valor óptimo automáticamente:\n",
        "#@markdown ##### <font color=\"orange\">**(Se recomienda marcarla, hará 2 cálculos de división basados en tu cantidad de audios para sacar el batch correcto.)**\n",
        "auto_batch_size = True #@param{type:\"boolean\"}\n",
        "hparams.batch_size =   6#@param {type: \"integer\"}\n",
        "\n",
        "if auto_batch_size:\n",
        "  import subprocess\n",
        "  gpu_check = subprocess.check_output(\"nvidia-smi -L\", shell=True)\n",
        "  if \"K80\" in str(gpu_check):\n",
        "      hparams.batch_size = int(wav_count/48)\n",
        "  else:\n",
        "      hparams.batch_size = int(wav_count/32)\n",
        "  print(f\"batch size ajustado a {hparams.batch_size}\")\n",
        "\n",
        "#@markdown ---\n",
        "#@markdown #### Esto es la tasa de aprendizaje, *se recomienda no tocarla a no ser que sepas manejarla.*\n",
        "# Learning Rate             # https://www.desmos.com/calculator/ptgcz4vzsw / http://boards.4channel.org/mlp/thread/34778298#p34789030\n",
        "hparams.decay_start = 15000         # wait till decay_start to start decaying learning rate\n",
        "autocalculate_learning_rate = False\n",
        "\n",
        "if autocalculate_learning_rate:\n",
        "  hparams.A_ = 0.001*(hparams.batch_size/256)**0.5 # Start/Max Learning Rate\n",
        "  print(f\"Learning Rate definido como {hparams.A_}\")\n",
        "else:\n",
        "  hparams.A_ = 3e-4 #@param [\"3e-6\", \"1e-5\", \"1e-4\", \"5e-4\", \"1e-3\"] {type:\"raw\", allow-input: true}\n",
        "\n",
        "hparams.load_mel_from_disk = True\n",
        "hparams.text_cleaners=[\"basic_cleaners\"]\n",
        "hparams.ignore_layers=[\"embedding.weight\"]\n",
        "# Layers to reset (None by default, other than foreign languages this param can be ignored)\n",
        "\n",
        "#@markdown ---\n",
        "#@markdown #### Épocas de entrenamiento: *(No se recomienda cambiar.)*\n",
        "hparams.epochs =  250#@param {type: \"integer\"}\n",
        "\n",
        "#@markdown ---\n",
        "#@markdown #### Rango de épocas para guardar: *(No se recomienda cambiar.)*\n",
        "saving_interval =  1#@param {type: \"integer\"}\n",
        "\n",
        "torch.backends.cudnn.enabled = hparams.cudnn_enabled\n",
        "torch.backends.cudnn.benchmark = hparams.cudnn_benchmark\n",
        "\n",
        "#@markdown ---\n",
        "#@markdown #### Dónde guardar tu modelo en tu Drive:\n",
        "output_directory = '/content/drive/My Drive/colab/outdir' #@param {type: \"string\"}\n",
        "log_directory = '/content/tacotron2/logs' # Location to save Log files locally\n",
        "log_directory2 = None # Location to copy log files (done at the end of each epoch to cut down on I/O)\n",
        "checkpoint_path = output_directory+(r'/')+model_filename\n",
        "\n",
        "#@markdown ---\n",
        "#@markdown ####¿Utilizar el warm start? <font color=\"orange\">**Si vas a seguir entrenando desde un punto de guardado, desactívalo.**\n",
        "warm_start = True #@param {type:\"boolean\"}\n",
        "\n",
        "#@markdown ---\n",
        "#@markdown #### Intervalo de épocas para generar muestras de audio del modelo:\n",
        "sample_interval =  5#@param {type: \"integer\"}\n",
        "#@markdown ---\n",
        "#@markdown #### Guardar muestras de audio del modelo: *(Bueno para enviar los progresos de entrenamiento.)*\n",
        "save_audios =  True #@param {type:\"boolean\"}\n",
        "audio_path = output_directory\n",
        "#@markdown ---\n",
        "#@markdown ####Elija un modelo base para una alineación más rápida: **(Obligatorio.)**\n",
        "if not os.path.exists(output_directory):\n",
        "    os.makedirs(output_directory)\n",
        "model_base = \"LATAM-Male\" #@param [\"LATAM-Male\", \"ESPAÑA-Male\", \"None\"]\n",
        "ids = {\"LATAM-Male\": \"Matthew.pt\", \"ESPAÑA-Male\": \"spanishmale.pt\"}\n",
        "file_status = os.path.isfile(checkpoint_path)\n",
        "if model_base != \"None\":\n",
        "    if file_status == True:\n",
        "      print(\"\\n\\033[33m\\033[1m[Aviso] Ya existe un archivo con ese nombre en tu disco. Si quieres utilizar el modelo base tendrás que borrar/renombrar este archivo.\\nPero si has desactivado el warm start, puedes sobrescribir el archivo existente con el mismo nombre sin preocuparte para seguir entrenando\\nel modelo sobre este sin perder datos.\")\n",
        "    else:\n",
        "      print(f\"Descarga de la plantilla {model_base} en {checkpoint_path}\")\n",
        "      !wget \"https://huggingface.co/datasets/rmcpantoja/taco2-checkpoints/resolve/main/es/{ids[model_base]}\" -O \"$checkpoint_path\"\n",
        "#@markdown ---"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A2-xc6EcACWc",
        "cellView": "form"
      },
      "source": [
        "#@markdown ## <font color=\"pink\"> **6. Convierte los .WAV en espectrogramas de Mel y comprueba los archivos.** 🔉>📈\n",
        "#@markdown ---\n",
        "#@markdown ####  Esta celda convierte automáticamente los .wav en .npy, los cuales serán necesarios para el entrenamiento de la voz.\n",
        "import re\n",
        "import num2words\n",
        "import sys\n",
        "from contextlib import redirect_stdout\n",
        "import fileinput\n",
        "\n",
        "with open('/content/tacotron2/filelists/list.txt', 'r') as f:\n",
        "    new_text = '\\n'.join([line.strip() for line in f.read().split('\\n') if line.strip()])\n",
        "    with open('/content/tacotron2/filelists/list.txt', 'w') as n:\n",
        "      n.write(new_text)\n",
        "\n",
        "f_input = open('/content/tacotron2/filelists/list.txt','r')\n",
        "text = f_input.readlines()\n",
        "#print(text)\n",
        "text2 = len(text)\n",
        "dummytext = \"\"\n",
        "#print(text2)\n",
        "for number in range(0,text2):\n",
        " dummytext = number\n",
        " if(str(dummytext) + \".wav\") in (text[number]):\n",
        "   pass\n",
        " else:\n",
        "  dummytext = str(text[number])\n",
        "  dummytext2 = dummytext.split(\"|\")\n",
        "  try:\n",
        "    dummytext2[1] = re.sub(r\"(\\d+)\", lambda x: num2words.num2words(int(x.group(0)), lang='es'), dummytext2[1],)\n",
        "  except IndexError:\n",
        "    replace = dummytext.replace('\\n', '')\n",
        "    raise Exception(f\"esta línea '{replace}' tiene un problema, por favor, compruebe.\")\n",
        "  #print(dummytext2[1])\n",
        "  text[number]  = (str(dummytext2[0] + \"|\" + dummytext2[1].lower()))\n",
        "  #print(text[number])\n",
        "\n",
        "  #print(text[number])\n",
        "textfinal = \" \"\n",
        "for number in range(text2):\n",
        " textfinal += text[number]\n",
        "textfinal = textfinal.replace('[','')\n",
        "textfinal = textfinal.replace(\"',\",'')\n",
        "textfinal = textfinal.replace(\"'\",'')\n",
        "textfinal = textfinal.replace(']','')\n",
        "textfinal = textfinal.replace('\\\\n','\\n')\n",
        "textfinal = textfinal.replace(' wavs','wavs')\n",
        "t = textfinal\n",
        "\"\".join([s for s in t.strip().splitlines(True) if s.strip()])\n",
        "print(textfinal, file=open(\"/content/tacotron2/filelists/list1.txt\", \"a\"))\n",
        "\n",
        "\n",
        "!rm /content/tacotron2/filelists/list.txt\n",
        "!mv /content/tacotron2/filelists/list1.txt /content/tacotron2/filelists/list.txt\n",
        "if generate_mels:\n",
        "    create_mels()\n",
        "\n",
        "print(\"Checking for missing files\")\n",
        "# ---- Replace .wav with .npy in filelists ----\n",
        "!sed -i -- 's,.wav|,.npy|,g' {hparams.training_files}; sed -i -- 's,.wav|,.npy|,g' {hparams.validation_files}\n",
        "\n",
        "check_dataset(hparams)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iqIk1dIuCqhx",
        "cellView": "form"
      },
      "source": [
        "#@markdown ## <font color=\"pink\"> **7. Empezar a entrenar. (Por fin)** 🏋️\n",
        "#@markdown ---\n",
        "#@markdown #### Aquí puedes escribir el texto en el que se generarán las muestras de audio del modelo. Un texto muy grande puede llevar mucho tiempo y ser difícil de generar, y un texto muy pequeño puede no demostrar el modelo muy bien, así que elige sabiamente. <br> Si dejas puesto `random`, se pondrá una frase aleatoria que está en una lista de frases.\n",
        "sampletext = \"random\" #@param {type: \"string\"}\n",
        "if sampletext == \"random\":\n",
        "    !gdown -q -O /content/tacotron2/filelists/randomtexts.txt 1zmYoPHdurHRxQZ7g4fkAZ4wDbIXZBljU\n",
        "    with open(\"/content/tacotron2/filelists/randomtexts.txt\", \"r\") as file:\n",
        "        lines = file.readlines()\n",
        "    sampletext = random.choice(lines)\n",
        "print('FP16 Run:', hparams.fp16_run)\n",
        "print('Dynamic Loss Scaling:', hparams.dynamic_loss_scaling)\n",
        "print('Distributed Run:', hparams.distributed_run)\n",
        "print('cuDNN Enabled:', hparams.cudnn_enabled)\n",
        "print('cuDNN Benchmark:', hparams.cudnn_benchmark)\n",
        "train(output_directory, log_directory, checkpoint_path,\n",
        "      warm_start, n_gpus, rank, group_name, hparams, log_directory2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#<font color=\"pink\">🧍***¿Has terminado de entrenar por hoy?***🏠🚶\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "##🔊 Prueba el modelo en el cuaderno de síntesis pulsando [aquí.](https://colab.research.google.com/drive/1lRGlbiK2wUCm07BKIhjV3dKej7jV0s1y)\n",
        "##📈 También puedes ajustar el vocoder HiFi-GAN pulsando [aquí.](https://colab.research.google.com/github/justinjohn0306/FakeYou-Tacotron2-Notebook/blob/main/FakeYou_HiFi_GAN_Fine_Tuning.ipynb?) Esto es para mejorar el sonido y la naturalidad del modelo TTS.  <font color=\"orange\">**(Solo para cuando termines de entrenar definitivamente el modelo.)**"
      ],
      "metadata": {
        "id": "BBtscuD-uE54"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h4ql3OWWPKZv"
      },
      "source": [
        "#<font color=\"pink\">✍️ ***Notas finales.*** ✍️\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "## Un buen entrenamiento se ve así:<br>*(Aunque bueno, esto es dependiendo de cada voz y como la entrenes, pero la idea es que haga la diagonal correctamente. Aunque no siempre debe ser así de perfecta tampoco.)*\n",
        "![img.png](https://media.discordapp.net/attachments/835971020569051216/851469553355587614/download_2.png)\n",
        "\n"
      ]
    }
  ]
}