diff --git "a/src/musicgen_test copy.ipynb" "b/src/musicgen_test copy.ipynb" new file mode 100644--- /dev/null +++ "b/src/musicgen_test copy.ipynb" @@ -0,0 +1,1036 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import torchaudio\n", + "import numpy as np\n", + "import torch\n", + "from tqdm import tqdm\n", + "import einops" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/ckadirt/miniconda3/envs/b2m/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "Could not find image processor class in the image processor config or the model config. Loading based on pattern matching with the model's feature extractor configuration.\n" + ] + } + ], + "source": [ + "from datasets import load_dataset, Audio\n", + "from transformers import EncodecModel, AutoProcessor\n", + "\n", + "\n", + "# load a demonstration datasets\n", + "librispeech_dummy = load_dataset(\"hf-internal-testing/librispeech_asr_dummy\", \"clean\", split=\"validation\")\n", + "\n", + "# load the model + processor (for pre-processing the audio)\n", + "model = EncodecModel.from_pretrained(\"facebook/encodec_24khz\")\n", + "processor = AutoProcessor.from_pretrained(\"facebook/encodec_24khz\")\n", + "\n", + "# cast the audio data to the correct sampling rate for the model\n", + "librispeech_dummy = librispeech_dummy.cast_column(\"audio\", Audio(sampling_rate=processor.sampling_rate))\n", + "audio_sample = librispeech_dummy[0][\"audio\"][\"array\"]\n", + "\n", + "# pre-process the inputs\n", + "inputs = processor(raw_audio=audio_sample, sampling_rate=processor.sampling_rate, return_tensors=\"pt\")\n", + "\n", + "# explicitly encode then decode the audio inputs\n", + "encoder_outputs = model.encode(inputs[\"input_values\"], inputs[\"padding_mask\"])\n", + "audio_values = model.decode(encoder_outputs.audio_codes, encoder_outputs.audio_scales, inputs[\"padding_mask\"])[0]\n", + "\n", + "# or the equivalent with a forward pass\n", + "audio_values = model(inputs[\"input_values\"], inputs[\"padding_mask\"]).audio_values\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 1, 2, 150])\n", + "torch.Size([1, 47999])\n" + ] + } + ], + "source": [ + "def get_encoder_outputs(paths):\n", + " input_values = []\n", + " padding_masks = []\n", + " for path in paths:\n", + " audio_loaded, sr = torchaudio.load(path)\n", + " audio_loaded = torchaudio.transforms.Resample(sr, 24000)(audio_loaded)\n", + " #print(audio_loaded.shape)\n", + " # take just the 0.1333333 part of the audio\n", + " audio_loaded = audio_loaded[:, int(audio_loaded.shape[1] * 0.133333333):int(audio_loaded.shape[1] * 0.133333333) * 2]\n", + " #print(audio_loaded.shape)\n", + " audio_sample = processor(raw_audio=audio_loaded[0], sampling_rate=24000, return_tensors=\"pt\")\n", + " input_values.append(audio_sample[\"input_values\"])\n", + " padding_masks.append(audio_sample[\"padding_mask\"])\n", + " \n", + " input_values = torch.cat(input_values, dim=0)\n", + " padding_masks = torch.cat(padding_masks, dim=0)\n", + " sr = 24000\n", + " encoder_outputs = model.encode(input_values, padding_masks)\n", + " return encoder_outputs, audio_sample\n", + "\n", + "def get_reconstructed_audio(encoder_outputs, audio_sample):\n", + " print(encoder_outputs.audio_codes.shape)\n", + " print(audio_sample[\"padding_mask\"].shape)\n", + " audio_values = model.decode(encoder_outputs.audio_codes, encoder_outputs.audio_scales, audio_sample[\"padding_mask\"])[0]\n", + " return audio_values\n", + "\n", + "\n", + "embeddings, another_info = get_encoder_outputs(['/home/ckadirt/brain2music/dataset/preproc/genres_preproc/Stim_Test_Run01_30_pop.wav'])\n", + "reconstructed = get_reconstructed_audio(embeddings, another_info)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 47999])\n" + ] + } + ], + "source": [ + "reconstructed = reconstructed[0]\n", + "print(reconstructed.shape)\n", + "torchaudio.save('first2second.wav', reconstructed, 24000)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1, 1, 2, 150])" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# read this tokens /home/ckadirt/Downloads/outputs_train397.pt\n", + "tokens = torch.load('/home/ckadirt/Downloads/outputs_train397.pt', map_location=torch.device('cpu'))\n", + "tokens.shape\n", + "# first song\n", + "first_song = einops.rearrange(tokens[152], '(u u2 c c1)-> u2 u c c1', c=2, u=1, u2=1)\n", + "first_song.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "# reconstruct\n", + "reconstructed = model.decode(first_song, [None], torch.ones(torch.Size([1, 47999])))" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "reconstructed.audio_values.shape\n", + "# save the reconstructed audio\n", + "torchaudio.save('train_reconstructed.wav', reconstructed.audio_values[0], 24000)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1, 1, 360000])" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "another_info.input_values.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "480it [00:52, 9.19it/s]\n" + ] + } + ], + "source": [ + "wav_paths = '/home/ckadirt/brain2music/dataset/preproc/genres_preproc'\n", + "\n", + "# get a list of all the wav files\n", + "wav_files = [os.path.join(wav_paths, f) for f in os.listdir(wav_paths) if f.endswith(\".wav\")]\n", + "\n", + "# if the path has Training in it, it's a training file\n", + "training_wav_files = [f for f in wav_files if \"Training\" in f]\n", + "test_wav_files = [f for f in wav_files if \"Test\" in f]\n", + "\n", + "\n", + "def get_embeddings(audios_paths):\n", + " embeddings = torch.zeros((len(audios_paths), 2, 150))\n", + " for i, path in tqdm(enumerate(audios_paths)):\n", + " encoder_outputs, audio_sample = get_encoder_outputs([path])\n", + " if (encoder_outputs.audio_codes.shape != (1, 1, 2, 150)):\n", + " print(\"There's a problem with the audio: \", path)\n", + " print(\"The shape is: \", encoder_outputs.audio_codes.shape)\n", + " embeddings[i] = encoder_outputs.audio_codes[0][0]\n", + " return embeddings\n", + "\n", + "training_embeds = get_embeddings(training_wav_files)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "240it [00:27, 8.68it/s]\n" + ] + } + ], + "source": [ + "test_embeds = get_embeddings(test_wav_files)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[[ 507., 948., 532., ..., 974., 912., 263.],\n", + " [ 945., 612., 1000., ..., 285., 509., 432.]],\n", + "\n", + " [[ 926., 685., 988., ..., 580., 478., 485.],\n", + " [ 973., 973., 447., ..., 555., 101., 555.]],\n", + "\n", + " [[ 511., 916., 372., ..., 974., 974., 974.],\n", + " [ 761., 973., 197., ..., 764., 764., 594.]],\n", + "\n", + " ...,\n", + "\n", + " [[ 213., 830., 830., ..., 375., 567., 548.],\n", + " [ 779., 330., 435., ..., 685., 264., 264.]],\n", + "\n", + " [[ 38., 511., 731., ..., 246., 806., 891.],\n", + " [ 370., 908., 370., ..., 269., 902., 898.]],\n", + "\n", + " [[ 302., 244., 660., ..., 951., 962., 485.],\n", + " [ 963., 645., 645., ..., 655., 163., 81.]]])" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_embeds" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "# save the training embeddings\n", + "np.save(\"encodec_training_embeds_150.npy\", training_embeds)\n", + "np.save(\"encodec_test_embeds_150.npy\", test_embeds)" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": {}, + "outputs": [], + "source": [ + "train_dir = '/home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/train'\n", + "audios_train_paths = os.listdir(train_dir)\n", + "\n", + "test_dir = '/home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/test'\n", + "audios_test_paths = os.listdir(test_dir)\n", + "\n", + "def get_embeddings(audios_paths):\n", + " embeddings = torch.zeros((len(audios_paths), 2, 1125))\n", + " for i, path in tqdm(enumerate(audios_paths)):\n", + " embeddings_s, another_info = get_encoder_outputs([path])\n", + " if (embeddings_s.audio_codes.shape != (1,1,2,1125)):\n", + " print(\"There's a problem with the audio: \", path)\n", + " print(\"The shape is: \", embeddings_s.audio_codes.shape)\n", + " embeddings[i] = embeddings_s.audio_codes[0][0][0][:][:1125]\n", + "\n", + " return embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 1, 2, 200])\n", + "torch.Size([1, 64000])\n" + ] + } + ], + "source": [ + "embed = torch.Tensor([ 408., 395., 25., 537., 537., 999., 228., 537., 731., 753.,\n", + " 499., 999., 325., 731., 834., 499., 731., 1011., 731., 228.,\n", + " 731., 677., 666., 860., 495., 409., 602., 783., 731., 192.,\n", + " 977., 843., 192., 602., 731., 731., 740., 461., 461., 957.,\n", + " 461., 511., 497., 511., 854., 872., 213., 729., 335., 764.,\n", + " 731., 777., 237., 598., 666., 627., 327., 972., 246., 461.,\n", + " 307., 246., 330., 511., 602., 806., 246., 372., 513., 729.,\n", + " 729., 854., 246., 511., 788., 788., 854., 788., 492., 513.,\n", + " 729., 541., 13., 854., 740., 731., 549., 806., 144., 372.,\n", + " 329., 1023., 788., 854., 511., 645., 854., 361., 854., 854.,\n", + " 789., 602., 628., 790., 789., 951., 368., 329., 900., 650.,\n", + " 400., 951., 654., 915., 157., 659., 141., 420., 729., 157.,\n", + " 854., 715., 788., 511., 246., 804., 335., 307., 854., 263.,\n", + " 854., 970., 800., 154., 385., 1008., 580., 854., 226., 246.,\n", + " 335., 790., 715., 789., 854., 679., 833., 806., 923., 854.,\n", + " 854., 729., 740., 573., 167., 226., 480., 385., 341., 715.,\n", + " 843., 226., 602., 854., 854., 33., 1023., 4., 683., 361.,\n", + " 801., 329., 854., 431., 891., 335., 335., 854., 854., 650.,\n", + " 645., 580., 997., 854., 132., 329., 854., 573., 951., 368.,\n", + " 715., 814., 330., 564., 541., 603., 735., 960., 729., 659.])\n", + "embed.unsqueeze_(0)\n", + "embed = torch.cat([embed, embed], dim=0)\n", + "embed.unsqueeze_(0)\n", + "embed.unsqueeze_(0)\n", + "embed = embed.int()\n", + "print(embed.shape)\n", + "model.eval()\n", + "with torch.no_grad():\n", + " audio = model.decode(embed, audio_scales=[None], padding_mask=torch.ones(1,360000))[0][0]\n", + " print(audio.shape)\n", + " torchaudio.save('test.wav', audio, 24000)" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "1it [00:00, 1.87it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/train/00285-pop-8.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# get the audio_path 73\n", + "audio_path_73 = os.path.join(train_dir, audios_train_paths[73])\n", + "# get its embeddings\n", + "embeddings_73 = get_embeddings([audio_path_73])" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1, 2, 1125])" + ] + }, + "execution_count": 129, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "embeddings_73.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Getting embeddings for train audios...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "74it [00:36, 2.05it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/train/00285-pop-8.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "117it [00:56, 2.14it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/train/00449-jazz-13.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "131it [01:03, 2.14it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/train/00247-disco-12.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "179it [01:25, 2.17it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/train/00381-metal-6.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "274it [02:09, 2.16it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/train/00419-blues-38.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "289it [02:16, 2.16it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/train/00065-country-46.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "308it [02:25, 2.15it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/train/00028-pop-92.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "316it [02:28, 2.15it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/train/00077-rock-76.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "437it [03:25, 2.17it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/train/00212-rock-91.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "440it [03:26, 2.15it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/train/00313-disco-30.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "442it [03:27, 2.12it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/train/00273-jazz-99.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "457it [03:34, 2.14it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/train/00356-reggae-9.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "473it [03:42, 2.13it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/train/00135-country-95.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "480it [03:45, 2.13it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Getting embeddings for test audios...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2it [00:00, 2.09it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/test/00078-blues-40.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "27it [00:12, 2.11it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/test/00058-blues-40.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "51it [00:24, 2.12it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/test/00048-blues-40.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "116it [00:55, 2.10it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/test/00068-blues-40.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "124it [00:59, 2.07it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/test/00011-pop-32.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "175it [01:23, 2.08it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/test/00021-pop-32.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "202it [01:36, 2.10it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/test/00001-pop-32.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "236it [01:52, 2.09it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There's a problem with the audio: /home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/test/00031-pop-32.wav\n", + "The shape is: torch.Size([1, 1, 2, 1126])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "240it [01:54, 2.09it/s]\n" + ] + } + ], + "source": [ + "print('Getting embeddings for train audios...')\n", + "train_embeddings = get_embeddings([os.path.join(train_dir, path) for path in audios_train_paths])\n", + "print('Getting embeddings for test audios...')\n", + "test_embeddings = get_embeddings([os.path.join(test_dir, path) for path in audios_test_paths])" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": {}, + "outputs": [], + "source": [ + "# save the embeddings\n", + "torch.save(train_embeddings, '/home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/encodec_embeddings_train.pt')\n", + "torch.save(test_embeddings, '/home/ckadirt/brain2music/dataset/Gtanz/audios/sub-001/encodec_embeddings_test.pt')" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([240, 2, 1125])" + ] + }, + "execution_count": 135, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_embeddings.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# save the train embeddings\n", + "np.save('train_embeddings_encodec.npy', train_embeddings)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# recunstruct and save the first audio\n", + "torchaudio.save(\"reconstructed1.wav\", reconstructed[0], 24000)\n", + "# now the second\n", + "torchaudio.save(\"reconstructed2.wav\", reconstructed[1], 24000)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(-2.5186e-05, grad_fn=) tensor(0.0567, grad_fn=) tensor(0.5089, grad_fn=)\n", + "tensor(562.4698) tensor(292.6277) tensor(1023.) tensor(0.)\n" + ] + } + ], + "source": [ + "# get the mean, std, and max of the audio values\n", + "print(audio_values.mean(), audio_values.std(), audio_values.max())\n", + "# get the mean, std, and max of the audio codes\n", + "print(embeddings.audio_codes.float().mean(), embeddings.audio_codes.float().std(), embeddings.audio_codes.float().max(), embeddings.audio_codes.float().min())" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "# change random values in the audio codes with a n% probability (the random values are between 0 and 1023 integers)\n", + "# this is to simulate a bit error rate\n", + "\n", + "def randomizeEmbeddings(embeddings, error):\n", + " # make a copy of the embeddings to modify\n", + " embeddings_copy = embeddings.copy()\n", + " embeddingsTensor = embeddings_copy.audio_codes\n", + " # get a random mask of the same shape as the embeddings tensor\n", + " mask = torch.rand(embeddingsTensor.shape) < error\n", + " # get a random tensor of the same shape as the embeddings tensor\n", + " randomTensor = torch.randint_like(embeddingsTensor, 0, 1024)\n", + " # apply the mask to the random tensor\n", + " randomTensor = randomTensor * mask\n", + " # apply the mask to the embeddings tensor\n", + " embeddingsTensor = embeddingsTensor * (~mask)\n", + " # add the random tensor to the embeddings tensor\n", + " embeddingsTensor = embeddingsTensor + randomTensor\n", + " # return the embeddings tensor\n", + " embeddings_copy.audio_codes = embeddingsTensor\n", + " return embeddings_copy\n", + "\n", + "noised_embeddings = randomizeEmbeddings(embeddings, 0.4)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "reconstructed_noised = get_reconstructed_audio(noised_embeddings, another_info)\n", + "# save the audio\n", + "torchaudio.save(\"reconstructed_noised.wav\", reconstructed_noised[0].detach().cpu(), 24000)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1, 1, 2, 1125])" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "embeddings.audio_codes.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "audio_sample.shape\n", + "# plot the original audio\n", + "import matplotlib.pyplot as plt\n", + "plt.plot(audio_sample)\n", + "plt.show()\n", + "\n", + "# save the original audio\n", + "import torchaudio\n", + "import torch\n", + "torchaudio.save(\"original.wav\", torch.tensor(audio_sample).unsqueeze(0).float(), processor.sampling_rate)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "24000\n" + ] + } + ], + "source": [ + "print(processor.sampling_rate)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import torchaudio \n", + "import IPython\n", + "\n", + "audio_values_single = audio_values[0][0].detach().cpu().numpy()\n", + "audio_values_single.shape\n", + "\n", + "# display the original audio\n", + "torchaudio.save(\"original.wav\", torch.tensor(audio_sample).unsqueeze(0).float(), processor.sampling_rate)\n", + "IPython.display.Audio(\"original.wav\")\n", + "\n", + "# display the reconstructed audio\n", + "torchaudio.save(\"reconstructed.wav\", torch.tensor(audio_values_single).unsqueeze(0).float(), processor.sampling_rate)\n", + "IPython.display.Audio(\"reconstructed.wav\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}