diff --git a/nbs/6. EnCodec quality enchancement.ipynb b/nbs/6. EnCodec quality enchancement.ipynb new file mode 100644 index 0000000..98aa1f3 --- /dev/null +++ b/nbs/6. EnCodec quality enchancement.ipynb @@ -0,0 +1,3505 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "20266a28", + "metadata": {}, + "outputs": [], + "source": [ + "#| default_exp a2a\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a853249", + "metadata": {}, + "outputs": [], + "source": [ + "#| exporti\n", + "import io\n", + "import time\n", + "import random" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7ffec6c3", + "metadata": {}, + "outputs": [], + "source": [ + "#| exporti\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.profiler import profile, record_function, ProfilerActivity, schedule" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13462aa4", + "metadata": {}, + "outputs": [], + "source": [ + "#| exporti\n", + "from pathlib import Path\n", + "import json\n", + "from fastprogress import progress_bar, master_bar\n", + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e0dda41", + "metadata": {}, + "outputs": [], + "source": [ + "#| exporti\n", + "from spear_tts_pytorch.train import *\n", + "from spear_tts_pytorch.modules import *" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d7b796d8", + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import Audio, HTML, display\n", + "import pylab as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d72390bf", + "metadata": {}, + "outputs": [], + "source": [ + "datadir = Path('/root/acoustic-6k-6454')" + ] + }, + { + "cell_type": "markdown", + "id": "b02bc209", + "metadata": {}, + "source": [ + "# Dataset" + ] + }, + { + "cell_type": "markdown", + "id": "ec46329b", + "metadata": {}, + "source": [ + "## Create a dataset index" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c5a37195", + "metadata": {}, + "outputs": [], + "source": [ + "atoks = []\n", + "for name in Path(datadir).glob('*.encodec'):\n", + " atoks.append(name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e361412e", + "metadata": {}, + "outputs": [], + "source": [ + "data = pd.DataFrame(dict(atoks=atoks))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c288b465", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1, 8, 50528])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "torch.load(atoks[0]).shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cdc2e2be", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def load_data(path):\n", + " atoks = []\n", + " for name in Path(path).glob('*.encodec'):\n", + " atoks.append(name)\n", + " return pd.DataFrame(dict(atoks=atoks))" + ] + }, + { + "cell_type": "markdown", + "id": "9f77fad9", + "metadata": {}, + "source": [ + "## Load the dataset index" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a5edd423", + "metadata": {}, + "outputs": [], + "source": [ + "#| exporti\n", + "import torch.nn.functional as F\n", + "\n", + "class SADataset(torch.utils.data.Dataset):\n", + " def __init__(self, data, fromq=2, toq=4):\n", + " self.fromq = fromq\n", + " self.toq = toq\n", + " self.n_ctx = 192\n", + " self.data = data\n", + " self.samples = [(i,j) for i,name in enumerate(data['atoks']) for j in range(torch.load(name).shape[-1] // self.n_ctx)]\n", + " \n", + " def __len__(self):\n", + " return len(self.samples)\n", + " \n", + " def A_tokens(self):\n", + " return len(self)*self.n_ctx*4\n", + " \n", + " def hours(self):\n", + " return len(self)*self.n_ctx/2250*30/3600\n", + " \n", + " def __repr__(self):\n", + " return f\"Dataset<{len(self)} samples, ({self.fromq}->{self.toq}), {self.A_tokens()} Atokens, {self.hours():.1f} hours>\"\n", + " \n", + " def __getitem__(self, idx):\n", + " i,j = self.samples[idx]\n", + " row = self.data.iloc[i]\n", + " jA = j * self.n_ctx\n", + " Atoks = torch.load(row['atoks'], map_location='cpu')[0,:self.toq,jA:jA+self.n_ctx].T\n", + " outtoks = Atoks.reshape(-1).clone()\n", + " Atoks[:,self.fromq:] = 1024 # mask token\n", + " intoks = Atoks.reshape(-1).clone()\n", + " return intoks, outtoks" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cedfb493", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3098" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(data)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ef8736c2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Dataset<5144 samples, (2->4), 3950592 Atokens, 3.7 hours>" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "val_data, train_data = data[:12], data[12:]\n", + "val_ds = SADataset(val_data)\n", + "val_ds" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d6c82c52", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Dataset<1709062 samples, (2->4), 1312559616 Atokens, 1215.3 hours>" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_ds = SADataset(train_data)\n", + "train_ds" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a897af41", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[torch.Size([768]), torch.Size([768])]" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[x.shape for x in train_ds[0]]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a6cc30ec", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(train_ds[0][0][:200], '.', alpha=.3)\n", + "plt.plot(train_ds[0][1][:200], '.', alpha=.3)\n", + "# brown - fromq, known tokens\n", + "# blue - masked\n", + "# orange - targets" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "887e3635", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def load_datasets(\n", + " path:Path, # encodec files path\n", + " subsample:float=1, # use a fraction of the files\n", + " fromq:int=2, # input quantizers\n", + " toq:int=8 # output quantizers\n", + " ):\n", + " data = load_data(path)\n", + " \n", + " val_data, train_data = data[:12], data[12:int(len(data)*subsample)]\n", + "\n", + " return SADataset(train_data, fromq=fromq, toq=toq), SADataset(val_data, fromq=fromq, toq=toq)" + ] + }, + { + "cell_type": "markdown", + "id": "0f5e4ad4", + "metadata": {}, + "source": [ + "# Modeling" + ] + }, + { + "cell_type": "markdown", + "id": "89b5e60b", + "metadata": {}, + "source": [ + "## Add resampled encoder features at the middle decoder layer (replacement for cross-attention)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0c4a32dd", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "class LayerNorm(nn.LayerNorm):\n", + " def forward(self, x):\n", + " return super().forward(x.float()).type(x.dtype)\n", + "\n", + "# based on https://github.com/karpathy/minGPT/blob/master/mingpt/model.py#L163\n", + "def init_transformer(m):\n", + " if isinstance(m, (nn.Linear, nn.Embedding)):\n", + " torch.nn.init.trunc_normal_(m.weight, std=.02)\n", + " if isinstance(m, nn.Linear) and m.bias is not None:\n", + " torch.nn.init.constant_(m.bias, 0)\n", + " elif isinstance(m, nn.LayerNorm):\n", + " torch.nn.init.constant_(m.bias, 0)\n", + " torch.nn.init.constant_(m.weight, 1.0)\n", + " \n", + "class PureEncoder(nn.Module):\n", + " def __init__(self, depth=6, width=384, n_head=6, length=1500, codes=1024, pos_embs=None):\n", + " super().__init__()\n", + " self.length = length\n", + " self.codes = codes\n", + " \n", + " # embed semantic tokens\n", + " self.embedding = nn.Embedding(codes+1, width)\n", + " if pos_embs is None: pos_embs = sinusoids(length, width)\n", + " self.register_buffer(\"positional_embedding\", pos_embs)\n", + " \n", + " self.layers = nn.ModuleList([\n", + " ResidualAttentionBlock(width, n_head) for _ in range(depth)\n", + " ])\n", + " self.ln_post = LayerNorm(width)\n", + " \n", + " self.apply(init_transformer)\n", + " \n", + " def forward(self, Stoks):\n", + " Sembs = self.embedding(Stoks)\n", + "\n", + " xin = (Sembs + self.positional_embedding[:Sembs.shape[1]])\n", + " \n", + " x = xin\n", + " for l in self.layers: x = l(x, causal=False)\n", + " \n", + " x = self.ln_post(x)\n", + " \n", + " logits = (x @ self.embedding.weight.to(x.dtype).T).float()\n", + " return logits" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "159774b6", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "class AAARTransformer(nn.Module):\n", + " def __init__(self, width=384, depth=4, ctx_n=250, n_head=6, fromq=2, toq=4):\n", + " super().__init__()\n", + "\n", + " pos_embs = sinusoids(ctx_n * toq, width)\n", + " \n", + " self.encoder = PureEncoder(pos_embs=pos_embs, length=ctx_n*toq, width=width, n_head=n_head, depth=depth)\n", + "\n", + " def forward(self, intoks, outtoks, loss=True):\n", + " with record_function(\"decoder\"):\n", + " logits = self.encoder(intoks)\n", + " if loss is not None:\n", + " with record_function(\"loss\"):\n", + " loss = F.cross_entropy(logits.reshape(-1,logits.shape[-1]), outtoks.view(-1))\n", + " return logits, loss" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4a24d2d7", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def make_model(size:str, dataset:torch.utils.data.Dataset=None):\n", + " assert(dataset is not None)\n", + " kwargs = dict(fromq = dataset.fromq, toq = dataset.toq, ctx_n = dataset.n_ctx)\n", + " if size == 'tiny':\n", + " return AAARTransformer(depth=4, **kwargs)\n", + " elif size == 'base':\n", + " return AAARTransformer(depth=6, width=512, n_head=8, **kwargs)\n", + " elif size == 'small':\n", + " return AAARTransformer(depth=12, width=768, n_head=12, **kwargs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a3ca8e2b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " 100.00% [1/1 08:46<00:00]\n", + "
\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
samplestrainvaltime
100485.872836.5059300:35
200324.600314.7004501:07
300164.414984.5919701:39
400006.697454.3031502:12
500485.772186.7026402:44
600324.361894.5761603:16
700164.125254.2396303:47
800004.072464.1530804:22
900483.985534.1076604:53
1000324.032214.0754905:25
1100163.984284.0521905:57
1200003.972864.0315106:29
1300483.956644.0143207:00
1400323.940954.0015507:32
1500163.892463.9930908:04
1600003.905193.9891208:36
1617283.930393.9886208:46

\n", + "\n", + "

\n", + " \n", + " 100.00% [2527/2527 08:46<00:00 #1/1 loss: 3.930 / 3.989]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "train_ds, val_ds = load_datasets(datadir, subsample=.1)\n", + "model = make_model('tiny', dataset=train_ds).cuda()\n", + "train(\"aaar\", model, train_ds, val_ds, half=True, bs=64, lr=2e-3, epochs=1,\n", + " table_row_every_iters=10000, run_valid_every_iters=5000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f0c1c349", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " 100.00% [4/4 1:44:18<00:00]\n", + "
\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
samplestrainvaltime
1000322.633142.9402901:29
2000002.387742.5035902:56
3000322.288962.3259704:24
4000002.168002.2140905:51
5000322.127492.1414707:17
6000002.027032.0880108:43
7000322.016742.0538310:09
8000002.021552.0317611:36
9000321.992352.0126813:03
10000001.977151.9985514:30
11000321.969171.9904115:57
12000001.972751.9824617:24
13000321.949591.9763418:51
14000001.958981.9751420:19
15000321.937541.9652521:47
16000001.933511.9611123:14
17000321.949701.9587424:41
18000001.943571.9551526:11
19000321.941341.9502727:39
20000001.930401.9489129:07
21000321.933251.9469630:33
22000001.921481.9430532:00
23000321.920041.9406133:27
24000001.920921.9386034:53
25000321.957871.9352836:20
26000001.931981.9333437:47
27000321.908771.9307239:14
28000001.934891.9280440:40
29000321.911621.9266042:07
30000001.912131.9250643:34
31000321.917071.9253145:00
32000001.901311.9205746:27
33000321.913491.9174147:53
34000001.896221.9139349:21
35000321.895171.9097950:48
36000001.870691.9083952:17
37000321.884201.9062853:45
38000001.884631.9024455:11
39000321.885881.9002156:38
40000001.874781.8982158:05
41000321.874861.8947659:32
42000001.887961.895621:00:59
43000321.875821.889281:02:26
44000001.872361.888851:03:53
45000321.857491.884541:05:20
46000001.856801.881981:06:47
47000321.863151.879641:08:13
48000001.866281.876221:09:40
49000321.857001.871911:11:07
50000001.826711.870571:12:34
51000321.848101.867051:14:01
52000001.845301.863711:15:29
53000321.857311.861951:16:58
54000001.839101.856581:18:27
55000321.811251.853831:19:55
56000001.840711.852131:21:22
57000321.834911.848211:22:49
58000001.827191.845511:24:16
59000321.833581.842181:25:43
60000001.820791.839701:27:10
61000321.826881.837251:28:37
62000001.808941.834151:30:05
63000321.791251.831261:31:31
64000001.821401.829441:32:58
65000321.804241.827371:34:25
66000001.797181.825301:35:52
67000321.797851.823191:37:20
68000001.798351.821951:38:49
69000321.779641.821201:40:16
70000001.815861.820451:41:43
71000321.783201.819971:43:11
71749121.783371.819931:44:18

\n", + "\n", + "

\n", + " \n", + " 100.00% [28027/28027 26:07<00:00 #4/4 loss: 1.783 / 1.820]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 3k prediction (2->4)\n", + "model = AAARTransformer(depth=4).cuda()\n", + "with torch.backends.cuda.sdp_kernel(enable_mem_efficient=False):\n", + " train(\"aaar\", model, train_ds, val_ds, half=True, bs=64, lr=2e-3, epochs=4,\n", + " table_row_every_iters=100000, run_valid_every_iters=50000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1b910c87", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " 93.33% [14/15 6:05:29<26:06]\n", + "
\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
samplestrainvaltime
1000322.670102.9590301:28
2000002.450642.5109402:55
3000322.261782.3307904:21
4000002.190892.2304805:48
5000322.080602.1470207:15
6000002.055192.0935608:42
7000322.022172.0580710:08
8000002.022722.0355611:35
9000321.990632.0136213:02
10000001.982362.0027114:29
11000321.981621.9953015:56
12000001.966281.9869017:24
13000321.978911.9790118:51
14000001.979961.9767220:18
15000321.969301.9712121:47
16000001.958801.9676323:15
17000321.940401.9679724:42
18000001.957381.9603126:11
19000321.950851.9610327:38
20000001.964881.9551529:05
21000321.949921.9534330:34
22000001.958271.9534032:01
23000321.922221.9503833:28
24000001.936381.9480434:56
25000321.926911.9475636:25
26000001.937921.9427437:51
27000321.929251.9427439:18
28000001.907631.9437040:45
29000321.939541.9419342:12
30000001.908371.9383343:38
31000321.929861.9372045:06
32000001.918741.9386846:34
33000321.943811.9354148:02
34000001.918501.9331449:29
35000321.898081.9332550:56
36000001.935711.9318452:24
37000321.904551.9331753:52
38000001.916221.9318855:20
39000321.904651.9315456:46
40000001.899831.9329958:13
41000321.906131.9274959:39
42000001.929951.927161:01:07
43000321.933241.927821:02:36
44000001.916441.926341:04:03
45000321.907881.925081:05:30
46000001.923791.927601:06:57
47000321.897011.925391:08:25
48000001.897301.923861:09:52
49000321.905181.922261:11:19
50000001.901411.923441:12:46
51000321.892991.920001:14:14
52000001.916221.921091:15:41
53000321.904831.918561:17:08
54000001.874331.917881:18:37
55000321.913971.919921:20:04
56000001.887701.917601:21:31
57000321.904541.915881:22:58
58000001.896071.917441:24:24
59000321.902161.914621:25:51
60000001.886451.917031:27:18
61000321.904991.912701:28:44
62000001.881491.914581:30:13
63000321.870191.911161:31:40
64000001.891581.911241:33:07
65000321.892921.911441:34:34
66000001.882551.910211:36:01
67000321.874041.912781:37:28
68000001.872581.910541:38:56
69000321.904141.908561:40:22
70000001.903421.909531:41:50
71000321.899521.911701:43:18
72000001.901221.908811:44:47
73000321.897101.906741:46:14
74000001.896631.908651:47:40
75000321.896251.907301:49:07
76000001.896341.905041:50:35
77000321.890891.904421:52:02
78000001.903411.904551:53:29
79000321.889181.903911:54:57
80000001.877111.901121:56:24
81000321.901371.901741:57:51
82000001.891541.903911:59:18
83000321.881101.902602:00:46
84000001.872561.902762:02:14
85000321.884471.903722:03:42
86000001.890011.900172:05:09
87000321.884791.896852:06:36
88000001.900711.901392:08:04
89000321.876141.900692:09:31
90000001.890661.900132:11:01
91000321.879981.896512:12:28
92000001.886321.897772:13:55
93000321.887861.897612:15:22
94000001.872401.898042:16:48
95000321.877551.896022:18:15
96000001.886881.894602:19:42
97000321.885131.897792:21:08
98000001.861311.893952:22:35
99000321.873771.892262:24:02
100000001.890111.893992:25:29
101000321.855521.893072:26:56
102000001.875191.892802:28:23
103000321.878081.893262:29:50
104000001.856621.890572:31:17
105000321.874701.892672:32:44
106000001.864341.890572:34:11
107000321.890151.890412:35:38
108000001.874131.890272:37:08
109000321.870411.889132:38:37
110000001.872621.888922:40:05
111000321.864281.887082:41:31
112000001.883131.887692:42:58
113000321.880861.888622:44:25
114000001.873961.888012:45:52
115000321.848781.885192:47:19
116000001.875341.886982:48:46
117000321.866211.884432:50:13
118000001.865981.884062:51:40
119000321.863711.883222:53:07
120000001.870901.882482:54:33
121000321.867521.882912:56:00
122000001.867461.883952:57:26
123000321.861281.879532:58:53
124000001.879051.879883:00:20
125000321.857171.879953:01:48
126000001.864701.878753:03:16
127000321.860231.880243:04:43
128000001.871531.879763:06:11
129000321.851181.876733:07:38
130000001.861971.876963:09:05
131000321.852951.877213:10:33
132000001.862251.876823:12:00
133000321.849471.874833:13:28
134000001.853271.875163:14:55
135000321.862981.874343:16:22
136000001.842761.873603:17:49
137000321.869631.872523:19:18
138000001.853521.872663:20:45
139000321.844891.871533:22:11
140000001.869421.873713:23:38
141000321.839301.869533:25:05
142000001.849851.867843:26:32
143000321.827931.868843:27:59
144000001.834701.869083:29:28
145000321.851341.867923:30:55
146000001.852421.865973:32:23
147000321.863821.867623:33:51
148000001.848891.869083:35:18
149000321.854571.866163:36:45
150000001.855661.865363:38:12
151000321.852351.862933:39:40
152000001.830601.863933:41:08
153000321.830731.862183:42:35
154000001.849181.862293:44:01
155000321.851891.860703:45:28
156000001.846621.859163:46:54
157000321.823701.860913:48:21
158000001.818611.858223:49:49
159000321.825971.856143:51:17
160000001.853281.854793:52:46
161000321.840971.855923:54:13
162000001.831141.855533:55:41
163000321.849711.853373:57:08
164000001.807281.851593:58:34
165000321.811061.850624:00:03
166000001.819091.853324:01:30
167000321.828241.848764:02:58
168000001.823921.849714:04:25
169000321.833411.848154:05:52
170000001.838571.847984:07:20
171000321.825691.845584:08:49
172000001.825511.844734:10:16
173000321.832581.843714:11:43
174000001.825801.845324:13:10
175000321.815171.841754:14:37
176000001.835471.843234:16:04
177000321.820371.841004:17:31
178000001.826701.845384:18:58
179000321.838201.839264:20:26
180000001.814561.839754:21:55
181000321.825141.837944:23:22
182000001.811201.837424:24:49
183000321.824251.838044:26:16
184000001.811821.836864:27:43
185000321.834171.836804:29:10
186000001.814021.834544:30:37
187000321.825251.833934:32:04
188000001.808251.832334:33:32
189000321.821841.831204:34:59
190000001.837171.831414:36:26
191000321.830691.830364:37:54
192000001.791811.829464:39:21
193000321.807281.829914:40:50
194000001.816831.828534:42:17
195000321.807331.826884:43:45
196000001.812391.827254:45:12
197000321.819651.824914:46:39
198000001.783981.823844:48:09
199000321.795121.826214:49:36
200000001.799341.823994:51:03
201000321.786891.823554:52:30
202000001.807701.821194:53:58
203000321.811231.819484:55:25
204000001.802011.820604:56:52
205000321.799641.818574:58:18
206000001.793271.817534:59:45
207000321.789071.816495:01:14
208000001.814711.816075:02:41
209000321.792661.815675:04:08
210000001.791881.813625:05:35
211000321.796911.813545:07:02
212000001.793561.812935:08:29
213000321.772141.811635:09:58
214000001.791651.811565:11:25
215000321.797951.810695:12:52
216000001.790471.809195:14:20
217000321.790381.809185:15:50
218000001.798531.807245:17:17
219000321.775041.806295:18:44
220000001.770151.805835:20:11
221000321.783741.806195:21:39
222000001.766521.804075:23:06
223000321.797161.803145:24:34
224000001.784321.803095:26:02
225000321.778151.802975:27:30
226000001.760941.801555:28:57
227000321.771771.800345:30:25
228000001.775971.799065:31:52
229000321.776701.798325:33:20
230000001.785641.797855:34:47
231000321.788451.796515:36:16
232000001.771031.796345:37:43
233000321.770881.796105:39:09
234000001.771421.795195:40:38
235000321.759111.792935:42:04
236000001.770591.792935:43:31
237000321.786731.791935:44:58
238000001.770811.792175:46:26
239000321.762541.790395:47:53
240000001.775671.790015:49:20
241000321.756741.788495:50:47
242000001.767161.788735:52:13
243000321.751311.788255:53:40
244000001.768891.787535:55:07
245000321.776711.786045:56:36
246000001.761911.784425:58:02
247000321.770641.784905:59:29
248000001.730981.784116:00:56
249000321.757351.783486:02:23
250000001.764921.782906:03:50
251000321.780281.782656:05:16
252000001.753741.781596:06:45
253000321.757861.781186:08:12
254000001.732511.780696:09:38
255000321.753761.780586:11:05
256000001.752851.780066:12:31
257000321.761441.779936:13:58

\n", + "\n", + "

\n", + " \n", + " 33.52% [9394/28027 08:42<17:15 #15/15 loss: 1.746 / 1.779]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 3k prediction (2->4)\n", + "model = AAARTransformer(depth=4).cuda()\n", + "with torch.backends.cuda.sdp_kernel(enable_mem_efficient=False):\n", + " train(\"aaar\", model, train_ds, val_ds, half=True, bs=64, lr=2e-3, epochs=15,\n", + " table_row_every_iters=100000, run_valid_every_iters=50000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4a53c06", + "metadata": {}, + "outputs": [], + "source": [ + "torch.save(model.state_dict(), 'aaar-1000h-3k-15e-ce1.78.pth')" + ] + }, + { + "cell_type": "markdown", + "id": "843d6703", + "metadata": {}, + "source": [ + "# Sample from the model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b62c35a", + "metadata": {}, + "outputs": [], + "source": [ + "state = {k.removeprefix('model.'):v for k, v in torch.load('a2a-2t4.ckpt')['state_dict'].items()}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "46afee25", + "metadata": {}, + "outputs": [], + "source": [ + "model1 = make_model('base', load_datasets(datadir, subsample=.1, fromq=2, toq=4)[0]).cuda()\n", + "model1.load_state_dict(state)\n", + "model1.eval().cuda();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6f086e61", + "metadata": {}, + "outputs": [], + "source": [ + "state = {k.removeprefix('model.'):v for k, v in torch.load('a2a-4t6.ckpt')['state_dict'].items()}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c645383f", + "metadata": {}, + "outputs": [], + "source": [ + "model2 = make_model('base', load_datasets(datadir, subsample=.1, fromq=4, toq=6)[0]).cuda()\n", + "model2.load_state_dict(state)\n", + "model2.eval().cuda();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1c3ab9ce", + "metadata": {}, + "outputs": [], + "source": [ + "state = {k.removeprefix('model.'):v for k, v in torch.load('a2a-6t8')['state_dict'].items()}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c34fa3f", + "metadata": {}, + "outputs": [], + "source": [ + "model3 = make_model('base', load_datasets(datadir, subsample=.1, fromq=6, toq=8)[0]).cuda()\n", + "model3.load_state_dict(state)\n", + "model3.eval().cuda();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1a9d792c", + "metadata": {}, + "outputs": [], + "source": [ + "from encodec.model import EncodecModel\n", + "Amodel = EncodecModel.encodec_model_24khz()\n", + "Amodel.set_target_bandwidth(6)\n", + "Amodel.cuda().eval();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c353c186", + "metadata": {}, + "outputs": [], + "source": [ + "import torchaudio\n", + "\n", + "def save_wav(name, Atoks, codes=4):\n", + " with torch.no_grad():\n", + " audio = Amodel.decode([(Atoks.reshape(-1,codes).T.unsqueeze(0), torch.tensor(1).cuda())])[0]\n", + " torchaudio.save(name, audio.cpu(), 24000)\n", + " display(HTML(f'Listen to sample {name}'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "da227a3b", + "metadata": {}, + "outputs": [], + "source": [ + "dl = torch.utils.data.DataLoader(SADataset(val_data, fromq=2, toq=8), batch_size=16)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "060b485e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Dataset<5144 samples, (2->8), 3950592 Atokens, 3.7 hours>" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dl.dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f9f8ae84", + "metadata": {}, + "outputs": [], + "source": [ + "bx, by = [x.cuda().reshape((x.shape[0],-1,8)) for x in next(iter(dl))]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "145d3f4b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(torch.Size([16, 192, 8]), torch.Size([16, 192, 8]))" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bx.shape, by.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "56ec88a6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([ 62, 913, 1024, 1024, 62, 424, 1024, 1024])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "val_ds[0][0][:8]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0cc52368", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([ 62, 913, 1024, 1024, 1024, 1024, 1024, 1024, 62, 424, 1024, 1024,\n", + " 1024, 1024, 1024, 1024, 62, 424, 1024, 1024, 1024, 1024, 1024, 1024,\n", + " 62, 424, 1024, 1024, 1024, 1024, 1024, 1024, 103, 420, 1024, 1024,\n", + " 1024, 1024, 1024, 1024, 148, 973, 1024, 1024, 1024, 1024, 1024, 1024,\n", + " 537, 652, 1024, 1024, 1024, 1024, 1024, 1024, 935, 652, 1024, 1024,\n", + " 1024, 1024, 1024, 1024], device='cuda:0')" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bx[:2,:4].reshape(-1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "25578b92", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([ 62, 913, 786, 215, 528, 1011, 1002, 948, 62, 424, 786, 215,\n", + " 448, 986, 570, 975, 62, 424, 786, 741, 622, 986, 1002, 948,\n", + " 62, 424, 786, 741, 622, 986, 1002, 948, 103, 420, 878, 540,\n", + " 984, 744, 664, 506, 148, 973, 872, 359, 962, 800, 355, 940,\n", + " 537, 652, 242, 1016, 983, 919, 605, 660, 935, 652, 767, 940,\n", + " 446, 439, 543, 831], device='cuda:0')" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "by[:2,:4].reshape(-1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6522e0c6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([768, 512])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model1.encoder.positional_embedding.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca57316b", + "metadata": {}, + "outputs": [], + "source": [ + "def fwd(model, bx, by=None):\n", + " logits = []\n", + " loss = 0\n", + " with torch.no_grad():\n", + " for i in range(len(bx)):\n", + " _logits, _loss = model(bx[i:i+1].reshape(1,-1), by is not None and by[i:i+1].reshape(1,-1), loss=by)\n", + " logits.append(_logits)\n", + " if by is not None:\n", + " loss += _loss\n", + " logits = torch.cat(logits)\n", + " return logits, loss/len(bx)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de3bb03a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(1.8225, device='cuda:0')" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "logits, loss = fwd(model1, bx[:,:,:4], by[:,:,:4])\n", + "p = logits.argmax(-1).reshape(logits.shape[0],-1,4)\n", + "loss" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ab4ae928", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([16, 768, 1025])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "logits.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4be154c0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(torch.Size([16, 192, 8]), torch.Size([16, 192, 4]))" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bx.shape, p.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34203390", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(0.1947, device='cuda:0')" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(by[:,:,2:4] == p[:,:,2:4]).float().mean()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10034618", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([16, 192, 8])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bx.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "875268a8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "Listen to sample ref-1.5k.wav" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "save_wav(\"ref-1.5k.wav\", bx[:,:,:2], codes=2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "09b20a2f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "Listen to sample ref-3k.wav" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "save_wav(\"ref-3k.wav\", by.reshape(-1,4)[:,:], codes=4)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e610c656", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "Listen to sample test-3k.wav" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "save_wav('test-3k.wav', p, codes=4)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3ddcb28e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([16, 192, 6])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bx2 = torch.cat([p[:,:,:4], torch.full((by.shape[0], by.shape[1], 2), 1024).cuda()], dim=-1)\n", + "bx2.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6d807745", + "metadata": {}, + "outputs": [], + "source": [ + "logits, _ = fwd(model2, bx2.reshape(p.shape[0],-1))\n", + "p2 = logits.argmax(-1).reshape(bx2.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1a6c484", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([16, 192, 6])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p2.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c0090d2d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "Listen to sample test-4.5k.wav" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "save_wav('test-4.5k.wav', p2, codes=6)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "816685b5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([16, 192, 8])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bx3 = torch.cat([p2[:,:,:6], torch.full((by.shape[0], by.shape[1], 2), 1024).cuda()], dim=-1)\n", + "bx3.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c20ea261", + "metadata": {}, + "outputs": [], + "source": [ + "logits, _ = fwd(model3, bx3.reshape(p.shape[0],-1))\n", + "p3 = logits.argmax(-1).reshape(bx3.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "525e6ec8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([16, 192, 8])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "by.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7f3d5616", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "Listen to sample test-6k.wav" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "save_wav('test-6k.wav', p3, codes=8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "381c27b1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "Listen to sample ref-6k.wav" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "save_wav('ref-6k.wav', by, codes=8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c97240bf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(0.3344, device='cuda:0')" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(p3 == by).float().mean()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "21241e6e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "python3", + "language": "python", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/nbs/a2a-2t4.ckpt b/nbs/a2a-2t4.ckpt new file mode 100644 index 0000000..5e72534 --- /dev/null +++ b/nbs/a2a-2t4.ckpt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f59da6f7d3eae1c17f76ed3f394ad410f24bb38b80a6e419953e41d239c1aba5 +size 234949007 diff --git a/nbs/a2a-4t6.ckpt b/nbs/a2a-4t6.ckpt new file mode 100644 index 0000000..715d6a0 --- /dev/null +++ b/nbs/a2a-4t6.ckpt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2eb0b7a5bf4bce59676ab4cebbb7c84adf12a6b4342a62d4520aad550d734ac3 +size 235735439 diff --git a/nbs/a2a-6t8.ckpt b/nbs/a2a-6t8.ckpt new file mode 100644 index 0000000..9638e78 --- /dev/null +++ b/nbs/a2a-6t8.ckpt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8a9f1d5a6d7bab34414dfba1249ec0205d3e2bb2d9242d9f24fb0232e13a02bc +size 236521871 diff --git a/spear_tts_pytorch/a2a.py b/spear_tts_pytorch/a2a.py new file mode 100644 index 0000000..f10885c --- /dev/null +++ b/spear_tts_pytorch/a2a.py @@ -0,0 +1,151 @@ +# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/6. EnCodec quality enchancement.ipynb. + +# %% auto 0 +__all__ = ['load_data', 'load_datasets', 'LayerNorm', 'init_transformer', 'PureEncoder', 'AAARTransformer', 'make_model'] + +# %% ../nbs/6. EnCodec quality enchancement.ipynb 1 +import io +import time +import random + +# %% ../nbs/6. EnCodec quality enchancement.ipynb 2 +import torch +import torch.nn as nn +from torch.profiler import profile, record_function, ProfilerActivity, schedule + +# %% ../nbs/6. EnCodec quality enchancement.ipynb 3 +from pathlib import Path +import json +from fastprogress import progress_bar, master_bar +import pandas as pd + +# %% ../nbs/6. EnCodec quality enchancement.ipynb 4 +from spear_tts_pytorch.train import * +from spear_tts_pytorch.modules import * + +# %% ../nbs/6. EnCodec quality enchancement.ipynb 12 +def load_data(path): + atoks = [] + for name in Path(path).glob('*.encodec'): + atoks.append(name) + return pd.DataFrame(dict(atoks=atoks)) + +# %% ../nbs/6. EnCodec quality enchancement.ipynb 14 +import torch.nn.functional as F + +class SADataset(torch.utils.data.Dataset): + def __init__(self, data, fromq=2, toq=4): + self.fromq = fromq + self.toq = toq + self.n_ctx = 192 + self.data = data + self.samples = [(i,j) for i,name in enumerate(data['atoks']) for j in range(torch.load(name).shape[-1] // self.n_ctx)] + + def __len__(self): + return len(self.samples) + + def A_tokens(self): + return len(self)*self.n_ctx*4 + + def hours(self): + return len(self)*self.n_ctx/2250*30/3600 + + def __repr__(self): + return f"Dataset<{len(self)} samples, ({self.fromq}->{self.toq}), {self.A_tokens()} Atokens, {self.hours():.1f} hours>" + + def __getitem__(self, idx): + i,j = self.samples[idx] + row = self.data.iloc[i] + jA = j * self.n_ctx + Atoks = torch.load(row['atoks'], map_location='cpu')[0,:self.toq,jA:jA+self.n_ctx].T + outtoks = Atoks.reshape(-1).clone() + Atoks[:,self.fromq:] = 1024 # mask token + intoks = Atoks.reshape(-1).clone() + return intoks, outtoks + +# %% ../nbs/6. EnCodec quality enchancement.ipynb 20 +def load_datasets( + path:Path, # encodec files path + subsample:float=1, # use a fraction of the files + fromq:int=2, # input quantizers + toq:int=8 # output quantizers + ): + data = load_data(path) + + val_data, train_data = data[:12], data[12:int(len(data)*subsample)] + + return SADataset(train_data, fromq=fromq, toq=toq), SADataset(val_data, fromq=fromq, toq=toq) + +# %% ../nbs/6. EnCodec quality enchancement.ipynb 23 +class LayerNorm(nn.LayerNorm): + def forward(self, x): + return super().forward(x.float()).type(x.dtype) + +# based on https://github.com/karpathy/minGPT/blob/master/mingpt/model.py#L163 +def init_transformer(m): + if isinstance(m, (nn.Linear, nn.Embedding)): + torch.nn.init.trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + torch.nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + torch.nn.init.constant_(m.bias, 0) + torch.nn.init.constant_(m.weight, 1.0) + +class PureEncoder(nn.Module): + def __init__(self, depth=6, width=384, n_head=6, length=1500, codes=1024, pos_embs=None): + super().__init__() + self.length = length + self.codes = codes + + # embed semantic tokens + self.embedding = nn.Embedding(codes+1, width) + if pos_embs is None: pos_embs = sinusoids(length, width) + self.register_buffer("positional_embedding", pos_embs) + + self.layers = nn.ModuleList([ + ResidualAttentionBlock(width, n_head) for _ in range(depth) + ]) + self.ln_post = LayerNorm(width) + + self.apply(init_transformer) + + def forward(self, Stoks): + Sembs = self.embedding(Stoks) + + xin = (Sembs + self.positional_embedding[:Sembs.shape[1]]) + + x = xin + for l in self.layers: x = l(x, causal=False) + + x = self.ln_post(x) + + logits = (x @ self.embedding.weight.to(x.dtype).T).float() + return logits + +# %% ../nbs/6. EnCodec quality enchancement.ipynb 24 +class AAARTransformer(nn.Module): + def __init__(self, width=384, depth=4, ctx_n=250, n_head=6, fromq=2, toq=4): + super().__init__() + + pos_embs = sinusoids(ctx_n * toq, width) + + self.encoder = PureEncoder(pos_embs=pos_embs, length=ctx_n*toq, width=width, n_head=n_head, depth=depth) + + def forward(self, intoks, outtoks, loss=True): + with record_function("decoder"): + logits = self.encoder(intoks) + if loss is not None: + with record_function("loss"): + loss = F.cross_entropy(logits.reshape(-1,logits.shape[-1]), outtoks.view(-1)) + return logits, loss + +# %% ../nbs/6. EnCodec quality enchancement.ipynb 25 +def make_model(size:str, dataset:torch.utils.data.Dataset=None): + assert(dataset is not None) + kwargs = dict(fromq = dataset.fromq, toq = dataset.toq, ctx_n = dataset.n_ctx) + if size == 'tiny': + return AAARTransformer(depth=4, **kwargs) + elif size == 'base': + return AAARTransformer(depth=6, width=512, n_head=8, **kwargs) + elif size == 'small': + return AAARTransformer(depth=12, width=768, n_head=12, **kwargs)