File size: 10,078 Bytes
56b10cc
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "tortoise-tts.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JrK20I32grP6"
      },
      "outputs": [],
      "source": [
        "!git clone https://github.com/neonbjb/tortoise-tts.git\n",
        "%cd tortoise-tts\n",
        "!pip install -r requirements.txt"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Imports used through the rest of the notebook.\n",
        "import torch\n",
        "import torchaudio\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from tqdm import tqdm\n",
        "\n",
        "from utils.tokenizer import VoiceBpeTokenizer\n",
        "from models.discrete_diffusion_vocoder import DiscreteDiffusionVocoder\n",
        "from models.text_voice_clip import VoiceCLIP\n",
        "from models.dvae import DiscreteVAE\n",
        "from models.autoregressive import UnifiedVoice\n",
        "\n",
        "# These have some fairly interesting code that is hidden in the colab. Consider checking it out.\n",
        "from do_tts import download_models, load_discrete_vocoder_diffuser, load_conditioning, fix_autoregressive_output, do_spectrogram_diffusion"
      ],
      "metadata": {
        "id": "Gen09NM4hONQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Download pretrained models and set up pretrained voice bank. Feel free to upload and add your own voices here.\n",
        "# To do so, upload two WAV files cropped to 5-10 seconds of someone speaking.\n",
        "download_models()\n",
        "preselected_cond_voices = {\n",
        "        # Male voices\n",
        "        'dotrice': ['voices/dotrice/1.wav', 'voices/dotrice/2.wav'],\n",
        "        'harris': ['voices/harris/1.wav', 'voices/harris/2.wav'],\n",
        "        'lescault': ['voices/lescault/1.wav', 'voices/lescault/2.wav'],\n",
        "        'otto': ['voices/otto/1.wav', 'voices/otto/2.wav'],\n",
        "        # Female voices\n",
        "        'atkins': ['voices/atkins/1.wav', 'voices/atkins/2.wav'],\n",
        "        'grace': ['voices/grace/1.wav', 'voices/grace/2.wav'],\n",
        "        'kennard': ['voices/kennard/1.wav', 'voices/kennard/2.wav'],\n",
        "        'mol': ['voices/mol/1.wav', 'voices/mol/2.wav'],\n",
        "    }"
      ],
      "metadata": {
        "id": "SSleVnRAiEE2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# This is the text that will be spoken.\n",
        "text = \"And took the other as just as fair, and having perhaps the better claim, because it was grassy and wanted wear.\"\n",
        "# This is the voice that will speak it.\n",
        "voice = 'atkins'\n",
        "# This is the number of samples we will generate from the DALLE-style model. More will produce better results, but will take longer to produce.\n",
        "# I don't recommend going less than 128.\n",
        "num_autoregressive_samples = 128"
      ],
      "metadata": {
        "id": "bt_aoxONjfL2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Prepare data.\n",
        "tokenizer = VoiceBpeTokenizer()\n",
        "text = torch.IntTensor(tokenizer.encode(text)).unsqueeze(0).cuda()\n",
        "text = F.pad(text, (0,1))  # This may not be necessary.\n",
        "cond_paths = preselected_cond_voices[voice]\n",
        "conds = []\n",
        "for cond_path in cond_paths:\n",
        "    c, cond_wav = load_conditioning(cond_path)\n",
        "    conds.append(c)\n",
        "conds = torch.stack(conds, dim=1)  # And just use the last cond_wav for the diffusion model."
      ],
      "metadata": {
        "id": "KEXOKjIvn6NW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Load the autoregressive model.\n",
        "autoregressive = UnifiedVoice(max_mel_tokens=300, max_text_tokens=200, max_conditioning_inputs=2, layers=30, model_dim=1024,\n",
        "                                      heads=16, number_text_tokens=256, start_text_token=255, checkpointing=False, train_solo_embeddings=False).cuda().eval()\n",
        "autoregressive.load_state_dict(torch.load('.models/autoregressive.pth'))\n",
        "stop_mel_token = autoregressive.stop_mel_token"
      ],
      "metadata": {
        "id": "Z15xFT_uhP8v"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Perform inference with the autoregressive model, generating num_autoregressive_samples\n",
        "with torch.no_grad():\n",
        "    samples = []\n",
        "    for b in tqdm(range(num_autoregressive_samples // 16)):\n",
        "        codes = autoregressive.inference_speech(conds, text, num_beams=1, repetition_penalty=1.0, do_sample=True, top_k=50, top_p=.95,\n",
        "                                                temperature=.9, num_return_sequences=16, length_penalty=1)\n",
        "        padding_needed = 250 - codes.shape[1]\n",
        "        codes = F.pad(codes, (0, padding_needed), value=stop_mel_token)\n",
        "        samples.append(codes)\n",
        "\n",
        "# Delete model weights to conserve memory.\n",
        "del autoregressive"
      ],
      "metadata": {
        "id": "xajqWiEik-j0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Load the CLIP model.\n",
        "clip = VoiceCLIP(dim_text=512, dim_speech=512, dim_latent=512, num_text_tokens=256, text_enc_depth=8, text_seq_len=120, text_heads=8,\n",
        "                  num_speech_tokens=8192, speech_enc_depth=10, speech_heads=8, speech_seq_len=250).cuda().eval()\n",
        "clip.load_state_dict(torch.load('.models/clip.pth'))"
      ],
      "metadata": {
        "id": "KNgYSyuyliMs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Use the CLIP model to select the best autoregressive output to match the given text.\n",
        "clip_results = []\n",
        "with torch.no_grad():\n",
        "    for batch in samples:\n",
        "        for i in range(batch.shape[0]):\n",
        "            batch[i] = fix_autoregressive_output(batch[i], stop_mel_token)\n",
        "        text = text[:, :120]  # Ugly hack to fix the fact that I didn't train CLIP to handle long enough text.\n",
        "        clip_results.append(clip(text.repeat(batch.shape[0], 1),\n",
        "                            torch.full((batch.shape[0],), fill_value=text.shape[1]-1, dtype=torch.long, device='cuda'),\n",
        "                            batch, torch.full((batch.shape[0],), fill_value=batch.shape[1]*1024, dtype=torch.long, device='cuda'),\n",
        "                            return_loss=False))\n",
        "    clip_results = torch.cat(clip_results, dim=0)\n",
        "    samples = torch.cat(samples, dim=0)\n",
        "    best_results = samples[torch.topk(clip_results, k=1).indices]\n",
        "\n",
        "# Save samples to CPU memory, delete clip to conserve memory.\n",
        "samples = samples.cpu()\n",
        "del clip"
      ],
      "metadata": {
        "id": "DDXkM0lclp4U"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Load the DVAE and diffusion model.\n",
        "dvae = DiscreteVAE(positional_dims=1, channels=80, hidden_dim=512, num_resnet_blocks=3, codebook_dim=512, num_tokens=8192, num_layers=2,\n",
        "                    record_codes=True, kernel_size=3, use_transposed_convs=False).cuda().eval()\n",
        "dvae.load_state_dict(torch.load('.models/dvae.pth'), strict=False)\n",
        "diffusion = DiscreteDiffusionVocoder(model_channels=128, dvae_dim=80, channel_mult=[1, 1, 1.5, 2, 3, 4, 6, 8, 8, 8, 8], num_res_blocks=[1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1],\n",
        "                                      spectrogram_conditioning_resolutions=[2,512], attention_resolutions=[512,1024], num_heads=4, kernel_size=3, scale_factor=2,\n",
        "                                      conditioning_inputs_provided=True, time_embed_dim_multiplier=4).cuda().eval()\n",
        "diffusion.load_state_dict(torch.load('.models/diffusion.pth'))\n",
        "diffuser = load_discrete_vocoder_diffuser(desired_diffusion_steps=100)"
      ],
      "metadata": {
        "id": "97acSnBal8Q2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Decode the (best) discrete sequence created by the autoregressive model.\n",
        "with torch.no_grad():\n",
        "    for b in range(best_results.shape[0]):\n",
        "        code = best_results[b].unsqueeze(0)\n",
        "        wav = do_spectrogram_diffusion(diffusion, dvae, diffuser, code, cond_wav, spectrogram_compression_factor=256, mean=True)\n",
        "        torchaudio.save(f'{voice}_{b}.wav', wav.squeeze(0).cpu(), 22050)"
      ],
      "metadata": {
        "id": "HEDABTrdl_kM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Listen to your text! (told you that'd take a long time..)\n",
        "from IPython.display import Audio\n",
        "Audio(data=wav.squeeze(0).cpu().numpy(), rate=22050)"
      ],
      "metadata": {
        "id": "EyHmcdqBmSvf"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}