{ "cells": [ { "cell_type": "markdown", "source": [ "# Installing packages\n" ], "metadata": { "id": "Lzjey2fi4flA" } }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "0eVlMYyoMGNK" }, "outputs": [], "source": [ "!pip install tensorflow\n", "!pip install soundfile \n", "!pip install --no-deps torchaudio\n", "!pip install pillow\n", "!pip install scipy\n", "!pip install matplotlib\n", "!pip install scikit-image\n", "!pip install librosa\n", "!pip install torch\n", "!pip install tqdm\n", "!pip install h5py==2.10.0" ] }, { "cell_type": "markdown", "source": [ "# Mounting drive" ], "metadata": { "id": "867I6CSm4_8I" } }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "CAmiyxtl2J5s", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "83c13ae5-a973-48d1-99a1-b8675e9cd9c0" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Mounted at /content/drive\n" ] } ], "source": [ "#Connecting Drive to save model checkpoints during training and to use custom data\n", "\n", "import os\n", "from google.colab import drive\n", "drive.mount('/content/drive')" ] }, { "cell_type": "markdown", "source": [ "# Importing packages" ], "metadata": { "id": "yp7yev4U5R2b" } }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "LEvqwT96l_Yq" }, "outputs": [], "source": [ "#Imports\n", "import tensorflow as tf\n", "from __future__ import print_function, division\n", "from glob import glob\n", "import scipy\n", "import soundfile as sf\n", "import matplotlib.pyplot as plt\n", "from IPython.display import clear_output\n", "from tensorflow.keras.layers import Input, Dense, Reshape, Flatten, Concatenate, Conv2D, Conv2DTranspose, GlobalAveragePooling2D, UpSampling2D, LeakyReLU, ReLU, Add, Multiply, Lambda, Dot, BatchNormalization, Activation, ZeroPadding2D, Cropping2D, Cropping1D\n", "from tensorflow.keras.models import Sequential, Model, load_model\n", "from tensorflow.keras.optimizers import Adam\n", "from tensorflow.keras.initializers import TruncatedNormal, he_normal\n", "import tensorflow.keras.backend as K\n", "import datetime\n", "import numpy as np\n", "import random\n", "import matplotlib.pyplot as plt\n", "import collections\n", "from PIL import Image\n", "from skimage.transform import resize\n", "import imageio\n", "import librosa\n", "import librosa.display\n", "from librosa.feature import melspectrogram\n", "import os\n", "import time\n", "import IPython" ] }, { "cell_type": "markdown", "source": [ "# Defining Hyperparameters" ], "metadata": { "id": "MjKq3GPD5Weq" } }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "KbaM4WKrvO7r" }, "outputs": [], "source": [ "#Hyperparameters\n", "\n", "hop=192 #hop size (window size = 6*hop)\n", "sr=16000 #sampling rate\n", "min_level_db=-100 #reference values to normalize data\n", "ref_level_db=20\n", "\n", "shape=24 #length of time axis of split specrograms to feed to generator \n", "vec_len=128 #length of vector generated by siamese vector\n", "bs = 16 #batch size\n", "delta = 2. #constant for siamese loss" ] }, { "cell_type": "markdown", "source": [ "# Data preprocessing" ], "metadata": { "id": "qgApQPC95aer" } }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "K9pIPj9hnyJ0" }, "outputs": [], "source": [ "#There seems to be a problem with Tensorflow STFT, so we'll be using pytorch to handle offline mel-spectrogram generation and waveform reconstruction\n", "#For waveform reconstruction, a gradient-based method is used:\n", "\n", "''' Decorsière, Rémi, Peter L. Søndergaard, Ewen N. MacDonald, and Torsten Dau. \n", "\"Inversion of auditory spectrograms, traditional spectrograms, and other envelope representations.\" \n", "IEEE/ACM Transactions on Audio, Speech, and Language Processing 23, no. 1 (2014): 46-56.'''\n", "\n", "#ORIGINAL CODE FROM https://github.com/yoyololicon/spectrogram-inversion\n", "\n", "import torch\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "from tqdm import tqdm\n", "from functools import partial\n", "import math\n", "import heapq\n", "from torchaudio.transforms import MelScale, Spectrogram\n", "\n", "torch.set_default_tensor_type('torch.cuda.FloatTensor')\n", "\n", "specobj = Spectrogram(n_fft=6*hop, win_length=6*hop, hop_length=hop, pad=0, power=2, normalized=True)\n", "specfunc = specobj.forward\n", "melobj = MelScale(n_mels=hop, sample_rate=sr, f_min=0.,n_stft=577)\n", "melfunc = melobj.forward\n", "\n", "def melspecfunc(waveform):\n", " specgram = specfunc(waveform)\n", " mel_specgram = melfunc(specgram)\n", " return mel_specgram\n", "\n", "def spectral_convergence(input, target):\n", " return 20 * ((input - target).norm().log10() - target.norm().log10())\n", "\n", "def GRAD(spec, transform_fn, samples=None, init_x0=None, maxiter=1000, tol=1e-6, verbose=1, evaiter=10, lr=0.003):\n", "\n", " spec = torch.Tensor(spec)\n", " samples = (spec.shape[-1]*hop)-hop\n", "\n", " if init_x0 is None:\n", " init_x0 = spec.new_empty((1,samples)).normal_(std=1e-6)\n", " x = nn.Parameter(init_x0)\n", " T = spec\n", "\n", " criterion = nn.L1Loss()\n", " optimizer = torch.optim.Adam([x], lr=lr)\n", "\n", " bar_dict = {}\n", " metric_func = spectral_convergence\n", " bar_dict['spectral_convergence'] = 0\n", " metric = 'spectral_convergence'\n", "\n", " init_loss = None\n", " with tqdm(total=maxiter, disable=not verbose) as pbar:\n", " for i in range(maxiter):\n", " optimizer.zero_grad()\n", " V = transform_fn(x)\n", " loss = criterion(V, T)\n", " loss.backward()\n", " optimizer.step()\n", " lr = lr*0.9999\n", " for param_group in optimizer.param_groups:\n", " param_group['lr'] = lr\n", "\n", " if i % evaiter == evaiter - 1:\n", " with torch.no_grad():\n", " V = transform_fn(x)\n", " bar_dict[metric] = metric_func(V, spec).item()\n", " l2_loss = criterion(V, spec).item()\n", " pbar.set_postfix(**bar_dict, loss=l2_loss)\n", " pbar.update(evaiter)\n", "\n", " return x.detach().view(-1).cpu()\n", "\n", "def normalize(S):\n", " return np.clip((((S - min_level_db) / -min_level_db)*2.)-1., -1, 1)\n", "\n", "def denormalize(S):\n", " return (((np.clip(S, -1, 1)+1.)/2.) * -min_level_db) + min_level_db\n", "\n", "def prep(wv,hop=192):\n", " S = np.array(torch.squeeze(melspecfunc(torch.Tensor(wv).view(1,-1))).detach().cpu())\n", " S = librosa.power_to_db(S)-ref_level_db\n", " return normalize(S)\n", "\n", "def deprep(S):\n", " S = denormalize(S)+ref_level_db\n", " S = librosa.db_to_power(S)\n", " wv = GRAD(np.expand_dims(S,0), melspecfunc, maxiter=2000, evaiter=10, tol=1e-8)\n", " return np.array(np.squeeze(wv))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "YNRYjsCDqDjF" }, "outputs": [], "source": [ "#Helper functions\n", "\n", "#Generate spectrograms from waveform array\n", "def tospec(data):\n", " specs=np.empty(data.shape[0], dtype=object)\n", " for i in range(data.shape[0]):\n", " x = data[i]\n", " S=prep(x)\n", " S = np.array(S, dtype=np.float32)\n", " specs[i]=np.expand_dims(S, -1)\n", " print(specs.shape)\n", " return specs\n", "\n", "#Generate multiple spectrograms with a determined length from single wav file\n", "def tospeclong(path, length=4*16000):\n", " x, sr = librosa.load(path,sr=16000)\n", " x,_ = librosa.effects.trim(x)\n", " loudls = librosa.effects.split(x, top_db=50)\n", " xls = np.array([])\n", " for interv in loudls:\n", " xls = np.concatenate((xls,x[interv[0]:interv[1]]))\n", " x = xls\n", " num = x.shape[0]//length\n", " specs=np.empty(num, dtype=object)\n", " for i in range(num-1):\n", " a = x[i*length:(i+1)*length]\n", " S = prep(a)\n", " S = np.array(S, dtype=np.float32)\n", " try:\n", " sh = S.shape\n", " specs[i]=S\n", " except AttributeError:\n", " print('spectrogram failed')\n", " print(specs.shape)\n", " return specs\n", "\n", "#Waveform array from path of folder containing wav files\n", "def audio_array(path):\n", " ls = glob(f'{path}/*.wav')\n", " adata = []\n", " for i in range(len(ls)):\n", " try:\n", " x, sr = tf.audio.decode_wav(tf.io.read_file(ls[i]), 1)\n", " except:\n", " print(ls[i],\"is broken\")\n", " continue\n", " x = np.array(x, dtype=np.float32)\n", " adata.append(x)\n", " return np.array(adata)\n", "\n", "#Concatenate spectrograms in array along the time axis\n", "def testass(a):\n", " but=False\n", " con = np.array([])\n", " nim = a.shape[0]\n", " for i in range(nim):\n", " im = a[i]\n", " im = np.squeeze(im)\n", " if not but:\n", " con=im\n", " but=True\n", " else:\n", " con = np.concatenate((con,im), axis=1)\n", " return np.squeeze(con)\n", "\n", "#Split spectrograms in chunks with equal size\n", "def splitcut(data):\n", " ls = []\n", " mini = 0\n", " minifinal = 10*shape #max spectrogram length\n", " for i in range(data.shape[0]-1):\n", " if data[i].shape[1]<=data[i+1].shape[1]:\n", " mini = data[i].shape[1]\n", " else:\n", " mini = data[i+1].shape[1]\n", " if mini>=3*shape and mini=3*shape:\n", " for n in range(x.shape[1]//minifinal):\n", " ls.append(x[:,n*minifinal:n*minifinal+minifinal,:])\n", " ls.append(x[:,-minifinal:,:])\n", " return np.array(ls)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "tK_UnhfMELHD", "outputId": "69f4326a-1245-44bc-c48a-fc61ae4cd795" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "(500,)\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ ":49: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", " return np.array(adata)\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "(500,)\n" ] } ], "source": [ "#Generating Mel-Spectrogram dataset (Uncomment where needed)\n", "#adata: source spectrograms\n", "#bdata: target spectrograms\n", "source_audio_directory = \"/content/drive/MyDrive/Datasets/mixed_data\" #@param {type:\"string\"}\n", "target_audio_directory = \"/content/drive/MyDrive/Datasets/lofi_data\" #@param {type:\"string\"}\n", "#Source\n", "awv = audio_array(source_audio_directory) #get waveform array from folder containing wav files\n", "aspec = tospec(awv) #get spectrogram array\n", "adata = splitcut(aspec) #split spectrogams to fixed length\n", "#Target\n", "bwv = audio_array(target_audio_directory) \n", "bspec = tospec(bwv) \n", "bdata = splitcut(bspec) " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "qSesIbwr_GyO" }, "outputs": [], "source": [ "#Creating Tensorflow Datasets\n", "\n", "@tf.function\n", "def proc(x):\n", " return tf.image.random_crop(x, size=[hop, 3*shape, 1])\n", "\n", "dsb = tf.data.Dataset.from_tensor_slices(bdata).repeat(50).map(proc, num_parallel_calls=tf.data.experimental.AUTOTUNE).shuffle(10000).batch(bs, drop_remainder=True)\n", "dsa = tf.data.Dataset.from_tensor_slices(adata).repeat(50).map(proc, num_parallel_calls=tf.data.experimental.AUTOTUNE).shuffle(10000).batch(bs, drop_remainder=True)\n", "\n" ] }, { "cell_type": "markdown", "source": [ "# Model architecture" ], "metadata": { "id": "x9td87vB6sza" } }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "AHnP2zr7Ypgi" }, "outputs": [], "source": [ "#Adding Spectral Normalization to convolutional layers\n", "\n", "from tensorflow.python.keras.utils import conv_utils\n", "from tensorflow.python.ops import array_ops\n", "from tensorflow.python.ops import math_ops\n", "from tensorflow.python.ops import sparse_ops\n", "from tensorflow.python.ops import gen_math_ops\n", "from tensorflow.python.ops import standard_ops\n", "from tensorflow.python.eager import context\n", "from tensorflow.python.framework import tensor_shape\n", "\n", "def l2normalize(v, eps=1e-12):\n", " return v / (tf.norm(v) + eps)\n", "\n", "\n", "class ConvSN2D(tf.keras.layers.Conv2D):\n", "\n", " def __init__(self, filters, kernel_size, power_iterations=1, **kwargs):\n", " super(ConvSN2D, self).__init__(filters, kernel_size, **kwargs)\n", " self.power_iterations = power_iterations\n", "\n", "\n", " def build(self, input_shape):\n", " super(ConvSN2D, self).build(input_shape)\n", "\n", " if self.data_format == 'channels_first':\n", " channel_axis = 1\n", " else:\n", " channel_axis = -1\n", "\n", " self.u = self.add_weight(self.name + '_u',\n", " shape=tuple([1, self.kernel.shape.as_list()[-1]]), \n", " initializer=tf.initializers.RandomNormal(0, 1),\n", " trainable=False\n", " )\n", "\n", " def compute_spectral_norm(self, W, new_u, W_shape):\n", " for _ in range(self.power_iterations):\n", "\n", " new_v = l2normalize(tf.matmul(new_u, tf.transpose(W)))\n", " new_u = l2normalize(tf.matmul(new_v, W))\n", " \n", " sigma = tf.matmul(tf.matmul(new_v, W), tf.transpose(new_u))\n", " W_bar = W/sigma\n", "\n", " with tf.control_dependencies([self.u.assign(new_u)]):\n", " W_bar = tf.reshape(W_bar, W_shape)\n", "\n", " return W_bar\n", "\n", " def convolution_op(self, inputs, kernel):\n", " if self.padding == \"causal\":\n", " tf_padding = \"VALID\" # Causal padding handled in `call`.\n", " elif isinstance(self.padding, str):\n", " tf_padding = self.padding.upper()\n", " else:\n", " tf_padding = self.padding\n", "\n", " return tf.nn.convolution(\n", " inputs,\n", " kernel,\n", " strides=list(self.strides),\n", " padding=tf_padding,\n", " dilations=list(self.dilation_rate),\n", " )\n", " def call(self, inputs):\n", " W_shape = self.kernel.shape.as_list()\n", " W_reshaped = tf.reshape(self.kernel, (-1, W_shape[-1]))\n", " new_kernel = self.compute_spectral_norm(W_reshaped, self.u, W_shape)\n", " outputs = self.convolution_op(inputs, new_kernel)\n", "\n", " if self.use_bias:\n", " if self.data_format == 'channels_first':\n", " outputs = tf.nn.bias_add(outputs, self.bias, data_format='NCHW')\n", " else:\n", " outputs = tf.nn.bias_add(outputs, self.bias, data_format='NHWC')\n", " if self.activation is not None:\n", " return self.activation(outputs)\n", "\n", " return outputs\n", "\n", "\n", "class ConvSN2DTranspose(tf.keras.layers.Conv2DTranspose):\n", "\n", " def __init__(self, filters, kernel_size, power_iterations=1, **kwargs):\n", " super(ConvSN2DTranspose, self).__init__(filters, kernel_size, **kwargs)\n", " self.power_iterations = power_iterations\n", "\n", "\n", " def build(self, input_shape):\n", " super(ConvSN2DTranspose, self).build(input_shape)\n", "\n", " if self.data_format == 'channels_first':\n", " channel_axis = 1\n", " else:\n", " channel_axis = -1\n", "\n", " self.u = self.add_weight(self.name + '_u',\n", " shape=tuple([1, self.kernel.shape.as_list()[-1]]), \n", " initializer=tf.initializers.RandomNormal(0, 1),\n", " trainable=False\n", " )\n", "\n", " def compute_spectral_norm(self, W, new_u, W_shape):\n", " for _ in range(self.power_iterations):\n", "\n", " new_v = l2normalize(tf.matmul(new_u, tf.transpose(W)))\n", " new_u = l2normalize(tf.matmul(new_v, W))\n", " \n", " sigma = tf.matmul(tf.matmul(new_v, W), tf.transpose(new_u))\n", " W_bar = W/sigma\n", "\n", " with tf.control_dependencies([self.u.assign(new_u)]):\n", " W_bar = tf.reshape(W_bar, W_shape)\n", "\n", " return W_bar\n", "\n", " def call(self, inputs):\n", " W_shape = self.kernel.shape.as_list()\n", " W_reshaped = tf.reshape(self.kernel, (-1, W_shape[-1]))\n", " new_kernel = self.compute_spectral_norm(W_reshaped, self.u, W_shape)\n", "\n", " inputs_shape = array_ops.shape(inputs)\n", " batch_size = inputs_shape[0]\n", " if self.data_format == 'channels_first':\n", " h_axis, w_axis = 2, 3\n", " else:\n", " h_axis, w_axis = 1, 2\n", "\n", " height, width = inputs_shape[h_axis], inputs_shape[w_axis]\n", " kernel_h, kernel_w = self.kernel_size\n", " stride_h, stride_w = self.strides\n", "\n", " if self.output_padding is None:\n", " out_pad_h = out_pad_w = None\n", " else:\n", " out_pad_h, out_pad_w = self.output_padding\n", "\n", " out_height = conv_utils.deconv_output_length(height,\n", " kernel_h,\n", " padding=self.padding,\n", " output_padding=out_pad_h,\n", " stride=stride_h,\n", " dilation=self.dilation_rate[0])\n", " out_width = conv_utils.deconv_output_length(width,\n", " kernel_w,\n", " padding=self.padding,\n", " output_padding=out_pad_w,\n", " stride=stride_w,\n", " dilation=self.dilation_rate[1])\n", " if self.data_format == 'channels_first':\n", " output_shape = (batch_size, self.filters, out_height, out_width)\n", " else:\n", " output_shape = (batch_size, out_height, out_width, self.filters)\n", "\n", " output_shape_tensor = array_ops.stack(output_shape)\n", " outputs = K.conv2d_transpose(\n", " inputs,\n", " new_kernel,\n", " output_shape_tensor,\n", " strides=self.strides,\n", " padding=self.padding,\n", " data_format=self.data_format,\n", " dilation_rate=self.dilation_rate)\n", "\n", " if not context.executing_eagerly():\n", " out_shape = self.compute_output_shape(inputs.shape)\n", " outputs.set_shape(out_shape)\n", "\n", " if self.use_bias:\n", " outputs = tf.nn.bias_add(\n", " outputs,\n", " self.bias,\n", " data_format=conv_utils.convert_data_format(self.data_format, ndim=4))\n", "\n", " if self.activation is not None:\n", " return self.activation(outputs)\n", " return outputs \n", " \n", " \n", "class DenseSN(Dense):\n", " \n", " def build(self, input_shape):\n", " super(DenseSN, self).build(input_shape)\n", "\n", " self.u = self.add_weight(self.name + '_u',\n", " shape=tuple([1, self.kernel.shape.as_list()[-1]]), \n", " initializer=tf.initializers.RandomNormal(0, 1),\n", " trainable=False)\n", " \n", " def compute_spectral_norm(self, W, new_u, W_shape):\n", " new_v = l2normalize(tf.matmul(new_u, tf.transpose(W)))\n", " new_u = l2normalize(tf.matmul(new_v, W))\n", " sigma = tf.matmul(tf.matmul(new_v, W), tf.transpose(new_u))\n", " W_bar = W/sigma\n", " with tf.control_dependencies([self.u.assign(new_u)]):\n", " W_bar = tf.reshape(W_bar, W_shape)\n", " return W_bar\n", " \n", " def call(self, inputs):\n", " W_shape = self.kernel.shape.as_list()\n", " W_reshaped = tf.reshape(self.kernel, (-1, W_shape[-1]))\n", " new_kernel = self.compute_spectral_norm(W_reshaped, self.u, W_shape)\n", " rank = len(inputs.shape)\n", " if rank > 2:\n", " outputs = standard_ops.tensordot(inputs, new_kernel, [[rank - 1], [0]])\n", " if not context.executing_eagerly():\n", " shape = inputs.shape.as_list()\n", " output_shape = shape[:-1] + [self.units]\n", " outputs.set_shape(output_shape)\n", " else:\n", " inputs = math_ops.cast(inputs, self._compute_dtype)\n", " if K.is_sparse(inputs):\n", " outputs = sparse_ops.sparse_tensor_dense_matmul(inputs, new_kernel)\n", " else:\n", " outputs = gen_math_ops.mat_mul(inputs, new_kernel)\n", " if self.use_bias:\n", " outputs = tf.nn.bias_add(outputs, self.bias)\n", " if self.activation is not None:\n", " return self.activation(outputs)\n", " return outputs\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "eX41awYeHE1N" }, "outputs": [], "source": [ "#Networks Architecture\n", "\n", "init = tf.keras.initializers.he_uniform()\n", "\n", "def conv2d(layer_input, filters, kernel_size=4, strides=2, padding='same', leaky=True, bnorm=True, sn=True):\n", " if leaky:\n", " Activ = LeakyReLU(alpha=0.2)\n", " else:\n", " Activ = ReLU()\n", " if sn:\n", " d = ConvSN2D(filters, kernel_size=kernel_size, strides=strides, padding=padding, kernel_initializer=init, use_bias=False)(layer_input)\n", " else:\n", " d = Conv2D(filters, kernel_size=kernel_size, strides=strides, padding=padding, kernel_initializer=init, use_bias=False)(layer_input)\n", " if bnorm:\n", " d = BatchNormalization()(d)\n", " d = Activ(d)\n", " return d\n", "\n", "def deconv2d(layer_input, layer_res, filters, kernel_size=4, conc=True, scalev=False, bnorm=True, up=True, padding='same', strides=2):\n", " if up:\n", " u = UpSampling2D((1,2))(layer_input)\n", " u = ConvSN2D(filters, kernel_size, strides=(1,1), kernel_initializer=init, use_bias=False, padding=padding)(u)\n", " else:\n", " u = ConvSN2DTranspose(filters, kernel_size, strides=strides, kernel_initializer=init, use_bias=False, padding=padding)(layer_input)\n", " if bnorm:\n", " u = BatchNormalization()(u)\n", " u = LeakyReLU(alpha=0.2)(u)\n", " if conc:\n", " u = Concatenate()([u,layer_res])\n", " return u\n", "\n", "#Extract function: splitting spectrograms\n", "def extract_image(im):\n", " im1 = Cropping2D(((0,0), (0, 2*(im.shape[2]//3))))(im)\n", " im2 = Cropping2D(((0,0), (im.shape[2]//3,im.shape[2]//3)))(im)\n", " im3 = Cropping2D(((0,0), (2*(im.shape[2]//3), 0)))(im)\n", " return im1,im2,im3\n", "\n", "#Assemble function: concatenating spectrograms\n", "def assemble_image(lsim):\n", " im1,im2,im3 = lsim\n", " imh = Concatenate(2)([im1,im2,im3])\n", " return imh\n", "\n", "#U-NET style architecture\n", "def build_generator(input_shape):\n", " h,w,c = input_shape\n", " inp = Input(shape=input_shape)\n", " #downscaling\n", " g0 = tf.keras.layers.ZeroPadding2D((0,1))(inp)\n", " g1 = conv2d(g0, 256, kernel_size=(h,3), strides=1, padding='valid')\n", " g2 = conv2d(g1, 256, kernel_size=(1,9), strides=(1,2))\n", " g3 = conv2d(g2, 256, kernel_size=(1,7), strides=(1,2))\n", " #upscaling\n", " g4 = deconv2d(g3,g2, 256, kernel_size=(1,7), strides=(1,2))\n", " g5 = deconv2d(g4,g1, 256, kernel_size=(1,9), strides=(1,2), bnorm=False)\n", " g6 = ConvSN2DTranspose(1, kernel_size=(h,1), strides=(1,1), kernel_initializer=init, padding='valid', activation='tanh')(g5)\n", " return Model(inp,g6, name='G')\n", "\n", "#Siamese Network\n", "def build_siamese(input_shape):\n", " h,w,c = input_shape\n", " inp = Input(shape=input_shape)\n", " g1 = conv2d(inp, 256, kernel_size=(h,3), strides=1, padding='valid', sn=False)\n", " g2 = conv2d(g1, 256, kernel_size=(1,9), strides=(1,2), sn=False)\n", " g3 = conv2d(g2, 256, kernel_size=(1,7), strides=(1,2), sn=False)\n", " g4 = Flatten()(g3)\n", " g5 = Dense(vec_len)(g4)\n", " return Model(inp, g5, name='S')\n", "\n", "#Discriminator (Critic) Network\n", "def build_critic(input_shape):\n", " h,w,c = input_shape\n", " inp = Input(shape=input_shape)\n", " g1 = conv2d(inp, 512, kernel_size=(h,3), strides=1, padding='valid', bnorm=False)\n", " g2 = conv2d(g1, 512, kernel_size=(1,9), strides=(1,2), bnorm=False)\n", " g3 = conv2d(g2, 512, kernel_size=(1,7), strides=(1,2), bnorm=False)\n", " g4 = Flatten()(g3)\n", " g4 = DenseSN(1, kernel_initializer=init)(g4)\n", " return Model(inp, g4, name='C')" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "4fXJmItOzrhC" }, "outputs": [], "source": [ "#Load past models from path to resume training or test\n", "save_model_path = '/content/drive/MyDrive/weights' #@param {type:\"string\"}\n", "def load(path):\n", " gen = build_generator((hop,shape,1))\n", " siam = build_siamese((hop,shape,1))\n", " critic = build_critic((hop,3*shape,1))\n", " gen.load_weights(path+'/gen.h5') \n", " critic.load_weights(path+'/critic.h5')\n", " siam.load_weights(path+'/siam.h5')\n", " return gen,critic,siam\n", "\n", "#Build models\n", "def build():\n", " gen = build_generator((hop,shape,1))\n", " siam = build_siamese((hop,shape,1))\n", " critic = build_critic((hop,3*shape,1)) #the discriminator accepts as input spectrograms of triple the width of those generated by the generator\n", " return gen,critic,siam\n", "\n", "#Generate a random batch to display current training results\n", "def testgena():\n", " sw = True\n", " while sw:\n", " a = np.random.choice(aspec)\n", " if a.shape[1]//shape!=1:\n", " sw=False\n", " dsa = []\n", " if a.shape[1]//shape>6:\n", " num=6\n", " else:\n", " num=a.shape[1]//shape\n", " rn = np.random.randint(a.shape[1]-(num*shape))\n", " for i in range(num):\n", " im = a[:,rn+(i*shape):rn+(i*shape)+shape]\n", " im = np.reshape(im, (im.shape[0],im.shape[1],1))\n", " dsa.append(im)\n", " return np.array(dsa, dtype=np.float32)\n", "\n", "#Show results mid-training\n", "def save_test_image_full(path):\n", " a = testgena()\n", " print(a.shape)\n", " ab = gen(a, training=False)\n", " ab = testass(ab)\n", " a = testass(a)\n", " abwv = deprep(ab)\n", " awv = deprep(a)\n", " sf.write(path+'/new_file.wav', abwv, sr)\n", " IPython.display.display(IPython.display.Audio(np.squeeze(abwv), rate=sr))\n", " IPython.display.display(IPython.display.Audio(np.squeeze(awv), rate=sr))\n", " fig, axs = plt.subplots(ncols=2)\n", " axs[0].imshow(np.flip(a, -2), cmap=None)\n", " axs[0].axis('off')\n", " axs[0].set_title('Source')\n", " axs[1].imshow(np.flip(ab, -2), cmap=None)\n", " axs[1].axis('off')\n", " axs[1].set_title('Generated')\n", " plt.show()\n", "\n", "#Save in training loop\n", "def save_end(epoch,gloss,closs,mloss,n_save=3,save_path=save_model_path): #use custom save_path (i.e. Drive '../content/drive/My Drive/')\n", " if epoch % n_save == 0:\n", " print('Saving...')\n", " path = f'{save_path}/MELGANVC-{str(gloss)[:9]}-{str(closs)[:9]}-{str(mloss)[:9]}'\n", " os.mkdir(path)\n", " gen.save_weights(path+'/gen.h5')\n", " critic.save_weights(path+'/critic.h5')\n", " siam.save_weights(path+'/siam.h5')\n", " save_test_image_full(path)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "fn2s65AxjDJ8" }, "outputs": [], "source": [ "#Losses\n", "\n", "def mae(x,y):\n", " return tf.reduce_mean(tf.abs(x-y))\n", "\n", "def mse(x,y):\n", " return tf.reduce_mean((x-y)**2)\n", "\n", "def loss_travel(sa,sab,sa1,sab1):\n", " l1 = tf.reduce_mean(((sa-sa1) - (sab-sab1))**2)\n", " l2 = tf.reduce_mean(tf.reduce_sum(-(tf.nn.l2_normalize(sa-sa1, axis=[-1]) * tf.nn.l2_normalize(sab-sab1, axis=[-1])), axis=-1))\n", " return l1+l2\n", "\n", "def loss_siamese(sa,sa1):\n", " logits = tf.sqrt(tf.reduce_sum((sa-sa1)**2, axis=-1, keepdims=True))\n", " return tf.reduce_mean(tf.square(tf.maximum((delta - logits), 0)))\n", "\n", "def d_loss_f(fake):\n", " return tf.reduce_mean(tf.maximum(1 + fake, 0))\n", "\n", "def d_loss_r(real):\n", " return tf.reduce_mean(tf.maximum(1 - real, 0))\n", "\n", "def g_loss_f(fake):\n", " return tf.reduce_mean(- fake)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "fgjxHjyIhPwl" }, "outputs": [], "source": [ "#Get models and optimizers\n", "def get_networks(shape, load_model=False, path=None):\n", " if not load_model:\n", " gen,critic,siam = build()\n", " else:\n", " gen,critic,siam = load(path)\n", " print('Built networks')\n", "\n", " opt_gen = Adam(0.0001, 0.5)\n", " opt_disc = Adam(0.0001, 0.5)\n", "\n", " return gen,critic,siam, [opt_gen,opt_disc]\n", "\n", "#Set learning rate\n", "def update_lr(lr):\n", " opt_gen.learning_rate = lr\n", " opt_disc.learning_rate = lr" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "WGWjgHqDWR78" }, "outputs": [], "source": [ "#Training Functions\n", "\n", "#Train Generator, Siamese and Critic\n", "@tf.function\n", "def train_all(a,b):\n", " #splitting spectrogram in 3 parts\n", " aa,aa2,aa3 = extract_image(a) \n", " bb,bb2,bb3 = extract_image(b)\n", "\n", " with tf.GradientTape() as tape_gen, tf.GradientTape() as tape_disc:\n", "\n", " #translating A to B\n", " fab = gen(aa, training=True)\n", " fab2 = gen(aa2, training=True)\n", " fab3 = gen(aa3, training=True)\n", " #identity mapping B to B COMMENT THESE 3 LINES IF THE IDENTITY LOSS TERM IS NOT NEEDED\n", " # fid = gen(bb, training=True) \n", " # fid2 = gen(bb2, training=True)\n", " # fid3 = gen(bb3, training=True)\n", " #concatenate/assemble converted spectrograms\n", " fabtot = assemble_image([fab,fab2,fab3])\n", "\n", " #feed concatenated spectrograms to critic\n", " cab = critic(fabtot, training=True)\n", " cb = critic(b, training=True)\n", " #feed 2 pairs (A,G(A)) extracted spectrograms to Siamese\n", " sab = siam(fab, training=True)\n", " sab2 = siam(fab3, training=True)\n", " sa = siam(aa, training=True)\n", " sa2 = siam(aa3, training=True)\n", "\n", " #identity mapping loss\n", " loss_id = 0 #loss_id = 0. IF THE IDENTITY LOSS TERM IS NOT NEEDED\n", " #travel loss\n", " loss_m = loss_travel(sa,sab,sa2,sab2)+loss_siamese(sa,sa2)\n", " #generator and critic losses\n", " loss_g = g_loss_f(cab)\n", " loss_dr = d_loss_r(cb)\n", " loss_df = d_loss_f(cab)\n", " loss_d = (loss_dr+loss_df)/2.\n", " #generator+siamese total loss\n", " # lossgtot = loss_g+10.*loss_m+0.5*loss_id #CHANGE LOSS WEIGHTS HERE (COMMENT OUT +w*loss_id IF THE IDENTITY LOSS TERM IS NOT NEEDED)\n", " lossgtot = loss_g+10.*loss_m\n", " \n", " #computing and applying gradients\n", " grad_gen = tape_gen.gradient(lossgtot, gen.trainable_variables+siam.trainable_variables)\n", " opt_gen.apply_gradients(zip(grad_gen, gen.trainable_variables+siam.trainable_variables))\n", "\n", " grad_disc = tape_disc.gradient(loss_d, critic.trainable_variables)\n", " opt_disc.apply_gradients(zip(grad_disc, critic.trainable_variables))\n", " \n", " return loss_dr,loss_df,loss_g,loss_id\n", "\n", "#Train Critic only\n", "@tf.function\n", "def train_d(a,b):\n", " aa,aa2,aa3 = extract_image(a)\n", " with tf.GradientTape() as tape_disc:\n", "\n", " fab = gen(aa, training=True)\n", " fab2 = gen(aa2, training=True)\n", " fab3 = gen(aa3, training=True)\n", " fabtot = assemble_image([fab,fab2,fab3])\n", "\n", " cab = critic(fabtot, training=True)\n", " cb = critic(b, training=True)\n", "\n", " loss_dr = d_loss_r(cb)\n", " loss_df = d_loss_f(cab)\n", "\n", " loss_d = (loss_dr+loss_df)/2.\n", " \n", " grad_disc = tape_disc.gradient(loss_d, critic.trainable_variables)\n", " opt_disc.apply_gradients(zip(grad_disc, critic.trainable_variables))\n", "\n", " return loss_dr,loss_df" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "aVwL-Ry-nNru" }, "outputs": [], "source": [ "#Training Loop\n", "\n", "def train(epochs, batch_size=16, lr=0.0001, n_save=6, gupt=5):\n", " \n", " update_lr(lr)\n", " df_list = []\n", " dr_list = []\n", " g_list = []\n", " id_list = []\n", " c = 0\n", " g = 0\n", " \n", " for epoch in range(epochs):\n", " bef = time.time()\n", " \n", " for batchi,(a,b) in enumerate(zip(dsa,dsb)):\n", " \n", " if batchi%gupt==0:\n", " dloss_t,dloss_f,gloss,idloss = train_all(a,b)\n", " else:\n", " dloss_t,dloss_f = train_d(a,b)\n", "\n", " df_list.append(dloss_f)\n", " dr_list.append(dloss_t)\n", " g_list.append(gloss)\n", " id_list.append(idloss)\n", " c += 1\n", " g += 1\n", "\n", " if batchi%600==0:\n", " print(f'[Epoch {epoch}/{epochs}] [Batch {batchi}] [D loss f: {np.mean(df_list[-g:], axis=0)} ', end='')\n", " print(f'r: {np.mean(dr_list[-g:], axis=0)}] ', end='')\n", " print(f'[G loss: {np.mean(g_list[-g:], axis=0)}] ', end='')\n", " print(f'[ID loss: {np.mean(id_list[-g:])}] ', end='')\n", " print(f'[LR: {lr}]')\n", " g = 0\n", " nbatch=batchi\n", "\n", " print(f'Time/Batch {(time.time()-bef)/nbatch}')\n", " save_end(epoch,np.mean(g_list[-n_save*c:], axis=0),np.mean(df_list[-n_save*c:], axis=0),np.mean(id_list[-n_save*c:], axis=0),n_save=n_save)\n", " print(f'Mean D loss: {np.mean(df_list[-c:], axis=0)} Mean G loss: {np.mean(g_list[-c:], axis=0)} Mean ID loss: {np.mean(id_list[-c:], axis=0)}')\n", " c = 0\n", " " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "JruweKNrl_ZD", "outputId": "43516ba8-79da-434c-e744-5abffb44544d" }, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.10/dist-packages/keras/initializers/initializers.py:120: UserWarning: The initializer HeUniform is unseeded and being called multiple times, which will return identical values each time (even if the initializer is unseeded). Please update your code to provide a seed to the initializer, or avoid using the same initalizer instance more than once.\n", " warnings.warn(\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "Built networks\n" ] } ], "source": [ "#Build models and initialize optimizers\n", "load_model_path='/content/drive/MyDrive/weights/MELGANVC-0.5051767-0.577141-0.0' #@param {type:\"string\"}\n", "#If load_model=True, specify the path where the models are saved\n", "\n", "gen,critic,siam, [opt_gen,opt_disc] = get_networks(shape, load_model=True,path=load_model_path)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "cellView": "both", "id": "BknKCA-8yqap" }, "outputs": [], "source": [ "#Training\n", "\n", "#n_save = how many epochs between each saving and displaying of results\n", "#gupt = how many discriminator updates for generator+siamese update\n", "\n", "train(50, batch_size=bs, lr=0.0002, n_save=1, gupt=3)" ] }, { "cell_type": "markdown", "source": [ "# Generate the result" ], "metadata": { "id": "KvEjWov48z0r" } }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "A-f6nSiF95H-" }, "outputs": [], "source": [ "#After Training, use these functions to convert data with the generator and save the results\n", "\n", "#Assembling generated Spectrogram chunks into final Spectrogram\n", "def specass(a,spec):\n", " but=False\n", " con = np.array([])\n", " nim = a.shape[0]\n", " for i in range(nim-1):\n", " im = a[i]\n", " im = np.squeeze(im)\n", " if not but:\n", " con=im\n", " but=True\n", " else:\n", " con = np.concatenate((con,im), axis=1)\n", " diff = spec.shape[1]-(nim*shape)\n", " a = np.squeeze(a)\n", " con = np.concatenate((con,a[-1,:,-diff:]), axis=1)\n", " return np.squeeze(con)\n", "\n", "#Splitting input spectrogram into different chunks to feed to the generator\n", "def chopspec(spec):\n", " dsa=[]\n", " for i in range(spec.shape[1]//shape):\n", " im = spec[:,i*shape:i*shape+shape]\n", " im = np.reshape(im, (im.shape[0],im.shape[1],1))\n", " dsa.append(im)\n", " imlast = spec[:,-shape:]\n", " imlast = np.reshape(imlast, (imlast.shape[0],imlast.shape[1],1))\n", " dsa.append(imlast)\n", " return np.array(dsa, dtype=np.float32)\n", "\n", "#Converting from source Spectrogram to target Spectrogram\n", "def towave(spec, name, path='../content/', show=False):\n", " specarr = chopspec(spec)\n", " print(specarr.shape)\n", " a = specarr\n", " print('Generating...')\n", " ab = gen(a, training=False)\n", " print('Assembling and Converting...')\n", " a = specass(a,spec)\n", " ab = specass(ab,spec)\n", " awv = deprep(a)\n", " abwv = deprep(ab)\n", " print('Saving...')\n", " pathfin = f'{path}/{name}'\n", " os.mkdir(pathfin)\n", " sf.write(pathfin+'/AB.wav', abwv, sr)\n", " sf.write(pathfin+'/A.wav', awv, sr)\n", " print('Saved WAV!')\n", " IPython.display.display(IPython.display.Audio(np.squeeze(abwv), rate=sr))\n", " IPython.display.display(IPython.display.Audio(np.squeeze(awv), rate=sr))\n", " if show:\n", " fig, axs = plt.subplots(ncols=2)\n", " axs[0].imshow(np.flip(a, -2), cmap=None)\n", " axs[0].axis('off')\n", " axs[0].set_title('Source')\n", " axs[1].imshow(np.flip(ab, -2), cmap=None)\n", " axs[1].axis('off')\n", " axs[1].set_title('Generated')\n", " plt.show()\n", " return abwv" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 370 }, "id": "6FZE91V1BIJX", "outputId": "e0ce6f71-a979-4ef9-b5f6-533a306c0894" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(480000,)\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "(105, 192, 24, 1)\n", "Generating...\n", "Assembling and Converting...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 2000/2000 [00:08<00:00, 223.34it/s, loss=0.000907, spectral_convergence=-28.8]\n", "100%|██████████| 2000/2000 [00:08<00:00, 230.70it/s, loss=0.00908, spectral_convergence=-13.4]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Saving...\n", "Saved WAV!\n" ] }, { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#Wav to wav conversion\n", "\n", "wv, sr = librosa.load(\"/content/finaldata/000.wav\", sr=16000) #Load waveform\n", "print(wv.shape)\n", "speca = prep(wv) #Waveform to Spectrogram\n", "\n", "plt.figure(figsize=(50,1)) #Show Spectrogram\n", "plt.imshow(np.flip(speca, axis=0), cmap=None)\n", "plt.axis('off')\n", "plt.show()\n", "\n", "abwv = towave(speca, name='FILENAME2', path='songs_gen') #Convert and save wav" ] } ], "metadata": { "accelerator": "GPU", "availableInstances": [ { "_defaultOrder": 0, "_isFastLaunch": true, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 4, "name": "ml.t3.medium", "vcpuNum": 2 }, { "_defaultOrder": 1, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 8, "name": "ml.t3.large", "vcpuNum": 2 }, { "_defaultOrder": 2, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 16, "name": "ml.t3.xlarge", "vcpuNum": 4 }, { "_defaultOrder": 3, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 32, "name": "ml.t3.2xlarge", "vcpuNum": 8 }, { "_defaultOrder": 4, "_isFastLaunch": true, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 8, "name": "ml.m5.large", "vcpuNum": 2 }, { "_defaultOrder": 5, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 16, "name": "ml.m5.xlarge", "vcpuNum": 4 }, { "_defaultOrder": 6, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 32, "name": "ml.m5.2xlarge", "vcpuNum": 8 }, { "_defaultOrder": 7, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 64, "name": "ml.m5.4xlarge", "vcpuNum": 16 }, { "_defaultOrder": 8, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 128, "name": "ml.m5.8xlarge", "vcpuNum": 32 }, { "_defaultOrder": 9, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 192, "name": "ml.m5.12xlarge", "vcpuNum": 48 }, { "_defaultOrder": 10, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 256, "name": "ml.m5.16xlarge", "vcpuNum": 64 }, { "_defaultOrder": 11, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 384, "name": "ml.m5.24xlarge", "vcpuNum": 96 }, { "_defaultOrder": 12, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 8, "name": "ml.m5d.large", "vcpuNum": 2 }, { "_defaultOrder": 13, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 16, "name": "ml.m5d.xlarge", "vcpuNum": 4 }, { "_defaultOrder": 14, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 32, "name": "ml.m5d.2xlarge", "vcpuNum": 8 }, { "_defaultOrder": 15, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 64, "name": "ml.m5d.4xlarge", "vcpuNum": 16 }, { "_defaultOrder": 16, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 128, "name": "ml.m5d.8xlarge", "vcpuNum": 32 }, { "_defaultOrder": 17, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 192, "name": "ml.m5d.12xlarge", "vcpuNum": 48 }, { "_defaultOrder": 18, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 256, "name": "ml.m5d.16xlarge", "vcpuNum": 64 }, { "_defaultOrder": 19, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 384, "name": "ml.m5d.24xlarge", "vcpuNum": 96 }, { "_defaultOrder": 20, "_isFastLaunch": false, "category": "General purpose", "gpuNum": 0, "hideHardwareSpecs": true, "memoryGiB": 0, "name": "ml.geospatial.interactive", "supportedImageNames": [ "sagemaker-geospatial-v1-0" ], "vcpuNum": 0 }, { "_defaultOrder": 21, "_isFastLaunch": true, "category": "Compute optimized", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 4, "name": "ml.c5.large", "vcpuNum": 2 }, { "_defaultOrder": 22, "_isFastLaunch": false, "category": "Compute optimized", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 8, "name": "ml.c5.xlarge", "vcpuNum": 4 }, { "_defaultOrder": 23, "_isFastLaunch": false, "category": "Compute optimized", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 16, "name": "ml.c5.2xlarge", "vcpuNum": 8 }, { "_defaultOrder": 24, "_isFastLaunch": false, "category": "Compute optimized", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 32, "name": "ml.c5.4xlarge", "vcpuNum": 16 }, { "_defaultOrder": 25, "_isFastLaunch": false, "category": "Compute optimized", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 72, "name": "ml.c5.9xlarge", "vcpuNum": 36 }, { "_defaultOrder": 26, "_isFastLaunch": false, "category": "Compute optimized", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 96, "name": "ml.c5.12xlarge", "vcpuNum": 48 }, { "_defaultOrder": 27, "_isFastLaunch": false, "category": "Compute optimized", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 144, "name": "ml.c5.18xlarge", "vcpuNum": 72 }, { "_defaultOrder": 28, "_isFastLaunch": false, "category": "Compute optimized", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 192, "name": "ml.c5.24xlarge", "vcpuNum": 96 }, { "_defaultOrder": 29, "_isFastLaunch": true, "category": "Accelerated computing", "gpuNum": 1, "hideHardwareSpecs": false, "memoryGiB": 16, "name": "ml.g4dn.xlarge", "vcpuNum": 4 }, { "_defaultOrder": 30, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 1, "hideHardwareSpecs": false, "memoryGiB": 32, "name": "ml.g4dn.2xlarge", "vcpuNum": 8 }, { "_defaultOrder": 31, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 1, "hideHardwareSpecs": false, "memoryGiB": 64, "name": "ml.g4dn.4xlarge", "vcpuNum": 16 }, { "_defaultOrder": 32, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 1, "hideHardwareSpecs": false, "memoryGiB": 128, "name": "ml.g4dn.8xlarge", "vcpuNum": 32 }, { "_defaultOrder": 33, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 4, "hideHardwareSpecs": false, "memoryGiB": 192, "name": "ml.g4dn.12xlarge", "vcpuNum": 48 }, { "_defaultOrder": 34, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 1, "hideHardwareSpecs": false, "memoryGiB": 256, "name": "ml.g4dn.16xlarge", "vcpuNum": 64 }, { "_defaultOrder": 35, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 1, "hideHardwareSpecs": false, "memoryGiB": 61, "name": "ml.p3.2xlarge", "vcpuNum": 8 }, { "_defaultOrder": 36, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 4, "hideHardwareSpecs": false, "memoryGiB": 244, "name": "ml.p3.8xlarge", "vcpuNum": 32 }, { "_defaultOrder": 37, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 8, "hideHardwareSpecs": false, "memoryGiB": 488, "name": "ml.p3.16xlarge", "vcpuNum": 64 }, { "_defaultOrder": 38, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 8, "hideHardwareSpecs": false, "memoryGiB": 768, "name": "ml.p3dn.24xlarge", "vcpuNum": 96 }, { "_defaultOrder": 39, "_isFastLaunch": false, "category": "Memory Optimized", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 16, "name": "ml.r5.large", "vcpuNum": 2 }, { "_defaultOrder": 40, "_isFastLaunch": false, "category": "Memory Optimized", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 32, "name": "ml.r5.xlarge", "vcpuNum": 4 }, { "_defaultOrder": 41, "_isFastLaunch": false, "category": "Memory Optimized", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 64, "name": "ml.r5.2xlarge", "vcpuNum": 8 }, { "_defaultOrder": 42, "_isFastLaunch": false, "category": "Memory Optimized", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 128, "name": "ml.r5.4xlarge", "vcpuNum": 16 }, { "_defaultOrder": 43, "_isFastLaunch": false, "category": "Memory Optimized", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 256, "name": "ml.r5.8xlarge", "vcpuNum": 32 }, { "_defaultOrder": 44, "_isFastLaunch": false, "category": "Memory Optimized", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 384, "name": "ml.r5.12xlarge", "vcpuNum": 48 }, { "_defaultOrder": 45, "_isFastLaunch": false, "category": "Memory Optimized", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 512, "name": "ml.r5.16xlarge", "vcpuNum": 64 }, { "_defaultOrder": 46, "_isFastLaunch": false, "category": "Memory Optimized", "gpuNum": 0, "hideHardwareSpecs": false, "memoryGiB": 768, "name": "ml.r5.24xlarge", "vcpuNum": 96 }, { "_defaultOrder": 47, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 1, "hideHardwareSpecs": false, "memoryGiB": 16, "name": "ml.g5.xlarge", "vcpuNum": 4 }, { "_defaultOrder": 48, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 1, "hideHardwareSpecs": false, "memoryGiB": 32, "name": "ml.g5.2xlarge", "vcpuNum": 8 }, { "_defaultOrder": 49, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 1, "hideHardwareSpecs": false, "memoryGiB": 64, "name": "ml.g5.4xlarge", "vcpuNum": 16 }, { "_defaultOrder": 50, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 1, "hideHardwareSpecs": false, "memoryGiB": 128, "name": "ml.g5.8xlarge", "vcpuNum": 32 }, { "_defaultOrder": 51, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 1, "hideHardwareSpecs": false, "memoryGiB": 256, "name": "ml.g5.16xlarge", "vcpuNum": 64 }, { "_defaultOrder": 52, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 4, "hideHardwareSpecs": false, "memoryGiB": 192, "name": "ml.g5.12xlarge", "vcpuNum": 48 }, { "_defaultOrder": 53, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 4, "hideHardwareSpecs": false, "memoryGiB": 384, "name": "ml.g5.24xlarge", "vcpuNum": 96 }, { "_defaultOrder": 54, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 8, "hideHardwareSpecs": false, "memoryGiB": 768, "name": "ml.g5.48xlarge", "vcpuNum": 192 }, { "_defaultOrder": 55, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 8, "hideHardwareSpecs": false, "memoryGiB": 1152, "name": "ml.p4d.24xlarge", "vcpuNum": 96 }, { "_defaultOrder": 56, "_isFastLaunch": false, "category": "Accelerated computing", "gpuNum": 8, "hideHardwareSpecs": false, "memoryGiB": 1152, "name": "ml.p4de.24xlarge", "vcpuNum": 96 } ], "colab": { "machine_shape": "hm", "provenance": [], "gpuType": "A100", "toc_visible": true }, "instance_type": "ml.t3.medium", "kernelspec": { "display_name": "Python 3 (Base Python)", "language": "python", "name": "python3__SAGEMAKER_INTERNAL__arn:aws:sagemaker:us-west-2:236514542706:image/python-3.6" }, "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.6.13" } }, "nbformat": 4, "nbformat_minor": 0 }