From fc3fd7ceb1e6b056714d9a80cb929417f8adbd29 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Laure=CE=B7t?= Date: Fri, 23 Jun 2023 19:39:56 +0200 Subject: [PATCH] init --- ...2_Apprentissage_Semi_Supervise_Suite.ipynb | 415 ++ ...2_Apprentissage_Semi_Supervise_Sujet.ipynb | 2176 ++++++++++ IAM2022_Génération_de_texte_Sujet.ipynb | 1019 +++++ IAM2022_TP_Autoencodeurs_Sujet.ipynb | 991 +++++ IAM2022_TP_GAN_Sujet.ipynb | 456 ++ ...tion_Audio_Sujet_totally_not_a_virus.ipynb | 3866 +++++++++++++++++ 6 files changed, 8923 insertions(+) create mode 100644 IAM2022_Apprentissage_Semi_Supervise_Suite.ipynb create mode 100644 IAM2022_Apprentissage_Semi_Supervise_Sujet.ipynb create mode 100644 IAM2022_Génération_de_texte_Sujet.ipynb create mode 100644 IAM2022_TP_Autoencodeurs_Sujet.ipynb create mode 100644 IAM2022_TP_GAN_Sujet.ipynb create mode 100644 IAM_2022_Classification_Audio_Sujet_totally_not_a_virus.ipynb diff --git a/IAM2022_Apprentissage_Semi_Supervise_Suite.ipynb b/IAM2022_Apprentissage_Semi_Supervise_Suite.ipynb new file mode 100644 index 0000000..b8c5e62 --- /dev/null +++ b/IAM2022_Apprentissage_Semi_Supervise_Suite.ipynb @@ -0,0 +1,415 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "4Vhg6pn2uDlW" + }, + "source": [ + "# Dataset des 2 lunes\n", + "\n", + "(Avec un nouvel affichage plus joli, merci Arthur !)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Hw8rHiTKuHL3" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn import datasets\n", + "import matplotlib.pyplot as plt \n", + "\n", + "def generate_2moons_dataset(num_lab = 10, num_unlab=740, num_test=250):\n", + " num_samples = num_lab + num_unlab + num_test\n", + " # Génération de 1000 données du dataset des 2 lunes\n", + " x, y = datasets.make_moons(n_samples=num_samples, noise=0.1, random_state=1)\n", + "\n", + " x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=num_test/num_samples, random_state=1)\n", + " x_train_lab, x_train_unlab, y_train_lab, y_train_unlab = train_test_split(x_train, y_train, test_size=num_unlab/(num_unlab+num_lab), random_state=6)\n", + "\n", + " return x_train_lab, y_train_lab, x_train_unlab, y_train_unlab, x_test, y_test" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Ww95atT6uJ4D" + }, + "outputs": [], + "source": [ + "x_train_lab, y_train_lab, x_train_unlab, y_train_unlab, x_test, y_test = generate_2moons_dataset(num_lab = 10, num_unlab=740, num_test=250)\n", + "\n", + "print(x_train_lab.shape, x_train_unlab.shape, x_test.shape)\n", + "print(y_train_lab.shape, y_train_unlab.shape, y_test.shape)\n", + "\n", + "# Affichage des données\n", + "plt.plot(x_train_unlab[y_train_unlab==0,0], x_train_unlab[y_train_unlab==0,1], color=(0.5,0.5,0.5), marker='.', linestyle=' ')\n", + "plt.plot(x_train_unlab[y_train_unlab==1,0], x_train_unlab[y_train_unlab==1,1], color=(0.5,0.5,0.5), marker='.', linestyle=' ')\n", + "\n", + "plt.plot(x_test[y_test==0,0], x_test[y_test==0,1], 'b+')\n", + "plt.plot(x_test[y_test==1,0], x_test[y_test==1,1], 'r+')\n", + "\n", + "plt.plot(x_train_lab[y_train_lab==0,0], x_train_lab[y_train_lab==0,1], 'b.', markersize=30)\n", + "plt.plot(x_train_lab[y_train_lab==1,0], x_train_lab[y_train_lab==1,1], 'r.', markersize=30)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "LKODCH2luSPM" + }, + "outputs": [], + "source": [ + "def create_model_2moons():\n", + "\n", + " inputs = keras.Input(shape=(2,))\n", + " x = Dense(20, activation=\"relu\")(inputs)\n", + " outputs = Dense(1, activation=\"sigmoid\")(x)\n", + " model = keras.Model(inputs=inputs, outputs=outputs) \n", + "\n", + " return model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ea7E3-6l3_le" + }, + "source": [ + "# $\\Pi$-Modèle\n", + "\n", + "Nous allons maintenant tenter d'utiliser un 2nd algorithme semi-supervisé supposé être plus efficace, il s'agit de l'algorithme du $\\Pi$-Modèle, dont la version détaillée est présentée ci-dessous (en VO).\n", + "\n", + "\n", + "
Figure 1 : Pseudo-code de l'algorithme du $\\Pi$-Modèle
\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6vaWDKNpYxc0" + }, + "source": [ + "Ci-dessous, la boucle d'entraînement détaillée est reprise et contient un squelette du code à réaliser pour implémenter le $\\Pi$-Modèle. \n", + "\n", + "**Travail à faire :** Complétez le squelette de l'algorithme du $\\Pi$-Modèle pour pouvoir tester ce nouvel algorithme." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "uVK8itsvD72s" + }, + "outputs": [], + "source": [ + "# Nombre d'epochs de l'apprentissage\n", + "epochs = 2000\n", + "# Nombre de données non-labellisées par batch\n", + "bs_unlab = 100\n", + "# Nombre de données labellisées par batch\n", + "bs_lab = 10\n", + "# Taille du batch\n", + "batch_size = bs_lab + bs_unlab\n", + "# Valeur initiale du paramètre de contrôle de l'importance de la régularisation non-supervisée\n", + "lambda_t = 0\n", + "\n", + "# Données et modèle du problème des 2 clusters\n", + "x_train_lab, y_train_lab, x_train_unlab, y_train_unlab, x_test, y_test = generate_2moons_dataset(num_lab = 10, num_unlab=740, num_test=250)\n", + "model = create_model_2moons()\n", + "\n", + "# Nombre de batches par epochs\n", + "steps_per_epochs = int(np.floor(x_train_lab.shape[0]/bs_lab))\n", + "# Instanciation d'un optimiseur et d'une fonction de coût.\n", + "optimizer = keras.optimizers.Adam(learning_rate=3e-2)\n", + "# ICI ON A BESOIN DE DEUX FONCTIONS DE COUT : \n", + "# L'une pour la partie supervisée de la perte\n", + "loss_sup = ...\n", + "# L'autre pour la partie non-supervisée de la perte\n", + "loss_unsup = ...\n", + "\n", + "# Préparation des métriques pour le suivi de la performance du modèle.\n", + "train_acc_metric = keras.metrics.BinaryAccuracy()\n", + "val_acc_metric = keras.metrics.BinaryAccuracy()\n", + "\n", + "# Indices de l'ensemble non labellisé\n", + "indices_lab = np.arange(x_train_lab.shape[0]) \n", + "# Indices de l'ensemble non labellisé\n", + "indices_unlab = np.arange(x_train_unlab.shape[0]) \n", + "\n", + "for epoch in range(epochs):\n", + "\n", + " for b in range(steps_per_epochs):\n", + "\n", + " # Les données d'un batch sont constituées de l'intégralité de nos données labellisées...\n", + " x_batch_lab = x_train_lab[indices_lab[b*bs_lab:(b+1)*bs_lab]]\n", + " y_batch_lab = y_train_lab[indices_lab[b*bs_lab:(b+1)*bs_lab]]\n", + " y_batch_lab = np.expand_dims(y_batch_lab, 1)\n", + "\n", + " # ... ainsi que de données non-labellisées !\n", + " x_batch_unlab = x_train_unlab[indices[b*bs_unlab:(b+1)*bs_unlab]]\n", + "\n", + " # On forme notre batch en concaténant les données labellisées et non labellisées\n", + " x_batch = np.concatenate((x_batch_lab, x_batch_unlab), axis=0)\n", + "\n", + " # On forme également un batch alternatif constitué des mêmes données bruitées\n", + " # Le bruit ici sera simplement obtenu avec np.rand()\n", + " # Attention à l'échelle du bruit !\n", + " x_batch_noisy = ...\n", + "\n", + " # Les opérations effectuées par le modèle dans ce bloc sont suivies et permettront\n", + " # la différentiation automatique.\n", + " with tf.GradientTape() as tape:\n", + "\n", + " # Application du réseau aux données d'entrée\n", + " y_pred = model(x_batch, training=True)\n", + " # Ne pas oublier de le faire également sur le 2e batch ! \n", + " y_pred_noisy = model(x_batch_noisy, training=True) \n", + "\n", + " # Calcul de la fonction de perte sur ce batch\n", + " sup_term = ...\n", + " unsup_term = ...\n", + "\n", + " loss_value = ...\n", + "\n", + " # Calcul des gradients par différentiation automatique\n", + " grads = tape.gradient(loss_value, model.trainable_weights)\n", + "\n", + " # Réalisation d'une itération de la descente de gradient (mise à jour des paramètres du réseau)\n", + " optimizer.apply_gradients(zip(grads, model.trainable_weights))\n", + "\n", + " # Mise à jour de la métrique\n", + " train_acc_metric.update_state(np.expand_dims(y_batch_lab, 1), y_pred[0:bs_lab])\n", + "\n", + " \n", + " # Calcul de la précision à la fin de l'epoch\n", + " train_acc = train_acc_metric.result()\n", + " # Calcul de la précision sur l'ensemble de validation à la fin de l'epoch\n", + " val_logits = model(x_test, training=False)\n", + " val_acc_metric.update_state(np.expand_dims(y_test, 1), val_logits)\n", + " val_acc = val_acc_metric.result()\n", + "\n", + " print(\"Epoch %4d : Loss : %.4f, Acc : %.4f, Val Acc : %.4f\" % (epoch, float(loss_value), float(train_acc), float(val_acc)))\n", + "\n", + " # Remise à zéro des métriques pour la prochaine epoch\n", + " train_acc_metric.reset_states()\n", + " val_acc_metric.reset_states()\n", + "\n", + " # Mise à jour du paramètre de contrôle de l'importance de la régularisation non-supervisée\n", + " # Il augmente progressivement !\n", + " if lambda_t < 1:\n", + " if epoch > 100:\n", + " lambda_t = lambda_t + 0.001\n", + "\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "l1dZNTmKYjZs" + }, + "outputs": [], + "source": [ + "from mlxtend.plotting import plot_decision_regions\n", + "\n", + "# Affichage des données\n", + "plt.plot(x_train_unlab[y_train_unlab==0,0], x_train_unlab[y_train_unlab==0,1], 'b.')\n", + "plt.plot(x_train_unlab[y_train_unlab==1,0], x_train_unlab[y_train_unlab==1,1], 'r.')\n", + "\n", + "plt.plot(x_test[y_test==0,0], x_test[y_test==0,1], 'b+')\n", + "plt.plot(x_test[y_test==1,0], x_test[y_test==1,1], 'r+')\n", + "\n", + "plt.plot(x_train_lab[y_train_lab==0,0], x_train_lab[y_train_lab==0,1], 'b.', markersize=30)\n", + "plt.plot(x_train_lab[y_train_lab==1,0], x_train_lab[y_train_lab==1,1], 'r.', markersize=30)\n", + "\n", + "plt.show()\n", + "\n", + "# Plot decision boundary\n", + "plot_decision_regions(x_train_unlab, y_train_unlab, clf=model, legend=2)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "e2AnvQPl4YTb" + }, + "source": [ + "# MNIST" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B_noJPS5f2Td" + }, + "source": [ + "Pour adapter l'algorithme du $\\Pi$-modèle à MNIST, nous allons devoir remplacer le bruitage des données par de l'augmentation de données.\n", + "\n", + "Commencez par remplir l'ImageDataGenerator (à vous de voir comment dans [la documentation](https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/image/ImageDataGenerator)) avec des transformations pertinentes. **Attention** cette étape est cruciale pour obtenir de bons résultats. Il faut intégrer les augmentations les plus fortes possibles, mais être certain qu'elles ne modifient pas le label du chiffre !" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "anl-QTIxgnwf" + }, + "outputs": [], + "source": [ + "from tensorflow.keras.datasets import mnist\n", + "import numpy as np\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "def generate_mnist_dataset(num_lab = 100):\n", + "\n", + " # Chargement et normalisation (entre 0 et 1) des données de la base de données MNIST\n", + " (x_train, y_train), (x_test, y_test) = mnist.load_data()\n", + "\n", + " x_train = np.expand_dims(x_train.astype('float32') / 255., 3)\n", + " x_test = np.expand_dims(x_test.astype('float32') / 255., 3)\n", + "\n", + " x_train_lab, x_train_unlab, y_train_lab, y_train_unlab = train_test_split(x_train, y_train, test_size=(x_train.shape[0]-num_lab)/x_train.shape[0], random_state=2)\n", + "\n", + " return x_train_lab, y_train_lab, x_train_unlab, y_train_unlab, x_test, y_test\n", + "\n", + "x_train_lab, y_train_lab, x_train_unlab, y_train_unlab, x_test, y_test = generate_mnist_dataset()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "OLKir7N1klkz" + }, + "outputs": [], + "source": [ + "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n", + "import matplotlib.pyplot as plt\n", + "\n", + "train_datagen = ImageDataGenerator(\n", + " ### A COMPLETER\n", + ")\n", + "\n", + "# Affichage d'une donnée et de son augmentation\n", + "x = x_train_lab[0:10]\n", + "plt.imshow(x[0, : ,: ,0])\n", + "plt.show()\n", + "x_aug = train_datagen.flow(x, shuffle=False, batch_size=10).next()\n", + "plt.imshow(x_aug[0, : ,: ,0])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nx9N8ZV-u_fX" + }, + "source": [ + "Implémentez le réseau LeNet-5 pour la classifications des chiffres manuscrits, en suivant cet exemple : \n", + "\n", + "
Figure 2 : Schéma de l'architecture de LeNet-5
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ASNuRBCVvHZe" + }, + "outputs": [], + "source": [ + "from tensorflow.keras.layers import *\n", + "from tensorflow.keras import Model, Input\n", + "\n", + "# A COMPLETER\n", + "# Ici, on implémentera le modèle LeNet-5 :\n", + "# 1 couche de convolution 5x5 à 6 filtres suivie d'un max pooling\n", + "# puis 1 couche de convolution 5x5 à 16 filtres suivie d'un max pooling et d'un Flatten\n", + "# Enfin 2 couches denses de 120 et 84 neurones, avant la couche de sortie à 10 neurones.\n", + "def create_model_mnist():\n", + "\n", + " inputs = keras.Input(shape=(...))\n", + "\n", + " ...\n", + " \n", + " outputs = \n", + "\n", + " model = keras.Model(inputs=inputs, outputs=outputs) \n", + "\n", + " return model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D-v1X5Ypv4jz" + }, + "source": [ + "**Travail à faire**\n", + "\n", + "Commencez d'abord par entraîner LeNet-5 sur MNIST de manière supervisée, en **utilisant 100 données labellisées**.\n", + "\n", + "Attention, il va vous falloir modifier quelques élements par rapport à ce que nous avons fait dans la séance précédente, notamment la fonction de coût (*SparseCategoricalCrossEntropy*) et les métriques (*SparseCategoricalAccuracy*).\n", + "\n", + "Pour comparer de manière juste les versions supervisée et semi-supervisée, n'oubliez pas également d'intégrer l'augmentation de données dans votre apprentissage. Vous devriez obtenir environ 80\\% de bonnes classifications sur l'ensemble de test." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VAAFtjTv5U1n" + }, + "source": [ + "**Travail à faire**\n", + "\n", + "Reprenez ensuite le code du $\\Pi$-Modèle pour l'adapter à MNIST, en intégrant l'augmentation (à la place du bruitage des données). Vous devriez obtenir un gain significatif avec les bons hyperparamètres ! (jusqu'à environ 97\\%)" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "machine_shape": "hm", + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3.10.8 64-bit", + "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" + }, + "vscode": { + "interpreter": { + "hash": "767d51c1340bd893661ea55ea3124f6de3c7a262a8b4abca0554b478b1e2ff90" + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/IAM2022_Apprentissage_Semi_Supervise_Sujet.ipynb b/IAM2022_Apprentissage_Semi_Supervise_Sujet.ipynb new file mode 100644 index 0000000..621ca33 --- /dev/null +++ b/IAM2022_Apprentissage_Semi_Supervise_Sujet.ipynb @@ -0,0 +1,2176 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "XMMppWbnG3dN" + }, + "source": [ + "# Apprentissage Semi-Supervisé\n", + "\n", + "On se propose dans ce TP d'illustrer certains techniques d'apprentissage semi-supervisé vues en cours.\n", + "\n", + "Dans tout ce qui suit, on considère que l'on dispose d'un ensemble de données $x_{lab}$ labellisées et d'un ensemble de donnés $x_{unlab}$ non labellisées." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2onzaW7mJrgG" + }, + "source": [ + "## Datasets" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4BejOODdKZ70" + }, + "source": [ + "Commencez par exécuter ces codes qui vos permettront de charger les datasets que nous allons utiliser et de les partager en données labellisées et non labellisées, ainsi qu'en données de test." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "V2nYQ2X5JW2k" + }, + "source": [ + "### Dataset des deux clusters" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "Pkv-k9qIJyXH" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn import datasets\n", + "import matplotlib.pyplot as plt \n", + "\n", + "def generate_2clusters_dataset(num_lab = 10, num_unlab=740, num_test=250):\n", + " num_samples = num_lab + num_unlab + num_test\n", + " # Génération de 1000 données du dataset des 2 lunes\n", + " x, y = datasets.make_blobs(n_samples=[round(num_samples/2), round(num_samples/2)], n_features=2, center_box=(- 3, 3), random_state=1)\n", + "\n", + " x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=num_test/num_samples, random_state=1)\n", + " x_train_lab, x_train_unlab, y_train_lab, y_train_unlab = train_test_split(x_train, y_train, test_size=num_unlab/(num_unlab+num_lab), random_state=6)\n", + "\n", + " return x_train_lab, y_train_lab, x_train_unlab, y_train_unlab, x_test, y_test\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "OBwkuDKFLKdH" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10, 2) (740, 2) (250, 2)\n", + "(10,) (740,) (250,)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_train_lab, y_train_lab, x_train_unlab, y_train_unlab, x_test, y_test = generate_2clusters_dataset(num_lab = 10, num_unlab=740, num_test=250)\n", + "\n", + "print(x_train_lab.shape, x_train_unlab.shape, x_test.shape)\n", + "print(y_train_lab.shape, y_train_unlab.shape, y_test.shape)\n", + "\n", + "# Affichage des données\n", + "plt.plot(x_train_unlab[y_train_unlab==0,0], x_train_unlab[y_train_unlab==0,1], 'b.')\n", + "plt.plot(x_train_unlab[y_train_unlab==1,0], x_train_unlab[y_train_unlab==1,1], 'r.')\n", + "\n", + "plt.plot(x_test[y_test==0,0], x_test[y_test==0,1], 'b+')\n", + "plt.plot(x_test[y_test==1,0], x_test[y_test==1,1], 'r+')\n", + "\n", + "plt.plot(x_train_lab[y_train_lab==0,0], x_train_lab[y_train_lab==0,1], 'b.', markersize=30)\n", + "plt.plot(x_train_lab[y_train_lab==1,0], x_train_lab[y_train_lab==1,1], 'r.', markersize=30)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sKR9vNgsLp_J" + }, + "source": [ + "### Dataset des 2 lunes" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_AFhsTUQwIxt" + }, + "source": [ + "\n", + "\n", + "
Figure 1: Comparaison de différents algorithmes semi-supervisés sur le dataset des 2 lunes
" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "tCw5v2JDLwau" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn import datasets\n", + "import matplotlib.pyplot as plt \n", + "\n", + "def generate_2moons_dataset(num_lab = 10, num_unlab=740, num_test=250):\n", + " num_samples = num_lab + num_unlab + num_test\n", + " # Génération de 1000 données du dataset des 2 lunes\n", + " x, y = datasets.make_moons(n_samples=num_samples, noise=0.1, random_state=1)\n", + "\n", + " x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=num_test/num_samples, random_state=1)\n", + " x_train_lab, x_train_unlab, y_train_lab, y_train_unlab = train_test_split(x_train, y_train, test_size=num_unlab/(num_unlab+num_lab), random_state=6)\n", + "\n", + " return x_train_lab, y_train_lab, x_train_unlab, y_train_unlab, x_test, y_test\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "FkQ1L5I1MBkH" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10, 2) (740, 2) (250, 2)\n", + "(10,) (740,) (250,)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_train_lab, y_train_lab, x_train_unlab, y_train_unlab, x_test, y_test = generate_2moons_dataset(num_lab = 10, num_unlab=740, num_test=250)\n", + "\n", + "print(x_train_lab.shape, x_train_unlab.shape, x_test.shape)\n", + "print(y_train_lab.shape, y_train_unlab.shape, y_test.shape)\n", + "\n", + "# Affichage des données\n", + "plt.plot(x_train_unlab[y_train_unlab==0,0], x_train_unlab[y_train_unlab==0,1], 'b.')\n", + "plt.plot(x_train_unlab[y_train_unlab==1,0], x_train_unlab[y_train_unlab==1,1], 'r.')\n", + "\n", + "plt.plot(x_test[y_test==0,0], x_test[y_test==0,1], 'b+')\n", + "plt.plot(x_test[y_test==1,0], x_test[y_test==1,1], 'r+')\n", + "\n", + "plt.plot(x_train_lab[y_train_lab==0,0], x_train_lab[y_train_lab==0,1], 'b.', markersize=30)\n", + "plt.plot(x_train_lab[y_train_lab==1,0], x_train_lab[y_train_lab==1,1], 'r.', markersize=30)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NIGZe-yAQq-A" + }, + "source": [ + "## Modèles" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jaPezVmtK5tC" + }, + "source": [ + "Nous allons dès maintenant préparer les modèles que nous utiliserons dans la suite.\n", + "\n", + "**Travail à faire** Complétez les modèles ci-dessous : " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mfw8EKUuUpt6" + }, + "source": [ + "Pour le dataset des 2 clusters, un simple perceptron monocouche suffira :" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "id": "BryV3CDKQytA" + }, + "outputs": [], + "source": [ + "from keras.layers import Input, Dense\n", + "from keras.models import Model\n", + "\n", + "# Ici, écrire un simple perceptron monocouche\n", + "def create_model_2clusters():\n", + "\n", + " inputs = Input(shape=(2,))\n", + "\n", + " outputs = Dense(1, activation='sigmoid')(inputs)\n", + "\n", + " model = Model(inputs=inputs, outputs=outputs) \n", + "\n", + " return model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NrE8ZQCpUuxg" + }, + "source": [ + "Pour le dataset des 2 lunes, implémentez un perceptron multi-couches à une couche cachée, par exemple de 20 neurones." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "id": "o1jcG_4pyGlx" + }, + "outputs": [], + "source": [ + "# Ici, écrire un perceptron multi-couches à une seule couche cachée comprenant 20 neurones\n", + "def create_model_2moons():\n", + "\n", + " inputs = Input(shape=(2,))\n", + "\n", + " inter = Dense(20, activation=\"relu\")(inputs) \n", + "\n", + " outputs = Dense(1, activation=\"sigmoid\")(inter)\n", + " \n", + " model = Model(inputs=inputs, outputs=outputs) \n", + "\n", + " return model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JMaTgZJcQbIh" + }, + "source": [ + "## Apprentissage supervisé" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hGTfv5YfMAXY" + }, + "source": [ + "Commencez par bien lire le code ci-dessous, qui vous permet de mettre en place un apprentissage supervisé en détaillant la boucle d'apprentissage. Cela nous permettra d'avoir plus de contrôle dans la suite pour implémenter les algorithmes semi-supervisés. Cela vous fournira également une base contre laquelle comparer les algorithmes semi-supervisés.\n", + "\n", + "En quelques mots, le code est organisé autour d'une double boucle : une sur les *epochs*, et la 2nde sur les *mini-batches*.\n", + "\n", + "Pour chaque nouveau batch de données, on réalise la succession d'étapes suivantes dans un bloc **GradientTape** qui permet le calcul automatique des gradients : \n", + "\n", + "\n", + "1. Prédiction de la sortie du modèle sur les données du batch\n", + "2. Calcul de la fonction de perte entre sortie du réseau et labels réels associés aux élements du batch\n", + "3. Calcul des gradients de la perte par rapport aux paramètres du réseau (par différentiation automatique)\n", + "4. Mise à jour des paramètres grâce aux gradients calculés. \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fbmhai8PVXVd" + }, + "source": [ + "### Dataset des 2 clusters" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "id": "XP5XgJRQQm5_" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0 : Loss : 1.5559, Acc : 0.1000, Test Acc : 0.0560\n", + "Epoch 1 : Loss : 1.5317, Acc : 0.1000, Test Acc : 0.0520\n", + "Epoch 2 : Loss : 1.5078, Acc : 0.1000, Test Acc : 0.0520\n", + "Epoch 3 : Loss : 1.4840, Acc : 0.1000, Test Acc : 0.0480\n", + "Epoch 4 : Loss : 1.4604, Acc : 0.1000, Test Acc : 0.0440\n", + "Epoch 5 : Loss : 1.4371, Acc : 0.0000, Test Acc : 0.0400\n", + "Epoch 6 : Loss : 1.4139, Acc : 0.0000, Test Acc : 0.0400\n", + "Epoch 7 : Loss : 1.3910, Acc : 0.0000, Test Acc : 0.0400\n", + "Epoch 8 : Loss : 1.3683, Acc : 0.0000, Test Acc : 0.0440\n", + "Epoch 9 : Loss : 1.3459, Acc : 0.0000, Test Acc : 0.0440\n", + "Epoch 10 : Loss : 1.3237, Acc : 0.0000, Test Acc : 0.0480\n", + "Epoch 11 : Loss : 1.3018, Acc : 0.0000, Test Acc : 0.0480\n", + "Epoch 12 : Loss : 1.2802, Acc : 0.0000, Test Acc : 0.0480\n", + "Epoch 13 : Loss : 1.2588, Acc : 0.0000, Test Acc : 0.0480\n", + "Epoch 14 : Loss : 1.2377, Acc : 0.0000, Test Acc : 0.0480\n", + "Epoch 15 : Loss : 1.2169, Acc : 0.0000, Test Acc : 0.0480\n", + "Epoch 16 : Loss : 1.1964, Acc : 0.0000, Test Acc : 0.0440\n", + "Epoch 17 : Loss : 1.1762, Acc : 0.0000, Test Acc : 0.0400\n", + "Epoch 18 : Loss : 1.1563, Acc : 0.0000, Test Acc : 0.0440\n", + "Epoch 19 : Loss : 1.1367, Acc : 0.0000, Test Acc : 0.0440\n", + "Epoch 20 : Loss : 1.1175, Acc : 0.0000, Test Acc : 0.0440\n", + "Epoch 21 : Loss : 1.0985, Acc : 0.0000, Test Acc : 0.0480\n", + "Epoch 22 : Loss : 1.0798, Acc : 0.0000, Test Acc : 0.0480\n", + "Epoch 23 : Loss : 1.0614, Acc : 0.0000, Test Acc : 0.0480\n", + "Epoch 24 : Loss : 1.0433, Acc : 0.0000, Test Acc : 0.0520\n", + "Epoch 25 : Loss : 1.0256, Acc : 0.0000, Test Acc : 0.0560\n", + "Epoch 26 : Loss : 1.0081, Acc : 0.0000, Test Acc : 0.0600\n", + "Epoch 27 : Loss : 0.9908, Acc : 0.0000, Test Acc : 0.0560\n", + "Epoch 28 : Loss : 0.9739, Acc : 0.0000, Test Acc : 0.0680\n", + "Epoch 29 : Loss : 0.9572, Acc : 0.0000, Test Acc : 0.0760\n", + "Epoch 30 : Loss : 0.9408, Acc : 0.1000, Test Acc : 0.0800\n", + "Epoch 31 : Loss : 0.9247, Acc : 0.1000, Test Acc : 0.0840\n", + "Epoch 32 : Loss : 0.9088, Acc : 0.1000, Test Acc : 0.0880\n", + "Epoch 33 : Loss : 0.8932, Acc : 0.1000, Test Acc : 0.0880\n", + "Epoch 34 : Loss : 0.8778, Acc : 0.1000, Test Acc : 0.1080\n", + "Epoch 35 : Loss : 0.8627, Acc : 0.1000, Test Acc : 0.1040\n", + "Epoch 36 : Loss : 0.8479, Acc : 0.1000, Test Acc : 0.1200\n", + "Epoch 37 : Loss : 0.8333, Acc : 0.1000, Test Acc : 0.1360\n", + "Epoch 38 : Loss : 0.8190, Acc : 0.1000, Test Acc : 0.1600\n", + "Epoch 39 : Loss : 0.8049, Acc : 0.3000, Test Acc : 0.1760\n", + "Epoch 40 : Loss : 0.7910, Acc : 0.3000, Test Acc : 0.2080\n", + "Epoch 41 : Loss : 0.7775, Acc : 0.4000, Test Acc : 0.2360\n", + "Epoch 42 : Loss : 0.7641, Acc : 0.4000, Test Acc : 0.3080\n", + "Epoch 43 : Loss : 0.7510, Acc : 0.4000, Test Acc : 0.3680\n", + "Epoch 44 : Loss : 0.7382, Acc : 0.4000, Test Acc : 0.4280\n", + "Epoch 45 : Loss : 0.7256, Acc : 0.5000, Test Acc : 0.4680\n", + "Epoch 46 : Loss : 0.7133, Acc : 0.5000, Test Acc : 0.5120\n", + "Epoch 47 : Loss : 0.7012, Acc : 0.5000, Test Acc : 0.5240\n", + "Epoch 48 : Loss : 0.6893, Acc : 0.5000, Test Acc : 0.5400\n", + "Epoch 49 : Loss : 0.6777, Acc : 0.5000, Test Acc : 0.5480\n", + "Epoch 50 : Loss : 0.6663, Acc : 0.5000, Test Acc : 0.5800\n", + "Epoch 51 : Loss : 0.6552, Acc : 0.5000, Test Acc : 0.6120\n", + "Epoch 52 : Loss : 0.6443, Acc : 0.5000, Test Acc : 0.6520\n", + "Epoch 53 : Loss : 0.6336, Acc : 0.7000, Test Acc : 0.6960\n", + "Epoch 54 : Loss : 0.6232, Acc : 0.7000, Test Acc : 0.7560\n", + "Epoch 55 : Loss : 0.6130, Acc : 0.7000, Test Acc : 0.7920\n", + "Epoch 56 : Loss : 0.6030, Acc : 0.8000, Test Acc : 0.8120\n", + "Epoch 57 : Loss : 0.5932, Acc : 1.0000, Test Acc : 0.8280\n", + "Epoch 58 : Loss : 0.5836, Acc : 1.0000, Test Acc : 0.8520\n", + "Epoch 59 : Loss : 0.5743, Acc : 1.0000, Test Acc : 0.8720\n", + "Epoch 60 : Loss : 0.5651, Acc : 1.0000, Test Acc : 0.8840\n", + "Epoch 61 : Loss : 0.5562, Acc : 1.0000, Test Acc : 0.8920\n", + "Epoch 62 : Loss : 0.5474, Acc : 1.0000, Test Acc : 0.9000\n", + "Epoch 63 : Loss : 0.5389, Acc : 1.0000, Test Acc : 0.9040\n", + "Epoch 64 : Loss : 0.5306, Acc : 1.0000, Test Acc : 0.9080\n", + "Epoch 65 : Loss : 0.5224, Acc : 1.0000, Test Acc : 0.9120\n", + "Epoch 66 : Loss : 0.5144, Acc : 1.0000, Test Acc : 0.9160\n", + "Epoch 67 : Loss : 0.5067, Acc : 1.0000, Test Acc : 0.9120\n", + "Epoch 68 : Loss : 0.4991, Acc : 1.0000, Test Acc : 0.9160\n", + "Epoch 69 : Loss : 0.4916, Acc : 1.0000, Test Acc : 0.9200\n", + "Epoch 70 : Loss : 0.4844, Acc : 1.0000, Test Acc : 0.9200\n", + "Epoch 71 : Loss : 0.4773, Acc : 1.0000, Test Acc : 0.9240\n", + "Epoch 72 : Loss : 0.4704, Acc : 1.0000, Test Acc : 0.9280\n", + "Epoch 73 : Loss : 0.4636, Acc : 1.0000, Test Acc : 0.9360\n", + "Epoch 74 : Loss : 0.4570, Acc : 1.0000, Test Acc : 0.9400\n", + "Epoch 75 : Loss : 0.4505, Acc : 1.0000, Test Acc : 0.9400\n", + "Epoch 76 : Loss : 0.4442, Acc : 1.0000, Test Acc : 0.9440\n", + "Epoch 77 : Loss : 0.4380, Acc : 1.0000, Test Acc : 0.9440\n", + "Epoch 78 : Loss : 0.4320, Acc : 1.0000, Test Acc : 0.9440\n", + "Epoch 79 : Loss : 0.4261, Acc : 1.0000, Test Acc : 0.9440\n", + "Epoch 80 : Loss : 0.4204, Acc : 1.0000, Test Acc : 0.9440\n", + "Epoch 81 : Loss : 0.4147, Acc : 1.0000, Test Acc : 0.9440\n", + "Epoch 82 : Loss : 0.4092, Acc : 1.0000, Test Acc : 0.9440\n", + "Epoch 83 : Loss : 0.4039, Acc : 1.0000, Test Acc : 0.9440\n", + "Epoch 84 : Loss : 0.3986, Acc : 1.0000, Test Acc : 0.9440\n", + "Epoch 85 : Loss : 0.3935, Acc : 1.0000, Test Acc : 0.9480\n", + "Epoch 86 : Loss : 0.3885, Acc : 1.0000, Test Acc : 0.9520\n", + "Epoch 87 : Loss : 0.3836, Acc : 1.0000, Test Acc : 0.9520\n", + "Epoch 88 : Loss : 0.3788, Acc : 1.0000, Test Acc : 0.9520\n", + "Epoch 89 : Loss : 0.3741, Acc : 1.0000, Test Acc : 0.9520\n", + "Epoch 90 : Loss : 0.3695, Acc : 1.0000, Test Acc : 0.9520\n", + "Epoch 91 : Loss : 0.3650, Acc : 1.0000, Test Acc : 0.9520\n", + "Epoch 92 : Loss : 0.3606, Acc : 1.0000, Test Acc : 0.9520\n", + "Epoch 93 : Loss : 0.3563, Acc : 1.0000, Test Acc : 0.9520\n", + "Epoch 94 : Loss : 0.3521, Acc : 1.0000, Test Acc : 0.9520\n", + "Epoch 95 : Loss : 0.3480, Acc : 1.0000, Test Acc : 0.9520\n", + "Epoch 96 : Loss : 0.3440, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 97 : Loss : 0.3400, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 98 : Loss : 0.3362, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 99 : Loss : 0.3324, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 100 : Loss : 0.3287, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 101 : Loss : 0.3251, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 102 : Loss : 0.3215, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 103 : Loss : 0.3181, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 104 : Loss : 0.3147, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 105 : Loss : 0.3113, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 106 : Loss : 0.3081, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 107 : Loss : 0.3049, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 108 : Loss : 0.3017, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 109 : Loss : 0.2987, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 110 : Loss : 0.2956, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 111 : Loss : 0.2927, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 112 : Loss : 0.2898, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 113 : Loss : 0.2870, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 114 : Loss : 0.2842, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 115 : Loss : 0.2814, Acc : 1.0000, Test Acc : 0.9560\n", + "Epoch 116 : Loss : 0.2787, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 117 : Loss : 0.2761, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 118 : Loss : 0.2735, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 119 : Loss : 0.2710, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 120 : Loss : 0.2685, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 121 : Loss : 0.2661, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 122 : Loss : 0.2637, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 123 : Loss : 0.2613, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 124 : Loss : 0.2590, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 125 : Loss : 0.2567, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 126 : Loss : 0.2545, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 127 : Loss : 0.2523, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 128 : Loss : 0.2501, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 129 : Loss : 0.2480, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 130 : Loss : 0.2459, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 131 : Loss : 0.2439, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 132 : Loss : 0.2418, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 133 : Loss : 0.2399, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 134 : Loss : 0.2379, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 135 : Loss : 0.2360, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 136 : Loss : 0.2341, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 137 : Loss : 0.2323, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 138 : Loss : 0.2304, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 139 : Loss : 0.2286, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 140 : Loss : 0.2269, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 141 : Loss : 0.2251, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 142 : Loss : 0.2234, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 143 : Loss : 0.2217, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 144 : Loss : 0.2201, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 145 : Loss : 0.2184, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 146 : Loss : 0.2168, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 147 : Loss : 0.2152, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 148 : Loss : 0.2137, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 149 : Loss : 0.2121, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 150 : Loss : 0.2106, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 151 : Loss : 0.2091, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 152 : Loss : 0.2076, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 153 : Loss : 0.2062, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 154 : Loss : 0.2048, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 155 : Loss : 0.2034, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 156 : Loss : 0.2020, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 157 : Loss : 0.2006, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 158 : Loss : 0.1992, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 159 : Loss : 0.1979, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 160 : Loss : 0.1966, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 161 : Loss : 0.1953, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 162 : Loss : 0.1940, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 163 : Loss : 0.1928, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 164 : Loss : 0.1915, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 165 : Loss : 0.1903, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 166 : Loss : 0.1891, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 167 : Loss : 0.1879, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 168 : Loss : 0.1867, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 169 : Loss : 0.1855, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 170 : Loss : 0.1844, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 171 : Loss : 0.1833, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 172 : Loss : 0.1821, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 173 : Loss : 0.1810, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 174 : Loss : 0.1799, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 175 : Loss : 0.1789, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 176 : Loss : 0.1778, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 177 : Loss : 0.1767, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 178 : Loss : 0.1757, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 179 : Loss : 0.1747, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 180 : Loss : 0.1737, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 181 : Loss : 0.1727, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 182 : Loss : 0.1717, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 183 : Loss : 0.1707, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 184 : Loss : 0.1697, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 185 : Loss : 0.1688, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 186 : Loss : 0.1678, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 187 : Loss : 0.1669, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 188 : Loss : 0.1660, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 189 : Loss : 0.1651, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 190 : Loss : 0.1642, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 191 : Loss : 0.1633, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 192 : Loss : 0.1624, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 193 : Loss : 0.1615, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 194 : Loss : 0.1607, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 195 : Loss : 0.1598, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 196 : Loss : 0.1590, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 197 : Loss : 0.1581, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 198 : Loss : 0.1573, Acc : 1.0000, Test Acc : 0.9600\n", + "Epoch 199 : Loss : 0.1565, Acc : 1.0000, Test Acc : 0.9600\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "import math\n", + "\n", + "# Données et modèle du problème des 2 clusters\n", + "x_train_lab, y_train_lab, x_train_unlab, y_train_unlab, x_test, y_test = generate_2clusters_dataset(num_lab = 10, num_unlab=740, num_test=250)\n", + "model = create_model_2clusters()\n", + "\n", + "# Hyperparamètres de l'apprentissage\n", + "epochs = 200\n", + "batch_size = 32\n", + "if batch_size < x_train_lab.shape[0]:\n", + " steps_per_epoch = math.floor(x_train_lab.shape[0]/batch_size)\n", + "else:\n", + " steps_per_epoch = 1\n", + " batch_size = x_train_lab.shape[0]\n", + "\n", + "# Instanciation d'un optimiseur et d'une fonction de coût.\n", + "optimizer = keras.optimizers.Adam(learning_rate=1e-2)\n", + "loss_fn = keras.losses.BinaryCrossentropy()\n", + "\n", + "# Préparation des métriques pour le suivi de la performance du modèle.\n", + "train_acc_metric = keras.metrics.BinaryAccuracy()\n", + "test_acc_metric = keras.metrics.BinaryAccuracy()\n", + "\n", + "# Indices de l'ensemble labellisé\n", + "indices = np.arange(x_train_lab.shape[0])\n", + "\n", + "# Boucle sur les epochs\n", + "for epoch in range(epochs):\n", + "\n", + " # A chaque nouvelle epoch, on randomise les indices de l'ensemble labellisé\n", + " np.random.shuffle(indices) \n", + "\n", + " # Et on recommence à cumuler la loss\n", + " cum_loss_value = 0\n", + "\n", + " for step in range(steps_per_epoch):\n", + "\n", + " # Sélection des données du prochain batch\n", + " x_batch = x_train_lab[indices[step*batch_size: (step+1)*batch_size]]\n", + " y_batch = y_train_lab[indices[step*batch_size: (step+1)*batch_size]]\n", + "\n", + " # Etape nécessaire pour comparer y_batch à la sortie du réseau\n", + " y_batch = np.expand_dims(y_batch, 1)\n", + "\n", + " # Les opérations effectuées par le modèle dans ce bloc sont suivies et permettront\n", + " # la différentiation automatique.\n", + " with tf.GradientTape() as tape:\n", + "\n", + " # Application du réseau aux données d'entrée\n", + " y_pred = model(x_batch, training=True) # Logits for this minibatch\n", + "\n", + " # Calcul de la fonction de perte sur ce batch\n", + " loss_value = loss_fn(y_batch, y_pred)\n", + "\n", + " # Calcul des gradients par différentiation automatique\n", + " grads = tape.gradient(loss_value, model.trainable_weights)\n", + "\n", + " # Réalisation d'une itération de la descente de gradient (mise à jour des paramètres du réseau)\n", + " optimizer.apply_gradients(zip(grads, model.trainable_weights))\n", + "\n", + " # Mise à jour de la métrique\n", + " train_acc_metric.update_state(y_batch, y_pred)\n", + "\n", + " cum_loss_value = cum_loss_value + loss_value\n", + "\n", + " # Calcul de la précision à la fin de l'epoch\n", + " train_acc = train_acc_metric.result()\n", + "\n", + " # Calcul de la précision sur l'ensemble de test à la fin de l'epoch\n", + " test_logits = model(x_test, training=False)\n", + " test_acc_metric.update_state(np.expand_dims(y_test, 1), test_logits)\n", + " test_acc = test_acc_metric.result()\n", + "\n", + " print(\"Epoch %4d : Loss : %.4f, Acc : %.4f, Test Acc : %.4f\" % (epoch, float(cum_loss_value/steps_per_epoch), float(train_acc), float(test_acc)))\n", + "\n", + " # Remise à zéro des métriques pour la prochaine epoch\n", + " train_acc_metric.reset_states()\n", + " test_acc_metric.reset_states() " + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "id": "FcnTF5WWVacl" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from mlxtend.plotting import plot_decision_regions\n", + "\n", + "# Affichage des données\n", + "plt.plot(x_train_unlab[y_train_unlab==0,0], x_train_unlab[y_train_unlab==0,1], 'b.')\n", + "plt.plot(x_train_unlab[y_train_unlab==1,0], x_train_unlab[y_train_unlab==1,1], 'r.')\n", + "\n", + "plt.plot(x_test[y_test==0,0], x_test[y_test==0,1], 'b+')\n", + "plt.plot(x_test[y_test==1,0], x_test[y_test==1,1], 'r+')\n", + "\n", + "plt.plot(x_train_lab[y_train_lab==0,0], x_train_lab[y_train_lab==0,1], 'b.', markersize=30)\n", + "plt.plot(x_train_lab[y_train_lab==1,0], x_train_lab[y_train_lab==1,1], 'r.', markersize=30)\n", + "\n", + "plt.show()\n", + "\n", + "#Affichage de la frontière de décision\n", + "plot_decision_regions(x_train_unlab, y_train_unlab, clf=model, legend=2)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "caF0geTEx5Zv" + }, + "source": [ + "### Dataset des 2 lunes" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GdFbVzKbMcYE" + }, + "source": [ + "**Travail à faire** : Mettez en place le même apprentissage pour le dataset des 2 lunes. " + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0 : Loss : 0.6756, Acc : 0.7000, Test Acc : 0.7200\n", + "Epoch 1 : Loss : 0.6550, Acc : 0.9000, Test Acc : 0.7560\n", + "Epoch 2 : Loss : 0.6354, Acc : 0.9000, Test Acc : 0.7600\n", + "Epoch 3 : Loss : 0.6172, Acc : 0.8000, Test Acc : 0.8000\n", + "Epoch 4 : Loss : 0.6000, Acc : 0.8000, Test Acc : 0.8120\n", + "Epoch 5 : Loss : 0.5837, Acc : 0.8000, Test Acc : 0.8200\n", + "Epoch 6 : Loss : 0.5677, Acc : 0.8000, Test Acc : 0.8280\n", + "Epoch 7 : Loss : 0.5520, Acc : 0.8000, Test Acc : 0.8360\n", + "Epoch 8 : Loss : 0.5363, Acc : 0.8000, Test Acc : 0.8360\n", + "Epoch 9 : Loss : 0.5205, Acc : 0.8000, Test Acc : 0.8360\n", + "Epoch 10 : Loss : 0.5050, Acc : 0.8000, Test Acc : 0.8400\n", + "Epoch 11 : Loss : 0.4898, Acc : 0.8000, Test Acc : 0.8400\n", + "Epoch 12 : Loss : 0.4749, Acc : 0.8000, Test Acc : 0.8440\n", + "Epoch 13 : Loss : 0.4607, Acc : 0.8000, Test Acc : 0.8440\n", + "Epoch 14 : Loss : 0.4475, Acc : 0.8000, Test Acc : 0.8400\n", + "Epoch 15 : Loss : 0.4347, Acc : 0.8000, Test Acc : 0.8360\n", + "Epoch 16 : Loss : 0.4223, Acc : 0.8000, Test Acc : 0.8360\n", + "Epoch 17 : Loss : 0.4104, Acc : 0.8000, Test Acc : 0.8360\n", + "Epoch 18 : Loss : 0.3991, Acc : 0.8000, Test Acc : 0.8360\n", + "Epoch 19 : Loss : 0.3886, Acc : 0.8000, Test Acc : 0.8360\n", + "Epoch 20 : Loss : 0.3787, Acc : 0.8000, Test Acc : 0.8440\n", + "Epoch 21 : Loss : 0.3694, Acc : 0.8000, Test Acc : 0.8440\n", + "Epoch 22 : Loss : 0.3606, Acc : 0.8000, Test Acc : 0.8440\n", + "Epoch 23 : Loss : 0.3523, Acc : 0.8000, Test Acc : 0.8440\n", + "Epoch 24 : Loss : 0.3446, Acc : 0.8000, Test Acc : 0.8440\n", + "Epoch 25 : Loss : 0.3374, Acc : 0.8000, Test Acc : 0.8440\n", + "Epoch 26 : Loss : 0.3306, Acc : 0.8000, Test Acc : 0.8440\n", + "Epoch 27 : Loss : 0.3242, Acc : 0.8000, Test Acc : 0.8440\n", + "Epoch 28 : Loss : 0.3181, Acc : 0.8000, Test Acc : 0.8440\n", + "Epoch 29 : Loss : 0.3125, Acc : 0.8000, Test Acc : 0.8440\n", + "Epoch 30 : Loss : 0.3072, Acc : 0.8000, Test Acc : 0.8440\n", + "Epoch 31 : Loss : 0.3021, Acc : 0.8000, Test Acc : 0.8440\n", + "Epoch 32 : Loss : 0.2972, Acc : 0.8000, Test Acc : 0.8520\n", + "Epoch 33 : Loss : 0.2924, Acc : 0.8000, Test Acc : 0.8520\n", + "Epoch 34 : Loss : 0.2878, Acc : 0.8000, Test Acc : 0.8560\n", + "Epoch 35 : Loss : 0.2834, Acc : 0.8000, Test Acc : 0.8560\n", + "Epoch 36 : Loss : 0.2790, Acc : 0.8000, Test Acc : 0.8560\n", + "Epoch 37 : Loss : 0.2747, Acc : 0.8000, Test Acc : 0.8560\n", + "Epoch 38 : Loss : 0.2705, Acc : 0.8000, Test Acc : 0.8560\n", + "Epoch 39 : Loss : 0.2664, Acc : 0.8000, Test Acc : 0.8560\n", + "Epoch 40 : Loss : 0.2623, Acc : 0.8000, Test Acc : 0.8600\n", + "Epoch 41 : Loss : 0.2583, Acc : 0.8000, Test Acc : 0.8640\n", + "Epoch 42 : Loss : 0.2544, Acc : 0.8000, Test Acc : 0.8680\n", + "Epoch 43 : Loss : 0.2506, Acc : 0.8000, Test Acc : 0.8800\n", + "Epoch 44 : Loss : 0.2468, Acc : 0.8000, Test Acc : 0.8800\n", + "Epoch 45 : Loss : 0.2431, Acc : 0.8000, Test Acc : 0.8880\n", + "Epoch 46 : Loss : 0.2394, Acc : 0.8000, Test Acc : 0.8880\n", + "Epoch 47 : Loss : 0.2362, Acc : 0.8000, Test Acc : 0.8880\n", + "Epoch 48 : Loss : 0.2334, Acc : 0.8000, Test Acc : 0.8880\n", + "Epoch 49 : Loss : 0.2306, Acc : 0.8000, Test Acc : 0.8880\n", + "Epoch 50 : Loss : 0.2281, Acc : 0.8000, Test Acc : 0.8920\n", + "Epoch 51 : Loss : 0.2258, Acc : 0.8000, Test Acc : 0.8960\n", + "Epoch 52 : Loss : 0.2237, Acc : 0.8000, Test Acc : 0.9080\n", + "Epoch 53 : Loss : 0.2215, Acc : 0.8000, Test Acc : 0.9040\n", + "Epoch 54 : Loss : 0.2194, Acc : 0.8000, Test Acc : 0.9040\n", + "Epoch 55 : Loss : 0.2174, Acc : 0.8000, Test Acc : 0.9080\n", + "Epoch 56 : Loss : 0.2154, Acc : 0.8000, Test Acc : 0.9080\n", + "Epoch 57 : Loss : 0.2134, Acc : 0.8000, Test Acc : 0.9080\n", + "Epoch 58 : Loss : 0.2115, Acc : 0.8000, Test Acc : 0.9120\n", + "Epoch 59 : Loss : 0.2096, Acc : 0.8000, Test Acc : 0.9120\n", + "Epoch 60 : Loss : 0.2078, Acc : 0.8000, Test Acc : 0.9120\n", + "Epoch 61 : Loss : 0.2061, Acc : 0.8000, Test Acc : 0.9120\n", + "Epoch 62 : Loss : 0.2044, Acc : 0.8000, Test Acc : 0.9120\n", + "Epoch 63 : Loss : 0.2028, Acc : 0.8000, Test Acc : 0.9120\n", + "Epoch 64 : Loss : 0.2012, Acc : 0.8000, Test Acc : 0.9120\n", + "Epoch 65 : Loss : 0.1997, Acc : 0.9000, Test Acc : 0.9120\n", + "Epoch 66 : Loss : 0.1982, Acc : 0.9000, Test Acc : 0.9120\n", + "Epoch 67 : Loss : 0.1968, Acc : 0.9000, Test Acc : 0.9120\n", + "Epoch 68 : Loss : 0.1954, Acc : 0.9000, Test Acc : 0.9120\n", + "Epoch 69 : Loss : 0.1941, Acc : 0.9000, Test Acc : 0.9120\n", + "Epoch 70 : Loss : 0.1928, Acc : 0.9000, Test Acc : 0.9120\n", + "Epoch 71 : Loss : 0.1916, Acc : 0.9000, Test Acc : 0.9080\n", + "Epoch 72 : Loss : 0.1904, Acc : 0.9000, Test Acc : 0.9080\n", + "Epoch 73 : Loss : 0.1893, Acc : 0.9000, Test Acc : 0.9080\n", + "Epoch 74 : Loss : 0.1882, Acc : 0.9000, Test Acc : 0.9080\n", + "Epoch 75 : Loss : 0.1872, Acc : 0.9000, Test Acc : 0.9000\n", + "Epoch 76 : Loss : 0.1862, Acc : 0.9000, Test Acc : 0.9000\n", + "Epoch 77 : Loss : 0.1854, Acc : 0.9000, Test Acc : 0.8960\n", + "Epoch 78 : Loss : 0.1844, Acc : 0.9000, Test Acc : 0.8960\n", + "Epoch 79 : Loss : 0.1835, Acc : 0.9000, Test Acc : 0.8960\n", + "Epoch 80 : Loss : 0.1826, Acc : 0.9000, Test Acc : 0.8960\n", + "Epoch 81 : Loss : 0.1818, Acc : 0.9000, Test Acc : 0.8960\n", + "Epoch 82 : Loss : 0.1812, Acc : 0.9000, Test Acc : 0.8960\n", + "Epoch 83 : Loss : 0.1805, Acc : 0.9000, Test Acc : 0.9000\n", + "Epoch 84 : Loss : 0.1797, Acc : 0.9000, Test Acc : 0.9000\n", + "Epoch 85 : Loss : 0.1789, Acc : 0.9000, Test Acc : 0.9000\n", + "Epoch 86 : Loss : 0.1782, Acc : 0.9000, Test Acc : 0.8960\n", + "Epoch 87 : Loss : 0.1776, Acc : 0.9000, Test Acc : 0.8960\n", + "Epoch 88 : Loss : 0.1769, Acc : 0.9000, Test Acc : 0.8920\n", + "Epoch 89 : Loss : 0.1763, Acc : 0.9000, Test Acc : 0.8920\n", + "Epoch 90 : Loss : 0.1757, Acc : 0.9000, Test Acc : 0.8800\n", + "Epoch 91 : Loss : 0.1750, Acc : 0.9000, Test Acc : 0.8800\n", + "Epoch 92 : Loss : 0.1744, Acc : 0.9000, Test Acc : 0.8800\n", + "Epoch 93 : Loss : 0.1739, Acc : 0.9000, Test Acc : 0.8800\n", + "Epoch 94 : Loss : 0.1733, Acc : 0.9000, Test Acc : 0.8800\n", + "Epoch 95 : Loss : 0.1727, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 96 : Loss : 0.1722, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 97 : Loss : 0.1716, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 98 : Loss : 0.1711, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 99 : Loss : 0.1706, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 100 : Loss : 0.1701, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 101 : Loss : 0.1696, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 102 : Loss : 0.1691, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 103 : Loss : 0.1687, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 104 : Loss : 0.1682, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 105 : Loss : 0.1677, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 106 : Loss : 0.1673, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 107 : Loss : 0.1669, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 108 : Loss : 0.1664, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 109 : Loss : 0.1660, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 110 : Loss : 0.1656, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 111 : Loss : 0.1652, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 112 : Loss : 0.1648, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 113 : Loss : 0.1644, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 114 : Loss : 0.1640, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 115 : Loss : 0.1636, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 116 : Loss : 0.1632, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 117 : Loss : 0.1628, Acc : 0.9000, Test Acc : 0.8720\n", + "Epoch 118 : Loss : 0.1624, Acc : 0.9000, Test Acc : 0.8720\n", + "Epoch 119 : Loss : 0.1620, Acc : 0.9000, Test Acc : 0.8720\n", + "Epoch 120 : Loss : 0.1617, Acc : 0.9000, Test Acc : 0.8760\n", + "Epoch 121 : Loss : 0.1613, Acc : 0.9000, Test Acc : 0.8720\n", + "Epoch 122 : Loss : 0.1610, Acc : 0.9000, Test Acc : 0.8720\n", + "Epoch 123 : Loss : 0.1606, Acc : 0.9000, Test Acc : 0.8720\n", + "Epoch 124 : Loss : 0.1602, Acc : 0.9000, Test Acc : 0.8720\n", + "Epoch 125 : Loss : 0.1599, Acc : 0.9000, Test Acc : 0.8720\n", + "Epoch 126 : Loss : 0.1595, Acc : 0.9000, Test Acc : 0.8720\n", + "Epoch 127 : Loss : 0.1591, Acc : 0.9000, Test Acc : 0.8720\n", + "Epoch 128 : Loss : 0.1588, Acc : 0.9000, Test Acc : 0.8720\n", + "Epoch 129 : Loss : 0.1585, Acc : 0.9000, Test Acc : 0.8720\n", + "Epoch 130 : Loss : 0.1581, Acc : 0.9000, Test Acc : 0.8720\n", + "Epoch 131 : Loss : 0.1578, Acc : 0.9000, Test Acc : 0.8720\n", + "Epoch 132 : Loss : 0.1574, Acc : 0.9000, Test Acc : 0.8720\n", + "Epoch 133 : Loss : 0.1571, Acc : 0.9000, Test Acc : 0.8720\n", + "Epoch 134 : Loss : 0.1567, Acc : 0.9000, Test Acc : 0.8680\n", + "Epoch 135 : Loss : 0.1564, Acc : 0.9000, Test Acc : 0.8680\n", + "Epoch 136 : Loss : 0.1561, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 137 : Loss : 0.1558, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 138 : Loss : 0.1554, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 139 : Loss : 0.1551, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 140 : Loss : 0.1548, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 141 : Loss : 0.1544, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 142 : Loss : 0.1541, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 143 : Loss : 0.1538, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 144 : Loss : 0.1535, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 145 : Loss : 0.1531, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 146 : Loss : 0.1528, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 147 : Loss : 0.1525, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 148 : Loss : 0.1522, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 149 : Loss : 0.1519, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 150 : Loss : 0.1515, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 151 : Loss : 0.1512, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 152 : Loss : 0.1509, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 153 : Loss : 0.1506, Acc : 0.9000, Test Acc : 0.8640\n", + "Epoch 154 : Loss : 0.1503, Acc : 0.9000, Test Acc : 0.8600\n", + "Epoch 155 : Loss : 0.1499, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 156 : Loss : 0.1496, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 157 : Loss : 0.1493, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 158 : Loss : 0.1490, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 159 : Loss : 0.1487, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 160 : Loss : 0.1484, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 161 : Loss : 0.1481, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 162 : Loss : 0.1477, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 163 : Loss : 0.1474, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 164 : Loss : 0.1471, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 165 : Loss : 0.1468, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 166 : Loss : 0.1465, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 167 : Loss : 0.1462, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 168 : Loss : 0.1458, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 169 : Loss : 0.1455, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 170 : Loss : 0.1452, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 171 : Loss : 0.1449, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 172 : Loss : 0.1446, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 173 : Loss : 0.1443, Acc : 0.9000, Test Acc : 0.8560\n", + "Epoch 174 : Loss : 0.1440, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 175 : Loss : 0.1437, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 176 : Loss : 0.1433, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 177 : Loss : 0.1430, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 178 : Loss : 0.1427, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 179 : Loss : 0.1424, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 180 : Loss : 0.1421, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 181 : Loss : 0.1417, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 182 : Loss : 0.1414, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 183 : Loss : 0.1411, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 184 : Loss : 0.1408, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 185 : Loss : 0.1405, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 186 : Loss : 0.1402, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 187 : Loss : 0.1398, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 188 : Loss : 0.1395, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 189 : Loss : 0.1392, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 190 : Loss : 0.1389, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 191 : Loss : 0.1386, Acc : 0.9000, Test Acc : 0.8520\n", + "Epoch 192 : Loss : 0.1382, Acc : 0.9000, Test Acc : 0.8480\n", + "Epoch 193 : Loss : 0.1379, Acc : 0.9000, Test Acc : 0.8480\n", + "Epoch 194 : Loss : 0.1376, Acc : 0.9000, Test Acc : 0.8480\n", + "Epoch 195 : Loss : 0.1373, Acc : 0.9000, Test Acc : 0.8480\n", + "Epoch 196 : Loss : 0.1369, Acc : 0.9000, Test Acc : 0.8480\n", + "Epoch 197 : Loss : 0.1366, Acc : 0.9000, Test Acc : 0.8480\n", + "Epoch 198 : Loss : 0.1363, Acc : 0.9000, Test Acc : 0.8480\n", + "Epoch 199 : Loss : 0.1360, Acc : 0.9000, Test Acc : 0.8480\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "import math\n", + "\n", + "# Données et modèle du problème des 2 clusters\n", + "x_train_lab, y_train_lab, x_train_unlab, y_train_unlab, x_test, y_test = generate_2moons_dataset(num_lab = 10, num_unlab=740, num_test=250)\n", + "model = create_model_2moons()\n", + "\n", + "# Hyperparamètres de l'apprentissage\n", + "epochs = 200\n", + "batch_size = 32\n", + "if batch_size < x_train_lab.shape[0]:\n", + " steps_per_epoch = math.floor(x_train_lab.shape[0]/batch_size)\n", + "else:\n", + " steps_per_epoch = 1\n", + " batch_size = x_train_lab.shape[0]\n", + "\n", + "# Instanciation d'un optimiseur et d'une fonction de coût.\n", + "optimizer = keras.optimizers.Adam(learning_rate=1e-2)\n", + "loss_fn = keras.losses.BinaryCrossentropy()\n", + "\n", + "# Préparation des métriques pour le suivi de la performance du modèle.\n", + "train_acc_metric = keras.metrics.BinaryAccuracy()\n", + "test_acc_metric = keras.metrics.BinaryAccuracy()\n", + "\n", + "# Indices de l'ensemble labellisé\n", + "indices = np.arange(x_train_lab.shape[0])\n", + "\n", + "# Boucle sur les epochs\n", + "for epoch in range(epochs):\n", + "\n", + " # A chaque nouvelle epoch, on randomise les indices de l'ensemble labellisé\n", + " np.random.shuffle(indices) \n", + "\n", + " # Et on recommence à cumuler la loss\n", + " cum_loss_value = 0\n", + "\n", + " for step in range(steps_per_epoch):\n", + "\n", + " # Sélection des données du prochain batch\n", + " x_batch = x_train_lab[indices[step*batch_size: (step+1)*batch_size]]\n", + " y_batch = y_train_lab[indices[step*batch_size: (step+1)*batch_size]]\n", + "\n", + " # Etape nécessaire pour comparer y_batch à la sortie du réseau\n", + " y_batch = np.expand_dims(y_batch, 1)\n", + "\n", + " # Les opérations effectuées par le modèle dans ce bloc sont suivies et permettront\n", + " # la différentiation automatique.\n", + " with tf.GradientTape() as tape:\n", + "\n", + " # Application du réseau aux données d'entrée\n", + " y_pred = model(x_batch, training=True) # Logits for this minibatch\n", + "\n", + " # Calcul de la fonction de perte sur ce batch\n", + " loss_value = loss_fn(y_batch, y_pred)\n", + "\n", + " # Calcul des gradients par différentiation automatique\n", + " grads = tape.gradient(loss_value, model.trainable_weights)\n", + "\n", + " # Réalisation d'une itération de la descente de gradient (mise à jour des paramètres du réseau)\n", + " optimizer.apply_gradients(zip(grads, model.trainable_weights))\n", + "\n", + " # Mise à jour de la métrique\n", + " train_acc_metric.update_state(y_batch, y_pred)\n", + "\n", + " cum_loss_value = cum_loss_value + loss_value\n", + "\n", + " # Calcul de la précision à la fin de l'epoch\n", + " train_acc = train_acc_metric.result()\n", + "\n", + " # Calcul de la précision sur l'ensemble de test à la fin de l'epoch\n", + " test_logits = model(x_test, training=False)\n", + " test_acc_metric.update_state(np.expand_dims(y_test, 1), test_logits)\n", + " test_acc = test_acc_metric.result()\n", + "\n", + " print(\"Epoch %4d : Loss : %.4f, Acc : %.4f, Test Acc : %.4f\" % (epoch, float(cum_loss_value/steps_per_epoch), float(train_acc), float(test_acc)))\n", + "\n", + " # Remise à zéro des métriques pour la prochaine epoch\n", + " train_acc_metric.reset_states()\n", + " test_acc_metric.reset_states() " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from mlxtend.plotting import plot_decision_regions\n", + "\n", + "# Affichage des données\n", + "plt.plot(x_train_unlab[y_train_unlab==0,0], x_train_unlab[y_train_unlab==0,1], 'b.')\n", + "plt.plot(x_train_unlab[y_train_unlab==1,0], x_train_unlab[y_train_unlab==1,1], 'r.')\n", + "\n", + "plt.plot(x_test[y_test==0,0], x_test[y_test==0,1], 'b+')\n", + "plt.plot(x_test[y_test==1,0], x_test[y_test==1,1], 'r+')\n", + "\n", + "plt.plot(x_train_lab[y_train_lab==0,0], x_train_lab[y_train_lab==0,1], 'b.', markersize=30)\n", + "plt.plot(x_train_lab[y_train_lab==1,0], x_train_lab[y_train_lab==1,1], 'r.', markersize=30)\n", + "\n", + "plt.show()\n", + "\n", + "#Affichage de la frontière de décision\n", + "plot_decision_regions(x_train_unlab, y_train_unlab, clf=model, legend=2)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YPiuBS36V8EG" + }, + "source": [ + "# Minimisation de l'entropie" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UlBFMsFLMtEp" + }, + "source": [ + "Nous allons dans cette partie mettre en place le mécanisme de minimisation d'entropie, conjointement à la minimisation de l'entropie croisée.\n", + "\n", + "Pour commencer, implémentez la fonction de coût qui calcule l'entropie $H$ des prédictions du réseau $\\hat{y}$ :\n", + "$$ H(\\hat{y}) = - ∑_{i=1}^N \\hat{y}_i log(\\hat{y}_i) $$\n", + "\n", + "Pour les exemples simples des datasets des 2 clusters et des 2 lunes, il faut implémenter une entropie binaire ! (plus tard, sur MNIST, il faudra implémenter une version multi-classe de l'entropie)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "id": "1gEt2x_sXFin" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "\n", + "# Calcul de l'entropie de y_pred\n", + "def binary_entropy_loss(y_pred):\n", + " return -tf.reduce_sum(y_pred * tf.math.log(y_pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-L1Li1YtNN87" + }, + "source": [ + "**Travail à faire** : Reprenez maintenant la boucle d'apprentissage supervisé et introduisez la minimisation d'entropie pour régulariser l'apprentissage.\n", + "\n", + "La difficulté principale va être l'introduction des données non labellisées dans la boucle. Ainsi, un batch devra maintenant être composé de données labellisées et non labellisées. Je vous suggère de conserver le même nombre de données labellisées par batch que précédemment (i.e. 16) et de prendre un plus grand nombre de données non labellisées, par exemple 90.\n", + "\n", + "N'oubliez pas également d'introduire un hyperparamètre λ pour contrôler l'équilibre entre perte supervisée et non supervisée. Utilisez un λ constant dans un premier temps, et testez ensuite des variantes qui consisteraient à augmenter progressivement sa valeur au fil des epochs. \n", + "\n", + "La fonction objectif à minimiser aura donc la forme : \n", + "$$ J = \\sum_{(x,y) \\in \\mathcal{L}} CE(y, \\hat{y}) + \\lambda \\sum_{x \\in \\mathcal{U}} H(\\hat{y})\t$$" + ] + }, + { + "cell_type": "code", + "execution_count": 188, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0 : Loss : 1.5490, Acc : 0.7000, Test Acc : 0.7800\n", + "Epoch 1 : Loss : 1.5385, Acc : 0.7000, Test Acc : 0.8000\n", + "Epoch 2 : Loss : 1.5271, Acc : 0.7000, Test Acc : 0.8600\n", + "Epoch 3 : Loss : 1.5151, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 4 : Loss : 1.5028, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 5 : Loss : 1.4902, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 6 : Loss : 1.4767, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 7 : Loss : 1.4626, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 8 : Loss : 1.4474, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 9 : Loss : 1.4315, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 10 : Loss : 1.4145, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 11 : Loss : 1.3964, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 12 : Loss : 1.3772, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 13 : Loss : 1.3567, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 14 : Loss : 1.3348, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 15 : Loss : 1.3121, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 16 : Loss : 1.2887, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 17 : Loss : 1.2647, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 18 : Loss : 1.2405, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 19 : Loss : 1.2163, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 20 : Loss : 1.1924, Acc : 0.7000, Test Acc : 0.8600\n", + "Epoch 21 : Loss : 1.1691, Acc : 0.7000, Test Acc : 0.8600\n", + "Epoch 22 : Loss : 1.1466, Acc : 0.7000, Test Acc : 0.8600\n", + "Epoch 23 : Loss : 1.1253, Acc : 0.7000, Test Acc : 0.8600\n", + "Epoch 24 : Loss : 1.1053, Acc : 0.7000, Test Acc : 0.8600\n", + "Epoch 25 : Loss : 1.0868, Acc : 0.7000, Test Acc : 0.8600\n", + "Epoch 26 : Loss : 1.0698, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 27 : Loss : 1.0543, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 28 : Loss : 1.0402, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 29 : Loss : 1.0273, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 30 : Loss : 1.0154, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 31 : Loss : 1.0045, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 32 : Loss : 0.9943, Acc : 0.7000, Test Acc : 0.8800\n", + "Epoch 33 : Loss : 0.9845, Acc : 0.8000, Test Acc : 0.8800\n", + "Epoch 34 : Loss : 0.9751, Acc : 0.8000, Test Acc : 0.8800\n", + "Epoch 35 : Loss : 0.9660, Acc : 0.8000, Test Acc : 0.8800\n", + "Epoch 36 : Loss : 0.9570, Acc : 0.8000, Test Acc : 0.8800\n", + "Epoch 37 : Loss : 0.9477, Acc : 0.8000, Test Acc : 0.8800\n", + "Epoch 38 : Loss : 0.9383, Acc : 0.8000, Test Acc : 0.9000\n", + "Epoch 39 : Loss : 0.9286, Acc : 0.8000, Test Acc : 0.9200\n", + "Epoch 40 : Loss : 0.9187, Acc : 0.8000, Test Acc : 0.9200\n", + "Epoch 41 : Loss : 0.9087, Acc : 0.8000, Test Acc : 0.9200\n", + "Epoch 42 : Loss : 0.8986, Acc : 0.8000, Test Acc : 0.9000\n", + "Epoch 43 : Loss : 0.8883, Acc : 0.8000, Test Acc : 0.9200\n", + "Epoch 44 : Loss : 0.8776, Acc : 0.8000, Test Acc : 0.9000\n", + "Epoch 45 : Loss : 0.8667, Acc : 0.8000, Test Acc : 0.9000\n", + "Epoch 46 : Loss : 0.8560, Acc : 0.8000, Test Acc : 0.9000\n", + "Epoch 47 : Loss : 0.8452, Acc : 0.8000, Test Acc : 0.9000\n", + "Epoch 48 : Loss : 0.8344, Acc : 0.8000, Test Acc : 0.9000\n", + "Epoch 49 : Loss : 0.8235, Acc : 0.8000, Test Acc : 0.8800\n", + "Epoch 50 : Loss : 0.8123, Acc : 0.8000, Test Acc : 0.8800\n", + "Epoch 51 : Loss : 0.8011, Acc : 0.8000, Test Acc : 0.8400\n", + "Epoch 52 : Loss : 0.7900, Acc : 0.8000, Test Acc : 0.8400\n", + "Epoch 53 : Loss : 0.7789, Acc : 0.8000, Test Acc : 0.8400\n", + "Epoch 54 : Loss : 0.7677, Acc : 0.8000, Test Acc : 0.8400\n", + "Epoch 55 : Loss : 0.7566, Acc : 0.8000, Test Acc : 0.8400\n", + "Epoch 56 : Loss : 0.7455, Acc : 0.8000, Test Acc : 0.8400\n", + "Epoch 57 : Loss : 0.7345, Acc : 0.8000, Test Acc : 0.8200\n", + "Epoch 58 : Loss : 0.7237, Acc : 0.8000, Test Acc : 0.8200\n", + "Epoch 59 : Loss : 0.7133, Acc : 0.8000, Test Acc : 0.8200\n", + "Epoch 60 : Loss : 0.7028, Acc : 0.8000, Test Acc : 0.8200\n", + "Epoch 61 : Loss : 0.6923, Acc : 0.8000, Test Acc : 0.8200\n", + "Epoch 62 : Loss : 0.6819, Acc : 0.8000, Test Acc : 0.8200\n", + "Epoch 63 : Loss : 0.6715, Acc : 0.8000, Test Acc : 0.8000\n", + "Epoch 64 : Loss : 0.6611, Acc : 0.8000, Test Acc : 0.8000\n", + "Epoch 65 : Loss : 0.6509, Acc : 0.8000, Test Acc : 0.8000\n", + "Epoch 66 : Loss : 0.6408, Acc : 0.8000, Test Acc : 0.8000\n", + "Epoch 67 : Loss : 0.6307, Acc : 0.8000, Test Acc : 0.8000\n", + "Epoch 68 : Loss : 0.6207, Acc : 0.8000, Test Acc : 0.8000\n", + "Epoch 69 : Loss : 0.6108, Acc : 0.8000, Test Acc : 0.8000\n", + "Epoch 70 : Loss : 0.6011, Acc : 0.8000, Test Acc : 0.8000\n", + "Epoch 71 : Loss : 0.5914, Acc : 0.8000, Test Acc : 0.8000\n", + "Epoch 72 : Loss : 0.5816, Acc : 0.8000, Test Acc : 0.8000\n", + "Epoch 73 : Loss : 0.5716, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 74 : Loss : 0.5616, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 75 : Loss : 0.5515, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 76 : Loss : 0.5415, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 77 : Loss : 0.5313, Acc : 0.9000, Test Acc : 0.7800\n", + "Epoch 78 : Loss : 0.5210, Acc : 0.9000, Test Acc : 0.7800\n", + "Epoch 79 : Loss : 0.5108, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 80 : Loss : 0.5006, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 81 : Loss : 0.4904, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 82 : Loss : 0.4802, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 83 : Loss : 0.4701, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 84 : Loss : 0.4600, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 85 : Loss : 0.4501, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 86 : Loss : 0.4402, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 87 : Loss : 0.4305, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 88 : Loss : 0.4210, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 89 : Loss : 0.4115, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 90 : Loss : 0.4020, Acc : 0.9000, Test Acc : 0.7800\n", + "Epoch 91 : Loss : 0.3926, Acc : 0.9000, Test Acc : 0.7800\n", + "Epoch 92 : Loss : 0.3833, Acc : 0.9000, Test Acc : 0.7800\n", + "Epoch 93 : Loss : 0.3741, Acc : 0.9000, Test Acc : 0.7800\n", + "Epoch 94 : Loss : 0.3650, Acc : 0.9000, Test Acc : 0.7800\n", + "Epoch 95 : Loss : 0.3560, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 96 : Loss : 0.3471, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 97 : Loss : 0.3381, Acc : 0.9000, Test Acc : 0.8000\n", + "Epoch 98 : Loss : 0.3292, Acc : 0.9000, Test Acc : 0.7800\n", + "Epoch 99 : Loss : 0.3204, Acc : 0.9000, Test Acc : 0.7800\n", + "Epoch 100 : Loss : 0.3116, Acc : 0.9000, Test Acc : 0.7600\n", + "Epoch 101 : Loss : 0.3028, Acc : 0.9000, Test Acc : 0.7600\n", + "Epoch 102 : Loss : 0.2940, Acc : 0.9000, Test Acc : 0.7600\n", + "Epoch 103 : Loss : 0.2853, Acc : 0.9000, Test Acc : 0.7600\n", + "Epoch 104 : Loss : 0.2766, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 105 : Loss : 0.2681, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 106 : Loss : 0.2597, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 107 : Loss : 0.2513, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 108 : Loss : 0.2429, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 109 : Loss : 0.2348, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 110 : Loss : 0.2279, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 111 : Loss : 0.2209, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 112 : Loss : 0.2134, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 113 : Loss : 0.2061, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 114 : Loss : 0.1991, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 115 : Loss : 0.1921, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 116 : Loss : 0.1852, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 117 : Loss : 0.1783, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 118 : Loss : 0.1716, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 119 : Loss : 0.1650, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 120 : Loss : 0.1587, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 121 : Loss : 0.1527, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 122 : Loss : 0.1468, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 123 : Loss : 0.1412, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 124 : Loss : 0.1360, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 125 : Loss : 0.1309, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 126 : Loss : 0.1258, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 127 : Loss : 0.1212, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 128 : Loss : 0.1171, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 129 : Loss : 0.1130, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 130 : Loss : 0.1089, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 131 : Loss : 0.1050, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 132 : Loss : 0.1012, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 133 : Loss : 0.0976, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 134 : Loss : 0.0942, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 135 : Loss : 0.0910, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 136 : Loss : 0.0878, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 137 : Loss : 0.0850, Acc : 1.0000, Test Acc : 0.7400\n", + "Epoch 138 : Loss : 0.0823, Acc : 1.0000, Test Acc : 0.7400\n", + "Epoch 139 : Loss : 0.0796, Acc : 1.0000, Test Acc : 0.7400\n", + "Epoch 140 : Loss : 0.0768, Acc : 1.0000, Test Acc : 0.7400\n", + "Epoch 141 : Loss : 0.0743, Acc : 1.0000, Test Acc : 0.7400\n", + "Epoch 142 : Loss : 0.0719, Acc : 1.0000, Test Acc : 0.7400\n", + "Epoch 143 : Loss : 0.0696, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 144 : Loss : 0.0675, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 145 : Loss : 0.0655, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 146 : Loss : 0.0635, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 147 : Loss : 0.0615, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 148 : Loss : 0.0597, Acc : 1.0000, Test Acc : 0.7600\n", + "Epoch 149 : Loss : 0.0580, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 150 : Loss : 0.0563, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 151 : Loss : 0.0547, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 152 : Loss : 0.0532, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 153 : Loss : 0.0518, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 154 : Loss : 0.0504, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 155 : Loss : 0.0491, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 156 : Loss : 0.0478, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 157 : Loss : 0.0465, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 158 : Loss : 0.0454, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 159 : Loss : 0.0443, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 160 : Loss : 0.0433, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 161 : Loss : 0.0423, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 162 : Loss : 0.0412, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 163 : Loss : 0.0402, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 164 : Loss : 0.0394, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 165 : Loss : 0.0385, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 166 : Loss : 0.0377, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 167 : Loss : 0.0368, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 168 : Loss : 0.0360, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 169 : Loss : 0.0353, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 170 : Loss : 0.0345, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 171 : Loss : 0.0338, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 172 : Loss : 0.0332, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 173 : Loss : 0.0325, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 174 : Loss : 0.0318, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 175 : Loss : 0.0312, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 176 : Loss : 0.0306, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 177 : Loss : 0.0301, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 178 : Loss : 0.0295, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 179 : Loss : 0.0290, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 180 : Loss : 0.0285, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 181 : Loss : 0.0280, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 182 : Loss : 0.0275, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 183 : Loss : 0.0270, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 184 : Loss : 0.0265, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 185 : Loss : 0.0261, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 186 : Loss : 0.0256, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 187 : Loss : 0.0252, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 188 : Loss : 0.0248, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 189 : Loss : 0.0244, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 190 : Loss : 0.0240, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 191 : Loss : 0.0236, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 192 : Loss : 0.0232, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 193 : Loss : 0.0229, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 194 : Loss : 0.0225, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 195 : Loss : 0.0222, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 196 : Loss : 0.0218, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 197 : Loss : 0.0215, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 198 : Loss : 0.0212, Acc : 1.0000, Test Acc : 0.7800\n", + "Epoch 199 : Loss : 0.0209, Acc : 1.0000, Test Acc : 0.7800\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "import math\n", + "\n", + "# Données et modèle du problème des 2 clusters\n", + "x_train_lab, y_train_lab, x_train_unlab, y_train_unlab, x_test, y_test = generate_2moons_dataset(num_lab=10, num_unlab=90, num_test=50)\n", + "model = create_model_2moons()\n", + "\n", + "# Hyperparamètres de l'apprentissage\n", + "lambdaa = 0.25\n", + "epochs = 200\n", + "batch_size = 16\n", + "if batch_size < x_train_lab.shape[0]:\n", + " steps_per_epoch = math.floor(x_train_lab.shape[0]/batch_size)\n", + "else:\n", + " steps_per_epoch = 1\n", + " batch_size = x_train_lab.shape[0]\n", + "\n", + "# Instanciation d'un optimiseur et d'une fonction de coût.\n", + "optimizer = keras.optimizers.Adam(learning_rate=1e-2)\n", + "loss_fn = keras.losses.BinaryCrossentropy()\n", + "\n", + "# Préparation des métriques pour le suivi de la performance du modèle.\n", + "train_acc_metric = keras.metrics.BinaryAccuracy()\n", + "test_acc_metric = keras.metrics.BinaryAccuracy()\n", + "\n", + "# Indices de l'ensemble labellisé\n", + "indices = np.arange(x_train_lab.shape[0])\n", + "indices_unlab = np.arange(x_train_unlab.shape[0])\n", + "\n", + "# Boucle sur les epochs\n", + "for epoch in range(epochs):\n", + "\n", + " # A chaque nouvelle epoch, on randomise les indices de l'ensemble labellisé\n", + " np.random.shuffle(indices)\n", + " np.random.shuffle(indices_unlab)\n", + "\n", + " # Et on recommence à cumuler la loss\n", + " cum_loss_value = 0\n", + "\n", + " for step in range(steps_per_epoch):\n", + "\n", + " # Sélection des données du prochain batch\n", + " x_batch = x_train_lab[indices[step*batch_size: (step+1)*batch_size]]\n", + " x_batch_unlab = x_train_unlab[indices_unlab[step*batch_size: (step+1)*batch_size]]\n", + " y_batch = y_train_lab[indices[step*batch_size: (step+1)*batch_size]]\n", + "\n", + " # Etape nécessaire pour comparer y_batch à la sortie du réseau\n", + " y_batch = np.expand_dims(y_batch, 1)\n", + "\n", + " # Les opérations effectuées par le modèle dans ce bloc sont suivies et permettront\n", + " # la différentiation automatique.\n", + " with tf.GradientTape() as tape:\n", + "\n", + " # Application du réseau aux données d'entrée\n", + " y_pred = model(x_batch, training=True) # Logits for this minibatch\n", + " y_pred_unlab = model(x_batch_unlab, training=True)\n", + "\n", + " # Calcul de la fonction de perte sur ce batch\n", + " loss_value = loss_fn(y_batch, y_pred) + lambdaa * binary_entropy_loss(y_pred)\n", + "\n", + " # Calcul des gradients par différentiation automatique\n", + " grads = tape.gradient(loss_value, model.trainable_weights)\n", + "\n", + " # Réalisation d'une itération de la descente de gradient (mise à jour des paramètres du réseau)\n", + " optimizer.apply_gradients(zip(grads, model.trainable_weights))\n", + "\n", + " # Mise à jour de la métrique\n", + " train_acc_metric.update_state(y_batch, y_pred)\n", + "\n", + " cum_loss_value = cum_loss_value + loss_value\n", + "\n", + " # Calcul de la précision à la fin de l'epoch\n", + " train_acc = train_acc_metric.result()\n", + "\n", + " # Calcul de la précision sur l'ensemble de test à la fin de l'epoch\n", + " test_logits = model(x_test, training=False)\n", + " test_acc_metric.update_state(np.expand_dims(y_test, 1), test_logits)\n", + " test_acc = test_acc_metric.result()\n", + "\n", + " print(\"Epoch %4d : Loss : %.4f, Acc : %.4f, Test Acc : %.4f\" % (epoch, float(cum_loss_value/steps_per_epoch), float(train_acc), float(test_acc)))\n", + "\n", + " # Remise à zéro des métriques pour la prochaine epoch\n", + " train_acc_metric.reset_states()\n", + " test_acc_metric.reset_states()" + ] + }, + { + "cell_type": "code", + "execution_count": 189, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD4CAYAAADvsV2wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAuoElEQVR4nO3dd3xUVfr48c+THkhCCx2kCEoHUREsCLhLM8KyKgKi2EARdHf1Z2Gx7ndXVnfFVUA6AqsiuoogoIhKtwDSOwgICTWQhDRCkjm/P5KJkzBJJpnJlNzn/XrxInPn5p4TynPPnPPc54gxBqWUUpVfkK87oJRSyjs04CullEVowFdKKYvQgK+UUhahAV8ppSwixNcdKMmqfWc0hUgppcqgZ6s6Utx7fh3wD51J83UXlFIqoPRsVafY93RKRymlLEIDvlJKWYTbAV9EGovIKhHZIyK7ReRPTs4REXlHRA6JyA4R6exuu0oppcrGE3P4OcDTxpgtIhIN/CwiK40xexzO6Qe0zP91AzA1//cyEwzVQm1EBINIsWsTPmOM4WIupGQHYfC//imlrMvtgG+MOQmczP86VUT2Ag0Bx4A/EJhv8gr3/Cgi1UWkfv73lkm1UBvVq0ZgkxDww4CPMUSYHEi/SHJ2sK97o5RSBTw6hy8iTYFrgJ+KvNUQOO7wOj7/WJlFBOO/wR5ABJuEEKGxXinlZzwW8EUkCvgU+LMx5oIb1xklIptFZPPaJQucve+/wd5OxC+nm5RS1uaRPHwRCSUv2H9gjPnMySkJQGOH143yj13GGDMDmAEwc+1hffBKKaU8xBNZOgLMBvYaYyYWc9oS4P78bJ2uQEp55u/9xeb13/HwHTfzYP9uLJw1ydfdUUopl3hihH8TcB+wU0S25R/7K3AFgDFmGrAc6A8cAjKABz3Qrk/k5uYy5R9/5bUZC4mtV58nh/Sja8/eNLnyal93TSmlSuSJLJ31UHL+YX52zhh32yqrP90/iJQLly8nVIuJ4e35i8p1zf07t1L/iqbUb9wEgFv7DeSHVSs04Cul/J5f19JxV8qFC7QcNfmy4wdnjC33Nc+dOUXter8lGMXWrc/+HVvLfT2llPIWLa2glFIWoQG/jGrVqcfZU78lGCWePkmtuvV82COllHKNBvwyurpdJ078eoRT8cfIzr7Emi8X07VHH193SymlSlWp5/ArQnBICI//9TXGPzYUW24uvQcNoWkLXbBVSvm/Sh3wq8XEOF2grRYT49Z1u3S/jS7db3PrGkop5W2VOuCXN/VSKaUqI53DV0opi9CAr5RSFqEBXymlLEIDvlJKWYQGfKWUsggN+OUw8cW/cM+t7Xh0UA9fd0UppVymAb8cfj9wMH+f+qGvu6GUUmViiYCfknSOfzw5nAvJ5z1yvfbXdSO6Wg2PXEsppbzFEgH/u88/wHZiO98uet/XXVFKKZ+p9AE/JekcW1f+j//8sRFbV/7PY6N8pZQKNJU+4H/3+Qfc0QJa1o3kjhboKF8pZVmVOuDbR/fDrq0GwLBrq+koXyllWZU64NtH97WiQoG83z0xyp/w7Gj+MjyO+KO/MPy2znz1mWbsKKX8X6Wulrlz4zrWnbzIgh3xhY5XP7uOQQ8+We7rjntjqrtdU0opr/NIwBeROUAccMYY087J+z2AxcCR/EOfGWP+5om2S/LS1E8qugmllAoYnhrhzwUmA/NLOGedMSbOQ+0ppZQqI4/M4Rtj1gJeWQk1xoAx3miq/IzJ66dSSvkRby7adhOR7SLypYi0Le4kERklIptFZPPaJQsue/9iLgSZHP8N+sYQZHK4mOvrjiilVGHeWrTdAjQxxqSJSH/gc6ClsxONMTOAGQAz1x6+LKqnZAdB+kUigkFEKrDL5WOM4WJufj+VUsqPeCXgG2MuOHy9XETeFZFYY0xima+FkJwdDNme7aNSSlV2XhmGikg9yR+Oi0iX/HbPeaNtpZRSeTyVlrkA6AHEikg88DIQCmCMmQbcBYwWkRwgExhidFVTKaW8yiMB3xgztJT3J5OXtqmUUspHdGVRKaUsQgO+UkpZhAZ8pZSyCA34SillERrwlVLKIjTgK6WURWjAV0opi9CAr5RSFqEBXymlLEIDvlJKWYQGfKWUsggN+EopZREa8JVSyiK8teOVUj41YexQ0tJSLzseFRXNuMmXb6WpVGWkAV95nS+Cb1paKs0fmXTZ8cOznqiQ9pTyRxrwldelpaVSpc9fyM0tvNP78Y9eYMLYoR4L+o43lqTEMyQcPQhAcHAw9Ro390gbSgUSDfjKJZ4elefm5hIee0WhY6FRNZ22UV6Oo/odk0cXtJeVeMxjbSgVSDTgK5folIhSgU+zdJRSyiJ0hK98JudSFo472efkZJOUeN6j8/h2wRFVODH3zwBkp50nK7YOkDclpZRVeCTgi8gcIA44Y4xp5+R9Ad4G+gMZwAPGmC2eaFtVjKJz9vZFT08seEZFRXP8oxeQiGgk+Ld/gsGRMUhIqEfn8e3aPvJmwdeHZz3BP+Yu9XgbSvk7T43w5wKTgfnFvN8PaJn/6wZgav7vyk8VnbO3L3p6YsFz3OQFTBg7lONHfyEkquZvb2RnEhxRBbgEuL9QHBUVfdkaQ8q5RIwth/EPxJXrmkoFMo8EfGPMWhFpWsIpA4H5xhgD/Cgi1UWkvjHmpCfaVxXPPiXiOB0C5Z8SGTd5AeMfiCtxIdiVheKy3hRKa1Opysxbc/gNgeMOr+Pzj10W8EVkFDAKYPjTf6f7gKFe6aAqmX1KxN+mQzR7SCnX+d2irTFmBjADYObaw6aU05VSSrnIWwE/AWjs8LpR/jFlYc7m2O3HlVKe562AvwQYKyIfkbdYm6Lz9/7NnWDs6ry6LpIq5V2eSstcAPQAYkUkHngZCAUwxkwDlpOXknmIvLTMBz3Rrqo49mBcNHinpaUy/oG4ErNaPDWvXhGfAIq7Zur5s5dl7tjP1xuTqiw8laVT4spqfnbOGE+0pbzLl4ui5U29tB8vyzU1e0dZgd8t2ipVFjr6Vsp1GvArId3sI4/+OShVmAb8Skhz0/N4+s9BbyAq0GnAtxhvBC3HefWUc4nYjA0AMbaChVF/CpITxg4ttEGKXXBwcKHXeiNVgU4DvsWUNWiVJ1PGMZAHwmJoWloqEbGNOLd0YsGxSxfOYoCQ4NCCm1RS4hl2z3q64Knj3bOeJvdiBtlp5wtl+PjTzUwpRxrwVYmsErgcq2lCXrG4WnFP0bBpy4JjCUcPFrop5F7MoMED/yEr8Vih8/zpZqaUI90ARSmlLEJH+JVQSdMwFVFr3l9p6QalCtOAXwmVNA3j7GnSsgikTBWP75oVHEx22vmCm0h22nmyEo9dtrjriicH3ECO7fLagCFBwjtLfnK7r0o5owHfYtwd9Xpj0dfbnPUxO+38ZYG8XuPmZMTWKSgPPf6BuEJz92WRYzM0GXv5fkG/Tr6/XNdTyhUa8C3G26Nwfxv1O+OsjxPGDiVtxVscLnLc8UYVCDczpRxpwFfKCVduVMXeKPILzDnyxykvZT0a8JXyIH04S/kzTctUSimL0BG+KhOdt/aMkCBxukAbEiQ+6I2yCg34AcQfUiLL2056agpnE34l9dQR0k4dhaxUwslGgEzCqNepF806dEXEGgFPUy+VL2jADyCBND+cfSmL/T99Q8rBTVQLyqReTCjXNahGy+bVaXpjY6KqhBecm5tr4/PvN/DF9EVUb9Od1jf1I6gcue2BwJWbtj/c2FXlpAFfedS5Uwns/24BMVmnGXpTM27ocV2po/bg4CDuvKU1d97SmjXbj/DBnOcJbtiB9rcNJjQ8vMTv9TelTXm5ctMOpBu7v0hNPs9H/3qGoc/+m6hqNXzdHb+lAV+5zWazcXDzahK3f0u7OsG8Nag91aNbl+tat3Zsxq0dm7H7yEmmf/gCGVFNaNf3PqpGV/Nwr4vnzghbR+C+senLhYSc3snG5R/Ra+hoX3fHb2nAV+WWlpLEnm8/JvjcIQZd34jej3Xz2Bx83RrRJPyyj1dHXsUHSyZwylaDVn3uo2adBh65fkl0hB1YUpPPs3/tIqYMasiYpYvo0n+IjvKL4ZGALyJ9gbeBYGCWMeafRd5/APgXkJB/aLIxZpYn2lbeZYzh2L5tHP9hMU2qXOLl3m1oVKeHx9uZv+x7kk4d5+sfdzFhRG9S0jJ5d/lU1iUFcWXPYTRofrXH2/Q1+yeLopuxBAcHU69xcx/2zL9t+nIhd7SEFnUiuaNluo7yS+B2wBeRYGAK8HsgHtgkIkuMMXuKnLrQGDPW3faszJcpkZeyLrJ71SKyjm3jtlY1eenBawgLrZgPiInJaSxds4mpf4xl9NJNjIi7iVrVqjJucFeyLmUzd+XHrF+ZQYOuAypVZo/9k8WOyaMJj72i4HhW4jEf9sq/2Uf3L9+TN+U3tHM1hi3UUX5xPPE/tgtwyBhzGEBEPgIGAkUDvnKTL+aHT8cf4ZdVC6lpO8/jPa+iXVz3Cm9z/rLviWsRxNV1wolrcZF5Szfw1L29AQgPC+XR2zsz0mZj0YYNLJ2Rl9nT6sbAyOxxpXR1cEQVTsz9c8F72WnnyYqto886OGEf3deqGgrk/X5HS3SUXwxPBPyGwHGH1/HADU7Ou1NEugMHgL8YY447OQcRGQWMAhj+9N/pPmCoB7qoysKWm8v+n77h/K7VXNswgncGtyO6aoRX2raP7j8enBfc7u9clcEf/zbKtwsK+i2zZ+2Oo7wfIJk9jjdtx8Vhx6mcWn3GFJrCOTzriYIKnaqwg1s3sPXMRRbuiC90POrUBg34Tnhr0fYLYIExJktEHgXmAb2cnWiMmQHMAJi59vDlBcNVsdzN386+lMXObz7GFr+DITdeQY/RN3l9usQ+uo+NyvunGRsVQlyLoEKj/KK6d2hK9w5N2X3kJDM+fJH0qCvcyuypiKkzZ383SYlnaHjvhILgbp/K0Skc1z36xvu+7kJA8UTATwAaO7xuxG+LswAYY845vJwFvOGBdlUR5c0uycrMYMeKDwk7t48xv29FuwE9KqiHpVu95QAnzmTx4c4zhY43OH3gsoCfmJzGo/98nxnj7qNWtaq0bVaft0fW58TZFCYtmcBJWw1alyOzpyKmzpz93eyYPJrc3FyPtxXoNKe+4ngi4G8CWopIM/IC/RBgmOMJIlLfGHMy/+UAYK8H2lVuykhLZceX84hO+5Xn+rXlykY9fd0llrzp+rq+PZOn6Oi/Qe1qTBhxC8mpGUxd/i7rkoO5sudQGjRvVRFd9tiTsfa5e/ucveN1rERz6iuO2wHfGJMjImOBFeSlZc4xxuwWkb8Bm40xS4AnRWQAkAOcBx5wt11VfheSEtn95Xxic0/z6u3taVSnma+7VGbFZfI4qh5dhXH3dMvP7PmE9d9k0uCGOzye2eOpvP22j7xZ8H1WnbPXnPqK5ZE5fGPMcmB5kWMvOXw9DhjnibZU+Z07lcC+r+dzRVgqr9/Rgdo1AjeXvaRMnqIcM3s+W7+BZQGW2WMlmlNfsfRJWwvIuZTFutkv06amjUn3dPJaxk1FcTWTp6igoCDu6t6au7r7R82e4IgqnProhULTN2C9KRw7zamveBrwK5Gi2SXZFzPJyUihVnQ4Mx64hojwUB/2znPmL/uefs0hOTmJ6pG1XMrkKcpZzZ72fe+nSnRMhfTZWeZPJFC76ZVafyefOzn19oXeOx4dzxfT/6ELvsXQgF+JjJu8AGMMv2xZx8lNS+ndugZDbm1LSEjlmrZYveUA+46k8s6ai0RGZhKT/4nFWSZPado2q887I+uTcDaZyUsmcMpWjdZ9RlCjTn2P9lmDeukObt3AppPpTPkugRo1qhOcP93mSk69faH3i6mvEnJ2r04FFUOM8d9Ud83Dd50tN5e9G77kwt41DLymHgO6XV1pSg4UlZicxuBn32ZqXBVGL83gk3/9ucSpnLJITs1g6pc72JccTPOeQ2nQrPR1Dq1f7znfLZjKr9++R5PbHnQ5YKcmn+f9cUN4p38k9793gHeHteCv32Zx3z8XWnKUP7J782L/42vAD1D2IGOM4VJaMrbsi0RXiaBR7WpsnDrG192rUBM/+BoSfuap7tWYuDYFGl5b5pF9abIuZfPe1zv44ddMn9fsscoNxR64p8RVZczSdJcD9ncLpnLVyUWMaGuYveEUEdE1yQkO50D9QZYc5ZcU8HVKx8+4+p87NTWFmI59sCUl0LjjjVSr3xSA3TOf9lZXfaK8C7ZlFR4WymNx1zLKMbOn7a15mT1BQR5rxxVWKddcngwd+0LvC3dFcTHpOI91iWT4p+f4590t+eILXfAtyrv/clWp7P+5i/6y3wRsubls+/pjspJOc0WzK2nXd1hBsLeCkkovVAR7Zs+cx7szsMZRfp79HFuW/5fsrKwKac+q7IF7aOffMnT2r11EWkpSid9nv0lE5qRSLQLqRQVze8sQvtl9vmDBV/1GR/h+7NTxwwWP3p8/e5pn7u5O7sU0rqhTndia1Ymq08jHPfS+spRe8CQRoUfHpvTomFezZ9oHL5IR3YQOfe+rsMweKylvho69eNqsNYkY229lKnLMJWrGxmoRtSI04Pux3NzcvGJaJ/YhtlxaxY2kdov2lX7apiRlKb1QUdo2q8+kUfWJP5PElCWvcdJWgzZ97vd4Zk9lU1KNnPJWvdTiaWWjAd+P5WakcH71e4THNiYspha1W7T3dZeUg0Z1ajjU7JmSV7On1zCXMntK47iW47gDViDvflVSjZxhf31HC6Z5gQZ8P2TLySZx42IyTsVTp8dwgsOrkLp5SaFzYqPDnY70Y6P9txZ8ZeVYs2fOyo9Z/3UGDbsNpGn7G8qd2eO4ULt71tOcWzoRyNsMJSP/ydxAeiK3tBo5WjDNOzTg+5lgk8PeN4dQPSaKzJRMTpzIKywaFhFZ6LzKnnoZiMLDQhl9e2cetdn4bP16ls34LC+zp1tft2r22IuqQeAWVispA8d+M3hnYH1GzJ9K25v7Urdx8QX9tHxy+WmWjp84G3+ENdPGMXVMb1K//D+OL3yOhrEx9HziDXo+8QY3jXzV1130C4nJadz5/DTOpaSX6T1vKpTZU/0Im2c/x9Yv37dsZk9pGTj2m0GDsAwGXpnLkndfKfF6jp8GVNnoCN/HLmaks+Xz6VwVkcTsUTcQHvZbvRudtrlccTXwS3vPF0SEHp2a0aNTM3YdPsn0D17kYkwT2vWxVmZPSRk41/e7p1Ae/ZM3VuHzuRs5ffyI01G+lk92jwZ8HzHGsGvVInJ+2cDf7+pMw9qXL/TptE1hJdXAd6U+vi+1a56X2ZNwNplJi1/jlLFOZk9JGThAQR59eATUiQphaLsQlrz7CiMnzLvsWlo+2T1aWsEHEg7t4pev5/JIj2bc2qGpy9/XZfQUElMvnxaIjQ63xM2hpJIKZSm3UHRrRF/Iy+zZzt5iMnsmjB1Kwq9HsBlboeNibDRq1rLSlFSY/uxwLpw6SnpyIrFVgggOglwbnMkM4tn56wqN3u2lFz68pxq1qoZyLj2bYQtTLFszpzhaWsFPpCafZ/vn79Klro0Xx9xKcHDZllASU7NoO/LNy45bIS+/pJIKxpgylVvwh6mfyzJ7VmbSsOuAgsyecZMXMP6BuEpfUuHRN94vqIUz9pbYguOT1yVeNnp3p3yyyqMB3wtyc3LY9tX7RJ3bw1uDr6NmjP9MNQSK0koqFPees43P/WnqxzGz59P161huz+y5sZ/P+uRtrj50Vd6Hs9RvNOBXsMNb13Pi+894Kq4NHa+81dfdCVgllVQASiy34DiFU5atEb0pKCiIu7u34a5bDGt2HOXDWc+RlZqELfsSQaFhvu5ehXL1aVl9qtZ9GvArSNLZU+xYNJnbW0fz2pO9Km1tem8prqSCPZivmPyM05F6YnIavZ/4D1XJYMonq1i9cXuFV9p0h2PNnuWrfyRx9RyoUpOanfsTEhnl6+6pAOeRPHwR6Ssi+0XkkIg87+T9cBFZmP/+TyLS1BPt+qOcnGw2fT6LlJX/YfqDnRnas50G+wrkOB/vyJ6T/+YHXyOZ57m5SSgLVnxPv+bitUqb7goLC6Nt76E0b38dKT8u5NSqeWSlnPV1t1QAc3uELyLBwBTg90A8sElElhhj9jic9jCQZIxpISJDgNeBe9xt298c37uVI9/O59kB7Wjf/BaPX1/z8gsraT5+/rLvOX/yGAt2/8L7gyJ5aVUGITbDzI0XWLj7UqHrVHSlzbKyZ2OdPJtEwoSRBcdFDBe2LCMoJJSTRw9Qv+lVPuylCkSemNLpAhwyxhwGEJGPgIGAY8AfCLyS//X/gMkiIsafc0LLIPtSFps+fZdrq6XyypO9KmyDDCukXpZFcfPx9hvBq70ieXxRBi1qRhLXMoR0E86qhFCPbolYEezZWG2LHN8982kOv/8UF7OymbPyI9avyHS7Zo8/0FIJ3uOJyNQQOO7wOj7/mNNzjDE5QApQywNt+1zCoV38OON5xveswdgB13p9NySrsgf1+zvnBe77O1dl6ZpNnEtJZ/6y7+nXHGqFXmR4h1A+3J7F/R3DWHUonZ5X4LdTOK6KCA/l8bhrmfPYjVyTto7vpz/H3vXLsdlspX+zH9JSCd7jd9FJREaJyGYR2bx2if8+XJKTk81Pn0wmes8nzH2yFy0a1fZ1lyzFWZpmj8bQc/SbLF61kf5XQkwY3NshlE/3XuLAuWw61oX3Nl9g9ZYDPu69ZwQH52X2vDemOwNqHGHzzGfZ8uUHAVWzx14q4c1BDV3a4Uq5xxNTOglAY4fXjfKPOTsnXkRCgGrAOWcXM8bMAGaA/z5pe/LofvZ/MY3xf2xPmyZdfN0dS3KWpnkuJQNysxhwZTRhhJCaLYDQpVEIw5fkUjO6Ku2ujPXpJiquPi2999gZcnIL//M/mXiBLqOnXDa155jZs+vwSaa//wKZ1ZrRvs9wv6/Zo6USvMsTAX8T0FJEmpEX2IcAw4qcswQYAfwA3AV8F4jz97bcXDYvmU1z2zHmPdGTkJDyl7xV7ikatBOT0/jdYxOoSjbvbUpj+eFqBAXZ/3mH+DzQ27n6tHROriGyduEtLEOjaji9WThq17w+kx7N241r0uJ/cNrUpE3fEdSoXc/9znuYfXT/8j2/VdEctlALolUktwO+MSZHRMYCK4BgYI4xZreI/A3YbIxZAswG/isih4Dz5N0UAsrZ+CPs/nwSz8S1oVOLbr7ujipi6qerua1xNv+4LYbx32ZSvfX1vPhQnK+7VS6x0eFs/+gFQqMKB728PRHSXLpGozo1eP2B7iSnZvDu8imsTwmmec+hHtmNCzyz0KqlErzPIw9eGWOWA8uLHHvJ4euLwN2eaMvbbDYbW5fNp37GAd4bcythofqsmr9JTE7j05U/8MGAMCJCgnjomjDuXfIDj9/Z06+zcYqzceoYmg+fSNuRb1z2XlnrJlWPrsJf7+man9mzkPVfZ9LwxoE0a9/VrT56YocqLZXgfRq9SnDuVAI7Pn2LP/VuyQ2tb/J1d1Qx7KP7q2KrAHBVbAi3Nc7g3U9XBewo39PsmT2P2Wz8b91alk37jNrX9OGqLmV/CrysNemL+zSgpRK8TwO+E8YYtq9YQPXzO5jz2M1EhIeW/k3KZz5dtYWMCzms+TW14NiFi4YqJ7dowC8iKCiIwbe25e7uhhWbd7Fw+ldEt7qZtrfEubwNY1kXWnW/Wv+hAb+IpLOn2PbJWzzWswnd4zz/tKzyvCvq1uSEFM5BjwmHBnVq+qhHxXP1aemKfqpaROh7fQv6Xt+C9bt+Zd7s5wi94lra33YnISUUayvrQqvuUOVfdAOUfMYYdn33GeEJP/HK0K5UjbRmuQJlXdsOnWDmtwfIjm1Fhz7DCI+IvOyc4mrXH6g/yOno3fH8ks5TnqMboJTiQlIiPy+cyIM31uf3fbSEsbKmTi0aMKVFAw7Gn2XKgpdIi2pC+773F8rlL8tCq6Zd+h/Lj/D3rP0C88sa/m9YN6KrRlR0cyrA+cP2iN6ScDaZd5bt4ExQHdr1G0FMjdjSv8lBWT8NKM8oaYTvd6UVvCUtJYk1M16iV5Vf+M/InhrsVUFJ5XMp6cWeU1w55sqoYe3qPPOHzpzd/g2nl/yTDfMncO70CZe//+DWDSzccZFbpsQX/Fq44yIHt1b+Pzt/ZckpnQM/fk3mrhVMGt6VGjFVfN0d5WXFjdJL2+vW37ZH9Ib5y74n49xJ6kVcxQt/aMmUZe+yPjmUlr8bTt0rrizxezXt0v9YaoSfkZbKmtmv0sW2g8mP9dJgb1HORumOwXzpmk0cOHbmstF+4XLM/rtxiqcU/TPJzrExbnA3po3oQMyO91k780WOH9jp626qMrBMwD+0ZS17PniJtwZfzd3dW/u6O8pHigYxe0AvGsyfm/xJoZtCSeWYK6vibnCR4WE8+YfrmDPyepocW8K66c9zZOePPu6tckWlD/gXM9JZN/c12qV+z7THb6N2jWhfd0n5kLMgVjSY3351BDv3/cKkgbUK1di3l2NOTMvh0U9OVora+sVx5QYXGhLMw307MXf0TXRMWcv6ac9yYNN3+HMiiNVV6jn8ozt+5PSGhbw+9Hrqx1bzdXeUj9mDWNFNzNMvXipUW3/Z3jSGtQuhVtilgpuCYznm86mZVA+5xNbTNtol+df2iJ7ibL8B+59F0Z83KCiIe3q0ZfCthuUbt/PpjC+Jbt2dNjf1d/npXeUdlTIt81LWRTZ+/A7d62fzUJ+OAb39m/KciR98DQk/81T3327+E9emMH/7JUKC8v6p5eTauJCaxn8HRVAnOowaNWoy+OPUgm0RE5PTGPzs20yNq8LopRl+v11ieQ14ejInziRedrxBHdfKTK/dcZT/rjtCWLPraNfrTkJCtDyJt5SUllnpAv7xvVs4/t1/+duQa2lcVx/uUL9xJYgVd1Og4bU8dW/vQu87HlfObT2YwMxvD5JbpzXtew91+vSu8ixLBHz7RuLXVU/j8bhrdFSvyqWkm8KcFx9g8LNv8/Hg6IK5fMfRvyregeNnmPLVHtKjm9G+731UidK1tIpS6QN+wqFdHP5qNi/d1VH3llUVprTRvxW4+6Tx8dNJTFq+k8TgurTrP4Lo6rUqoJfWVmlr6eTkZLN50XTaRpxl7pO9CAqq9ElHyoec7aML0OB05Vy4daa0h9NK07huDd54sDtnk1J5Z9m/2Z4VQ5t+I6hZp0EF9FYVFbAj/MIbidf1ZreUsqSKWLBOScvk3WXb2JsSSqve91O7UTMP9da6KlUtHVtuLhsXzSB0y/vMe6KnBnvlMa7U0inLed7irf7YUzWb1wzl2hppvPvpKrevWS0qknH3dGPa/R2I3DqXdbNf5kz8EQ/0VjkTUAH/TPwR1k59hjHXBDFucFdCQjTHV3mOq4XRKqqAWnkDtzcKujk+iHUuJY07r4ZPv/7BYzeZKhFh/GVQF6Y/0IkqW+eybvYrnNXA73EBEfBtNhs/fzGXnA0zeW/MrXRqUd/XXVKVTHElF8p7XnmUJ3Dv//U0Ez9cyWv9alRoqQf76L5aRBApqel0ahDGbY2zPTLKdxQZbg/8HQn7+b28wJ9w1KNtWJlbAV9EaorIShE5mP+708R3EckVkW35v5aUpY3zp+JZM/VZHmyVxcv33kRYaECvMys/5WphtIoqoObKjcTZJ4Dnp/yPxlG5fH8k0+X+FPdJoqRPGKu3HODDnVm0nRjPHR+mc/OcNL7Yn8On320px09busjwMP7fnTcwbURHwjbPYd2cVzl74liFtGUl7o7wnwe+Nca0BL7Nf+1MpjGmU/6vAa5efNtXH5Ly7STmPHYzN7Ru5GZXlXLO1cJoFVlAzZUbSdFPAPt/Pc3Ofb8wc2BVlu6+QFyrCJf6U9wniZI+YSx5cyxfTfp/NIqN5ouHG9OkRhhLH2lMzSrBFbp2UCUiP/Df34GwTbM08LvJ3YA/EJiX//U84A9uXq+Qe5ok89qI7kSE62PZquKUVDemPOeVlbMbyWff/sQdT08pCKbOPgE8P+V/DGsXQrs6IcS1DGHpnrRi+2MfvR84dsbpJwlXPmHYf/5le9NISr9UYnue5hj4QzfOYv2cv5F48niFt1vZuBvw6xpjTuZ/fQooLmUmQkQ2i8iPIvKHki4oIqPyz92873B8Sacq5RH26Yrrppwp+PXhzixWbzlQrvPKytmNpHboRRJP/FoQTIt+ApjyySr2HDhKnxYh7DmbzQ2NhMkbkpi/LdNpf+yj9+cmf+L0k4QrnzBWbznA/G2ZTN6QxNM3hpXYXkWpEhHGM3fdwLv3tSP4p5msm/M3Ek9qnHBVqXn4IvINUM/JW+OBecaY6g7nJhljLpvHF5GGxpgEEWkOfAfcZoz5pdTefT/Jfx8SUMpDipZzsBdwmxpXldd/jmDaCyN57O8zC5V0uGX6KR66NopnelQv+L7invq158+/1iuc4R+eYP3YJtSLCS0oDeHs+sWVjChaSyi9Vnu2HYz32R6/6ZlZTFq6lT1JobTu9xCx9XXqt8JKK4jIfqCHMeakiNQHVhtjri7le+YCS40x/yu1AQ34KoA5liEwxrhckqBoUF2XGMMtsRcKlXTo9OZhMnJDiCmyF7Ozapb262HLIflCKo/fVJN6tWLy3ivm+s5uHvYbh+ON4XezThMdahjUt4dPnzZOy8hi0tIt7E0Oo03/h6lVr6HP+uJrFVlaYQkwAvhn/u+Li56Qn7mTYYzJEpFY4CbgDTfbVcrvFV0EdaUkgbOa/dMnH+VIfCQf7swqOC8kIopWLpQqdrzeQx+dID45l/e2naZ2jUyCgvLiQuKF4xw/GVFqyYiiU0/VIoK4rXE2YeGRLF3j2z1+o6qEM25wt/zAP411KWG06feQpQO/M+6O8GsBHwNXAL8Cg40x50XkOuAxY8wjInIjMB2wkbdm8B9jzGyXGtARvgpQjmUIHv48jeAgYcaAqqWWJPB0gTZPXq/o1NOF9IuQc4lWdcLocVU1vyoil5p+kclLt7L3QnjeiL+udWr1BGy1TA34KlA5BtpB7yXQvm4wf+tfr9Rg6+7GIxV9PTtn0zv+WCraHvj3pUbQpv9DlijSpgFfKS9yDIYAd753jNd/F851V9UnOdPml4GxrAKtVHRq+kXe+WIrB9IjadvvIWrUqbxP61fa8shK+SPHue6Jq88x8OpQmtYIJjE5jXq1YordGzaQBFqp6OiqEYwf0o0L6Zm8vWQy69Or0i7uYarHWqv4oo7wlfIwx2mUhMRUgrABEBwcRJ0aeaN+d6dUlHuSUzN4e8lWjl6KoV3cI8TUiPV1lzxGp3SUUsqJ8xfSmbh4Kwkmlo5xD1M1prqvu+Q2DfhKKVWCM0mpTFy8jbNhDeh4+4NEVg3cPXc14CullAsSzibz5uLtXIhqRqfbRxAeWcXXXSozDfhKKVUGR06c462lO8mKbU3HPvcSGh7u6y65TAO+UkqVw75fT/POl3swDTrSofcQQkL8v3KvBnyllHLD9l9OMmXFXsKadaV9rz8SFOy/26tWqk3MlVLK2zpeWZ8Zj/fi/qbn2DjzWXat/hybzebrbpWZBnyllHJRl9aNmT22F3fWPcGP059l7w8r8OtZkiI04CulVBl1b9+EOWN70CdyH+unPcMv2yp+1y9P0ICvlFLlICL0ua4F88b2oHP6BtZMfY74gzt93a0SacBXSik3iAiDb23L3NE30fDI56yd9SJnE476ultOacBXSikPCAkJZlT/zsx4sDPBG2ezfu5rXDh/eWlqX9JqmUop5UGR4WE8d3dXklMz+Pfnb7KbunQa8LBflGvQPHyllKpAJ86m8K/F20ivfhWd+t9HaFjFPrWrefhKKeUjDWpX461HbuWp64PYMW8821d+gi031yd90YCvlFJe0KpJXaaN7snwpuf5cYZvcvg14CullBd1bd2IOWN78rvwvayb9ixHd/3ktbbdCvgicreI7BYRm4hcV8J5fUVkv4gcEpHn3WlTKaUCnYjQv0tL5o3pTpvzq1g3/a+cOLyvwtt1d4S/C/gjsLa4E0QkGJgC9APaAENFpI2b7SqlVMALCgri3l7tmf1oV2rt+5h1s1/h3OkTFdaeW2mZxpi9kHe3KkEX4JAx5nD+uR8BA4E97rStlFKVRWhIMGMHXEt6Zhb/WfwuGzKj6XDHSKKr1/RoO96Yw28IHHd4HZ9/zCkRGSUim0Vk84zFgVGfQimlPKFqZDjjh3Tj34Oacnrp6/z4yWSyMjM8dv1SR/gi8g1Qz8lb440xiz3Wk3zGmBnADEDz8JVSlhRbPYrXH+jOsVPn+fdHL3Opdls69r3X7Q1YSg34xpjfudUCJACNHV43yj+mlFKqBFfUq8k7I3uw8/Ap3pn9PBEtb6Zdj4EEBZVvcsYbUzqbgJYi0kxEwoAhwBIvtKuUUpVC++b1mDmmF3fXP8n3057h4ObV5crhdzctc5CIxAPdgGUisiL/eAMRWQ5gjMkBxgIrgL3Ax8aY3e60q5RSVtS9fRPmPtGTG20/s3bqsxzfu7VM36+1dJRSKgDl5tqY981OVh3O5Oq+D1K3cXNAa+kopVSlExwcxEN9OjLr4WuJ3DqPde/9H8mJp0v8Hg34SikVwMLDQnn6j12YPKw16d++XeK5GvCVUqoSiKkaySv33lTiORrwlVLKIjTgK6WURWjAV0opi9CAr5RSFqEBXymlLEIDvlJKWYQGfKWUsggN+EopZREa8JVSyiI04CullEVowFdKKYvQgK+UUhahAV8ppSxCA75SSlmEBnyllLIIDfhKKWURGvCVUsoi3Ar4InK3iOwWEZuIXFfCeUdFZKeIbBORze60qZRSqnxC3Pz+XcAfgekunNvTGJPoZntKKaXKya2Ab4zZCyAinumNUkqpCuOtOXwDfC0iP4vIqJJOFJFRIrJZRDbPWLzBS91TSqnKr9QRvoh8A9Rz8tZ4Y8xiF9u52RiTICJ1gJUiss8Ys9bZicaYGcAMAL6fZFy8vlJKqVKUGvCNMb9ztxFjTEL+72dEZBHQBXAa8JVSSlWMCp/SEZGqIhJt/xroTd5ir1JKKS9yNy1zkIjEA92AZSKyIv94AxFZnn9aXWC9iGwHNgLLjDFfudOuUkqpshNj/HiafPtCP+6cUkr5oY73FJs26d8BP5+IjMpfzLUsq/8Z6M+vP7/+/O7//IFSWqHEVE6LsPqfgf781qY/vwcESsBXSinlJg34SillEYES8C07d+fA6n8G+vNbm/78HhAQi7ZKKaXcFygjfKWUUm7SgK+UUhYRMAFfRP4lIvtEZIeILBKR6r7ukze5utlMZSMifUVkv4gcEpHnfd0fbxOROSJyRkQsWY5ERBqLyCoR2ZP/7/9Pvu6TN4lIhIhsFJHt+T//q+5cL2ACPrASaGeM6QAcAMb5uD/eZt9sxjJF50QkGJgC9APaAENFpI1ve+V1c4G+vu6ED+UATxtj2gBdgTEW+zeQBfQyxnQEOgF9RaRreS8WMAHfGPO1MSYn/+WPQCNf9sfbjDF7jTH7fd0PL+sCHDLGHDbGXAI+Agb6uE9elV9G/Lyv++ErxpiTxpgt+V+nAnuBhr7tlfeYPGn5L0Pzf5U70yZgAn4RDwFf+roTqsI1BI47vI7HQv/ZVWEi0hS4BvjJx13xKhEJFpFtwBlgpTGm3D+/u3vaepQrm62IyHjyPuZ94M2+eYOHNptRqtIRkSjgU+DPxpgLvu6PNxljcoFO+euWi0SknTGmXGs6fhXwS9tsRUQeAOKA20wlfIDAE5vNVDIJQGOH143yjykLEZFQ8oL9B8aYz3zdH18xxiSLyCry1nTKFfADZkpHRPoCzwIDjDEZvu6P8opNQEsRaSYiYcAQYImP+6S8SEQEmA3sNcZM9HV/vE1EatszEkUkEvg9sK+81wuYgA9MBqLJ2xN3m4hM83WHvKm4zWYqs/xF+rHACvIW6z42xuz2ba+8S0QWAD8AV4tIvIg87Os+edlNwH1Ar/z/99tEpL+vO+VF9YFVIrKDvAHQSmPM0vJeTEsrKKWURQTSCF8ppZQbNOArpZRFaMBXSimL0ICvlFIWoQFfKaUsQgO+UkpZhAZ8pZSyiP8Pc7wNsowszeMAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from mlxtend.plotting import plot_decision_regions\n", + "\n", + "# Affichage des données\n", + "plt.plot(x_train_unlab[y_train_unlab==0,0], x_train_unlab[y_train_unlab==0,1], 'b.')\n", + "plt.plot(x_train_unlab[y_train_unlab==1,0], x_train_unlab[y_train_unlab==1,1], 'r.')\n", + "\n", + "plt.plot(x_test[y_test==0,0], x_test[y_test==0,1], 'b+')\n", + "plt.plot(x_test[y_test==1,0], x_test[y_test==1,1], 'r+')\n", + "\n", + "plt.plot(x_train_lab[y_train_lab==0,0], x_train_lab[y_train_lab==0,1], 'b.', markersize=30)\n", + "plt.plot(x_train_lab[y_train_lab==1,0], x_train_lab[y_train_lab==1,1], 'r.', markersize=30)\n", + "\n", + "plt.show()\n", + "\n", + "#Affichage de la frontière de décision\n", + "plot_decision_regions(x_train_unlab, y_train_unlab, clf=model, legend=2)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0 : Loss : 0.4852, Acc : 0.7000, Test Acc : 0.6111\n", + "Epoch 1 : Loss : 0.4787, Acc : 0.7000, Test Acc : 0.6444\n", + "Epoch 2 : Loss : 0.4723, Acc : 0.7000, Test Acc : 0.6444\n", + "Epoch 3 : Loss : 0.4660, Acc : 0.7000, Test Acc : 0.6444\n", + "Epoch 4 : Loss : 0.4598, Acc : 0.7000, Test Acc : 0.6556\n", + "Epoch 5 : Loss : 0.4537, Acc : 0.7000, Test Acc : 0.6667\n", + "Epoch 6 : Loss : 0.4478, Acc : 0.7000, Test Acc : 0.6667\n", + "Epoch 7 : Loss : 0.4420, Acc : 0.7000, Test Acc : 0.6667\n", + "Epoch 8 : Loss : 0.4363, Acc : 0.7000, Test Acc : 0.6667\n", + "Epoch 9 : Loss : 0.4307, Acc : 0.7000, Test Acc : 0.6667\n", + "Epoch 10 : Loss : 0.4252, Acc : 0.7000, Test Acc : 0.6667\n", + "Epoch 11 : Loss : 0.4199, Acc : 0.7000, Test Acc : 0.6778\n", + "Epoch 12 : Loss : 0.4147, Acc : 0.7000, Test Acc : 0.6889\n", + "Epoch 13 : Loss : 0.4095, Acc : 0.7000, Test Acc : 0.6889\n", + "Epoch 14 : Loss : 0.4045, Acc : 0.7000, Test Acc : 0.6889\n", + "Epoch 15 : Loss : 0.3996, Acc : 0.7000, Test Acc : 0.6889\n", + "Epoch 16 : Loss : 0.3948, Acc : 0.7000, Test Acc : 0.7111\n", + "Epoch 17 : Loss : 0.3900, Acc : 0.7000, Test Acc : 0.7222\n", + "Epoch 18 : Loss : 0.3854, Acc : 0.7000, Test Acc : 0.7222\n", + "Epoch 19 : Loss : 0.3808, Acc : 0.7000, Test Acc : 0.7333\n", + "Epoch 20 : Loss : 0.3764, Acc : 0.7000, Test Acc : 0.7333\n", + "Epoch 21 : Loss : 0.3720, Acc : 0.7000, Test Acc : 0.7333\n", + "Epoch 22 : Loss : 0.3677, Acc : 0.7000, Test Acc : 0.7444\n", + "Epoch 23 : Loss : 0.3635, Acc : 0.7000, Test Acc : 0.7444\n", + "Epoch 24 : Loss : 0.3593, Acc : 0.7000, Test Acc : 0.7444\n", + "Epoch 25 : Loss : 0.3552, Acc : 0.7000, Test Acc : 0.7444\n", + "Epoch 26 : Loss : 0.3512, Acc : 0.7000, Test Acc : 0.7556\n", + "Epoch 27 : Loss : 0.3473, Acc : 0.7000, Test Acc : 0.7556\n", + "Epoch 28 : Loss : 0.3434, Acc : 0.7000, Test Acc : 0.7556\n", + "Epoch 29 : Loss : 0.3396, Acc : 0.7000, Test Acc : 0.7667\n", + "Epoch 30 : Loss : 0.3358, Acc : 0.7000, Test Acc : 0.7667\n", + "Epoch 31 : Loss : 0.3321, Acc : 0.7000, Test Acc : 0.7667\n", + "Epoch 32 : Loss : 0.3285, Acc : 0.7000, Test Acc : 0.7667\n", + "Epoch 33 : Loss : 0.3249, Acc : 0.7000, Test Acc : 0.7667\n", + "Epoch 34 : Loss : 0.3214, Acc : 0.7000, Test Acc : 0.7667\n", + "Epoch 35 : Loss : 0.3179, Acc : 0.7000, Test Acc : 0.7778\n", + "Epoch 36 : Loss : 0.3144, Acc : 0.7000, Test Acc : 0.7778\n", + "Epoch 37 : Loss : 0.3110, Acc : 0.7000, Test Acc : 0.7778\n", + "Epoch 38 : Loss : 0.3077, Acc : 0.7000, Test Acc : 0.7778\n", + "Epoch 39 : Loss : 0.3044, Acc : 0.7000, Test Acc : 0.7778\n", + "Epoch 40 : Loss : 0.3012, Acc : 0.7000, Test Acc : 0.7778\n", + "Epoch 41 : Loss : 0.2980, Acc : 0.8000, Test Acc : 0.7778\n", + "Epoch 42 : Loss : 0.2948, Acc : 0.8000, Test Acc : 0.7778\n", + "Epoch 43 : Loss : 0.2917, Acc : 0.8000, Test Acc : 0.7889\n", + "Epoch 44 : Loss : 0.2886, Acc : 0.8000, Test Acc : 0.7889\n", + "Epoch 45 : Loss : 0.2856, Acc : 0.8000, Test Acc : 0.7889\n", + "Epoch 46 : Loss : 0.2826, Acc : 0.8000, Test Acc : 0.7889\n", + "Epoch 47 : Loss : 0.2796, Acc : 0.8000, Test Acc : 0.7889\n", + "Epoch 48 : Loss : 0.2767, Acc : 0.8000, Test Acc : 0.7889\n", + "Epoch 49 : Loss : 0.2738, Acc : 0.8000, Test Acc : 0.7889\n", + "Epoch 50 : Loss : 0.2710, Acc : 0.8000, Test Acc : 0.8000\n", + "Epoch 51 : Loss : 0.6722, Acc : 0.8000, Test Acc : 0.8111\n", + "Epoch 52 : Loss : 0.6680, Acc : 0.8000, Test Acc : 0.8111\n", + "Epoch 53 : Loss : 0.6631, Acc : 0.8000, Test Acc : 0.8111\n", + "Epoch 54 : Loss : 0.6577, Acc : 0.8000, Test Acc : 0.8111\n", + "Epoch 55 : Loss : 0.6520, Acc : 0.8000, Test Acc : 0.8222\n", + "Epoch 56 : Loss : 0.6462, Acc : 0.8000, Test Acc : 0.8222\n", + "Epoch 57 : Loss : 0.6403, Acc : 0.8000, Test Acc : 0.8222\n", + "Epoch 58 : Loss : 0.6344, Acc : 0.8000, Test Acc : 0.8222\n", + "Epoch 59 : Loss : 0.6285, Acc : 0.8000, Test Acc : 0.8222\n", + "Epoch 60 : Loss : 0.6227, Acc : 0.8000, Test Acc : 0.8222\n", + "Epoch 61 : Loss : 0.6171, Acc : 0.8000, Test Acc : 0.8222\n", + "Epoch 62 : Loss : 0.6116, Acc : 0.8000, Test Acc : 0.8222\n", + "Epoch 63 : Loss : 0.6062, Acc : 0.8000, Test Acc : 0.8222\n", + "Epoch 64 : Loss : 0.6011, Acc : 0.8000, Test Acc : 0.8222\n", + "Epoch 65 : Loss : 0.5961, Acc : 0.8000, Test Acc : 0.8222\n", + "Epoch 66 : Loss : 0.5913, Acc : 0.8000, Test Acc : 0.8222\n", + "Epoch 67 : Loss : 0.5866, Acc : 0.8000, Test Acc : 0.8333\n", + "Epoch 68 : Loss : 0.5822, Acc : 0.8000, Test Acc : 0.8333\n", + "Epoch 69 : Loss : 0.5779, Acc : 0.8000, Test Acc : 0.8333\n", + "Epoch 70 : Loss : 0.5738, Acc : 0.8000, Test Acc : 0.8333\n", + "Epoch 71 : Loss : 0.5698, Acc : 0.8000, Test Acc : 0.8333\n", + "Epoch 72 : Loss : 0.5660, Acc : 0.8000, Test Acc : 0.8333\n", + "Epoch 73 : Loss : 0.5624, Acc : 0.8000, Test Acc : 0.8333\n", + "Epoch 74 : Loss : 0.5589, Acc : 0.8000, Test Acc : 0.8333\n", + "Epoch 75 : Loss : 0.5555, Acc : 0.8000, Test Acc : 0.8333\n", + "Epoch 76 : Loss : 0.5523, Acc : 0.8000, Test Acc : 0.8333\n", + "Epoch 77 : Loss : 0.5491, Acc : 0.8000, Test Acc : 0.8333\n", + "Epoch 78 : Loss : 0.5461, Acc : 0.8000, Test Acc : 0.8333\n", + "Epoch 79 : Loss : 0.5432, Acc : 0.8000, Test Acc : 0.8444\n", + "Epoch 80 : Loss : 0.5404, Acc : 0.8000, Test Acc : 0.8444\n", + "Epoch 81 : Loss : 0.5377, Acc : 0.8000, Test Acc : 0.8444\n", + "Epoch 82 : Loss : 0.5350, Acc : 0.8000, Test Acc : 0.8556\n", + "Epoch 83 : Loss : 0.5324, Acc : 0.8000, Test Acc : 0.8556\n", + "Epoch 84 : Loss : 0.5299, Acc : 0.9000, Test Acc : 0.8444\n", + "Epoch 85 : Loss : 0.5275, Acc : 0.9000, Test Acc : 0.8444\n", + "Epoch 86 : Loss : 0.5252, Acc : 0.9000, Test Acc : 0.8444\n", + "Epoch 87 : Loss : 0.5228, Acc : 0.9000, Test Acc : 0.8444\n", + "Epoch 88 : Loss : 0.5206, Acc : 0.9000, Test Acc : 0.8556\n", + "Epoch 89 : Loss : 0.5184, Acc : 0.9000, Test Acc : 0.8556\n", + "Epoch 90 : Loss : 0.5162, Acc : 0.9000, Test Acc : 0.8667\n", + "Epoch 91 : Loss : 0.5141, Acc : 0.9000, Test Acc : 0.8667\n", + "Epoch 92 : Loss : 0.5120, Acc : 0.9000, Test Acc : 0.8667\n", + "Epoch 93 : Loss : 0.5100, Acc : 0.9000, Test Acc : 0.8667\n", + "Epoch 94 : Loss : 0.5080, Acc : 0.9000, Test Acc : 0.8667\n", + "Epoch 95 : Loss : 0.5060, Acc : 0.9000, Test Acc : 0.8667\n", + "Epoch 96 : Loss : 0.5041, Acc : 0.9000, Test Acc : 0.8667\n", + "Epoch 97 : Loss : 0.5022, Acc : 0.9000, Test Acc : 0.8667\n", + "Epoch 98 : Loss : 0.5003, Acc : 0.9000, Test Acc : 0.8667\n", + "Epoch 99 : Loss : 0.4984, Acc : 0.9000, Test Acc : 0.8667\n", + "Epoch 100 : Loss : 0.4965, Acc : 0.9000, Test Acc : 0.8667\n", + "Epoch 101 : Loss : 0.4947, Acc : 0.9000, Test Acc : 0.8778\n", + "Epoch 102 : Loss : 0.4929, Acc : 0.9000, Test Acc : 0.8778\n", + "Epoch 103 : Loss : 0.4911, Acc : 1.0000, Test Acc : 0.8778\n", + "Epoch 104 : Loss : 0.4893, Acc : 1.0000, Test Acc : 0.8778\n", + "Epoch 105 : Loss : 0.4875, Acc : 1.0000, Test Acc : 0.8778\n", + "Epoch 106 : Loss : 0.4858, Acc : 1.0000, Test Acc : 0.8778\n", + "Epoch 107 : Loss : 0.4840, Acc : 1.0000, Test Acc : 0.8778\n", + "Epoch 108 : Loss : 0.4822, Acc : 1.0000, Test Acc : 0.8778\n", + "Epoch 109 : Loss : 0.4805, Acc : 1.0000, Test Acc : 0.8778\n", + "Epoch 110 : Loss : 0.4788, Acc : 1.0000, Test Acc : 0.8778\n", + "Epoch 111 : Loss : 0.4770, Acc : 1.0000, Test Acc : 0.8889\n", + "Epoch 112 : Loss : 0.4753, Acc : 1.0000, Test Acc : 0.8889\n", + "Epoch 113 : Loss : 0.4736, Acc : 1.0000, Test Acc : 0.8889\n", + "Epoch 114 : Loss : 0.4719, Acc : 1.0000, Test Acc : 0.8889\n", + "Epoch 115 : Loss : 0.4702, Acc : 1.0000, Test Acc : 0.8889\n", + "Epoch 116 : Loss : 0.4685, Acc : 1.0000, Test Acc : 0.9000\n", + "Epoch 117 : Loss : 0.4668, Acc : 1.0000, Test Acc : 0.9000\n", + "Epoch 118 : Loss : 0.4650, Acc : 1.0000, Test Acc : 0.9000\n", + "Epoch 119 : Loss : 0.4633, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 120 : Loss : 0.4616, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 121 : Loss : 0.4599, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 122 : Loss : 0.4582, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 123 : Loss : 0.4565, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 124 : Loss : 0.4548, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 125 : Loss : 0.4531, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 126 : Loss : 0.4513, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 127 : Loss : 0.4496, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 128 : Loss : 0.4479, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 129 : Loss : 0.4461, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 130 : Loss : 0.4444, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 131 : Loss : 0.4427, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 132 : Loss : 0.4409, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 133 : Loss : 0.4392, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 134 : Loss : 0.4374, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 135 : Loss : 0.4356, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 136 : Loss : 0.4339, Acc : 1.0000, Test Acc : 0.9111\n", + "Epoch 137 : Loss : 0.4321, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 138 : Loss : 0.4303, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 139 : Loss : 0.4285, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 140 : Loss : 0.4267, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 141 : Loss : 0.4249, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 142 : Loss : 0.4231, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 143 : Loss : 0.4213, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 144 : Loss : 0.4194, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 145 : Loss : 0.4176, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 146 : Loss : 0.4158, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 147 : Loss : 0.4139, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 148 : Loss : 0.4120, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 149 : Loss : 0.4102, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 150 : Loss : 0.4083, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 151 : Loss : 0.4064, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 152 : Loss : 0.4045, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 153 : Loss : 0.4027, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 154 : Loss : 0.4008, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 155 : Loss : 0.3988, Acc : 1.0000, Test Acc : 0.9222\n", + "Epoch 156 : Loss : 0.3969, Acc : 1.0000, Test Acc : 0.9333\n", + "Epoch 157 : Loss : 0.3950, Acc : 1.0000, Test Acc : 0.9333\n", + "Epoch 158 : Loss : 0.3931, Acc : 1.0000, Test Acc : 0.9444\n", + "Epoch 159 : Loss : 0.3912, Acc : 1.0000, Test Acc : 0.9556\n", + "Epoch 160 : Loss : 0.3892, Acc : 1.0000, Test Acc : 0.9556\n", + "Epoch 161 : Loss : 0.3873, Acc : 1.0000, Test Acc : 0.9556\n", + "Epoch 162 : Loss : 0.3853, Acc : 1.0000, Test Acc : 0.9556\n", + "Epoch 163 : Loss : 0.3834, Acc : 1.0000, Test Acc : 0.9556\n", + "Epoch 164 : Loss : 0.3814, Acc : 1.0000, Test Acc : 0.9556\n", + "Epoch 165 : Loss : 0.3794, Acc : 1.0000, Test Acc : 0.9556\n", + "Epoch 166 : Loss : 0.3775, Acc : 1.0000, Test Acc : 0.9556\n", + "Epoch 167 : Loss : 0.3755, Acc : 1.0000, Test Acc : 0.9556\n", + "Epoch 168 : Loss : 0.3735, Acc : 1.0000, Test Acc : 0.9556\n", + "Epoch 169 : Loss : 0.3715, Acc : 1.0000, Test Acc : 0.9556\n", + "Epoch 170 : Loss : 0.3695, Acc : 1.0000, Test Acc : 0.9556\n", + "Epoch 171 : Loss : 0.3675, Acc : 1.0000, Test Acc : 0.9556\n", + "Epoch 172 : Loss : 0.3656, Acc : 1.0000, Test Acc : 0.9667\n", + "Epoch 173 : Loss : 0.3636, Acc : 1.0000, Test Acc : 0.9667\n", + "Epoch 174 : Loss : 0.3616, Acc : 1.0000, Test Acc : 0.9667\n", + "Epoch 175 : Loss : 0.3596, Acc : 1.0000, Test Acc : 0.9667\n", + "Epoch 176 : Loss : 0.3576, Acc : 1.0000, Test Acc : 0.9667\n", + "Epoch 177 : Loss : 0.3556, Acc : 1.0000, Test Acc : 0.9667\n", + "Epoch 178 : Loss : 0.3536, Acc : 1.0000, Test Acc : 0.9667\n", + "Epoch 179 : Loss : 0.3516, Acc : 1.0000, Test Acc : 0.9667\n", + "Epoch 180 : Loss : 0.3496, Acc : 1.0000, Test Acc : 0.9667\n", + "Epoch 181 : Loss : 0.3476, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 182 : Loss : 0.3456, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 183 : Loss : 0.3436, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 184 : Loss : 0.3416, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 185 : Loss : 0.3396, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 186 : Loss : 0.3376, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 187 : Loss : 0.3356, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 188 : Loss : 0.3336, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 189 : Loss : 0.3316, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 190 : Loss : 0.3296, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 191 : Loss : 0.3277, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 192 : Loss : 0.3257, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 193 : Loss : 0.3237, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 194 : Loss : 0.3218, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 195 : Loss : 0.3198, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 196 : Loss : 0.3179, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 197 : Loss : 0.3159, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 198 : Loss : 0.3140, Acc : 1.0000, Test Acc : 0.9778\n", + "Epoch 199 : Loss : 0.3121, Acc : 1.0000, Test Acc : 0.9778\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "import math\n", + "\n", + "# Données et modèle du problème des 2 clusters\n", + "x_train_lab, y_train_lab, x_train_unlab, y_train_unlab, x_test, y_test = generate_2clusters_dataset(num_lab=10, num_unlab=90, num_test=90)\n", + "model = create_model_2clusters()\n", + "\n", + "# Hyperparamètres de l'apprentissage\n", + "epochs = 200\n", + "batch_size = 16\n", + "if batch_size < x_train_lab.shape[0]:\n", + " steps_per_epoch = math.floor(x_train_lab.shape[0]/batch_size)\n", + "else:\n", + " steps_per_epoch = 1\n", + " batch_size = x_train_lab.shape[0]\n", + "\n", + "# Instanciation d'un optimiseur et d'une fonction de coût.\n", + "optimizer = keras.optimizers.Adam(learning_rate=1e-2)\n", + "loss_fn = keras.losses.BinaryCrossentropy()\n", + "\n", + "# Préparation des métriques pour le suivi de la performance du modèle.\n", + "train_acc_metric = keras.metrics.BinaryAccuracy()\n", + "test_acc_metric = keras.metrics.BinaryAccuracy()\n", + "\n", + "# Indices de l'ensemble labellisé\n", + "indices = np.arange(x_train_lab.shape[0])\n", + "indices_unlab = np.arange(x_train_unlab.shape[0])\n", + "\n", + "# Boucle sur les epochs\n", + "for epoch in range(epochs):\n", + "\n", + " if epoch > 50:\n", + " lambdaa = 0.25\n", + " else:\n", + " lambdaa = 0\n", + "\n", + " # A chaque nouvelle epoch, on randomise les indices de l'ensemble labellisé\n", + " np.random.shuffle(indices)\n", + " np.random.shuffle(indices_unlab)\n", + "\n", + " # Et on recommence à cumuler la loss\n", + " cum_loss_value = 0\n", + "\n", + " for step in range(steps_per_epoch):\n", + "\n", + " # Sélection des données du prochain batch\n", + " x_batch = x_train_lab[indices[step*batch_size: (step+1)*batch_size]]\n", + " x_batch_unlab = x_train_unlab[indices_unlab[step*batch_size: (step+1)*batch_size]]\n", + " y_batch = y_train_lab[indices[step*batch_size: (step+1)*batch_size]]\n", + "\n", + " # Etape nécessaire pour comparer y_batch à la sortie du réseau\n", + " y_batch = np.expand_dims(y_batch, 1)\n", + "\n", + " # Les opérations effectuées par le modèle dans ce bloc sont suivies et permettront\n", + " # la différentiation automatique.\n", + " with tf.GradientTape() as tape:\n", + "\n", + " # Application du réseau aux données d'entrée\n", + " y_pred = model(x_batch, training=True) # Logits for this minibatch\n", + " y_pred_unlab = model(x_batch_unlab, training=True)\n", + "\n", + " # Calcul de la fonction de perte sur ce batch\n", + " loss_value = loss_fn(y_batch, y_pred) + lambdaa * binary_entropy_loss(y_pred)\n", + "\n", + " # Calcul des gradients par différentiation automatique\n", + " grads = tape.gradient(loss_value, model.trainable_weights)\n", + "\n", + " # Réalisation d'une itération de la descente de gradient (mise à jour des paramètres du réseau)\n", + " optimizer.apply_gradients(zip(grads, model.trainable_weights))\n", + "\n", + " # Mise à jour de la métrique\n", + " train_acc_metric.update_state(y_batch, y_pred)\n", + "\n", + " cum_loss_value = cum_loss_value + loss_value\n", + "\n", + " # Calcul de la précision à la fin de l'epoch\n", + " train_acc = train_acc_metric.result()\n", + "\n", + " # Calcul de la précision sur l'ensemble de test à la fin de l'epoch\n", + " test_logits = model(x_test, training=False)\n", + " test_acc_metric.update_state(np.expand_dims(y_test, 1), test_logits)\n", + " test_acc = test_acc_metric.result()\n", + "\n", + " print(\"Epoch %4d : Loss : %.4f, Acc : %.4f, Test Acc : %.4f\" % (epoch, float(cum_loss_value/steps_per_epoch), float(train_acc), float(test_acc)))\n", + "\n", + " # Remise à zéro des métriques pour la prochaine epoch\n", + " train_acc_metric.reset_states()\n", + " test_acc_metric.reset_states()" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from mlxtend.plotting import plot_decision_regions\n", + "\n", + "# Affichage des données\n", + "plt.plot(x_train_unlab[y_train_unlab==0,0], x_train_unlab[y_train_unlab==0,1], 'b.')\n", + "plt.plot(x_train_unlab[y_train_unlab==1,0], x_train_unlab[y_train_unlab==1,1], 'r.')\n", + "\n", + "plt.plot(x_test[y_test==0,0], x_test[y_test==0,1], 'b+')\n", + "plt.plot(x_test[y_test==1,0], x_test[y_test==1,1], 'r+')\n", + "\n", + "plt.plot(x_train_lab[y_train_lab==0,0], x_train_lab[y_train_lab==0,1], 'b.', markersize=30)\n", + "plt.plot(x_train_lab[y_train_lab==1,0], x_train_lab[y_train_lab==1,1], 'r.', markersize=30)\n", + "\n", + "plt.show()\n", + "\n", + "#Affichage de la frontière de décision\n", + "plot_decision_regions(x_train_unlab, y_train_unlab, clf=model, legend=2)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "y25fa_IIZeuH" + }, + "source": [ + "Une fois cette étape réalisée, vous pouvez tester l'algorithme sur le dataset des 2 lunes ; comme annoncé en cours, vous devriez avoir beaucoup de mal à faire fonctionner l'algorithme sur ces données.\n", + "\n", + "S'il vous reste du temps, vous pouvez également tester votre algorithme sur les données MNIST, cela vous avancera pour la prochaine séance." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "T3qJ5s-NUPnT" + }, + "source": [ + "# MNIST" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kH_eMruIMMVF" + }, + "source": [ + "## Chargement des données\n" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": { + "id": "ebv6WLB1MOkU" + }, + "outputs": [], + "source": [ + "from keras.datasets import mnist\n", + "import numpy as np\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "def generate_mnist_dataset(num_lab = 10, seed=10):\n", + "\n", + " # Chargement et normalisation (entre 0 et 1) des données de la base de données MNIST\n", + " (x_train, y_train), (x_test, y_test) = mnist.load_data()\n", + "\n", + " x_train = np.expand_dims(x_train.astype('float32') / 255., 3)\n", + " x_test = np.expand_dims(x_test.astype('float32') / 255., 3)\n", + "\n", + " x_train_lab, x_train_unlab, y_train_lab, y_train_unlab = train_test_split(x_train, y_train, test_size=(x_train.shape[0]-num_lab)/x_train.shape[0], random_state=seed)\n", + "\n", + " return x_train_lab, y_train_lab, x_train_unlab, y_train_unlab, x_test, y_test\n" + ] + }, + { + "cell_type": "code", + "execution_count": 184, + "metadata": { + "id": "ZTsEZ2pzMpiU" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[7 5 9 4 4 1 8 1 0 7]\n", + "[7 2 8 3 1 4 6 9 5 0]\n", + "[0 5 6 4 5 5 8 2 1 4]\n" + ] + } + ], + "source": [ + "# for i in range(1000, 10000):\n", + "# x_train_lab, y_train_lab, x_train_unlab, y_train_unlab, x_test, y_test = generate_mnist_dataset(num_lab = 10, seed=i)\n", + "# if len(set(y_train_lab)) >= 10:\n", + "# print(i)\n", + "# break\n", + "\n", + "# print(y_train_lab)\n", + "# print(len(y_train_lab))\n", + "# print(set(y_train_lab))\n", + "# test = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "# print(set(test))\n", + "# print(len(set(y_train_lab)))\n", + "\n", + "# print(x_train_lab.shape, x_train_unlab.shape, x_test.shape)\n", + "# print(y_train_lab.shape, y_train_unlab.shape, y_test.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cl7GCcHvUa-l" + }, + "source": [ + "## Définition du modèle" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": { + "id": "RiYrQU0NUcKs" + }, + "outputs": [], + "source": [ + "from keras.layers import Conv2D, MaxPooling2D, Flatten\n", + "\n", + "# Ici, on implémentera le modèle LeNet-5 :\n", + "def create_model_mnist():\n", + "\n", + " inputs = keras.Input(shape=(28, 28, 1,))\n", + "\n", + " # 1 couche de convolution 5x5 à 6 filtres suivie d'un max pooling\n", + " x = Conv2D(6, 5, activation = 'relu')(inputs)\n", + " x = MaxPooling2D(pool_size=(2, 2))(x)\n", + "\n", + " # puis 1 couche de convolution 5x5 à 16 filtres suivie d'un max pooling\n", + " x = Conv2D(16, 5, activation = 'relu')(x)\n", + " x = MaxPooling2D(pool_size=(2, 2))(x)\n", + "\n", + " # et d'un Flatten\n", + " x = Flatten()(x)\n", + "\n", + " # Enfin 2 couches denses de 120 et 84 neurones\n", + " x = Dense(120, activation='relu')(x)\n", + " x = Dense(84, activation='relu')(x)\n", + "\n", + " # avant la couche de sortie à 10 neurones.\n", + " outputs = Dense(10, activation='softmax')(x)\n", + "\n", + " model = keras.Model(inputs=inputs, outputs=outputs) \n", + "\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 190, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0 : Loss : 2.3014, Acc : 0.1000, Test Acc : 0.1074\n", + "Epoch 1 : Loss : 2.2547, Acc : 0.3000, Test Acc : 0.1335\n", + "Epoch 2 : Loss : 2.2146, Acc : 0.4000, Test Acc : 0.1968\n", + "Epoch 3 : Loss : 2.1732, Acc : 0.6000, Test Acc : 0.2695\n", + "Epoch 4 : Loss : 2.1275, Acc : 0.7000, Test Acc : 0.3152\n", + "Epoch 5 : Loss : 2.0814, Acc : 0.8000, Test Acc : 0.3496\n", + "Epoch 6 : Loss : 2.0271, Acc : 0.8000, Test Acc : 0.3671\n", + "Epoch 7 : Loss : 1.9674, Acc : 0.8000, Test Acc : 0.3805\n", + "Epoch 8 : Loss : 1.9000, Acc : 0.8000, Test Acc : 0.3940\n", + "Epoch 9 : Loss : 1.8275, Acc : 0.8000, Test Acc : 0.4053\n", + "Epoch 10 : Loss : 1.7498, Acc : 0.9000, Test Acc : 0.4102\n", + "Epoch 11 : Loss : 1.6640, Acc : 0.9000, Test Acc : 0.4171\n", + "Epoch 12 : Loss : 1.5701, Acc : 0.9000, Test Acc : 0.4208\n", + "Epoch 13 : Loss : 1.4696, Acc : 0.9000, Test Acc : 0.4260\n", + "Epoch 14 : Loss : 1.3669, Acc : 0.9000, Test Acc : 0.4301\n", + "Epoch 15 : Loss : 1.2611, Acc : 0.9000, Test Acc : 0.4359\n", + "Epoch 16 : Loss : 1.1529, Acc : 0.9000, Test Acc : 0.4425\n", + "Epoch 17 : Loss : 1.0442, Acc : 0.9000, Test Acc : 0.4470\n", + "Epoch 18 : Loss : 0.9338, Acc : 1.0000, Test Acc : 0.4501\n", + "Epoch 19 : Loss : 0.8274, Acc : 1.0000, Test Acc : 0.4498\n", + "Epoch 20 : Loss : 0.7254, Acc : 1.0000, Test Acc : 0.4487\n", + "Epoch 21 : Loss : 0.6296, Acc : 1.0000, Test Acc : 0.4457\n", + "Epoch 22 : Loss : 0.5413, Acc : 1.0000, Test Acc : 0.4438\n", + "Epoch 23 : Loss : 0.4580, Acc : 1.0000, Test Acc : 0.4425\n", + "Epoch 24 : Loss : 0.3813, Acc : 1.0000, Test Acc : 0.4404\n", + "Epoch 25 : Loss : 0.3130, Acc : 1.0000, Test Acc : 0.4395\n", + "Epoch 26 : Loss : 1.8660, Acc : 1.0000, Test Acc : 0.4432\n", + "Epoch 27 : Loss : 1.5501, Acc : 1.0000, Test Acc : 0.4450\n", + "Epoch 28 : Loss : 1.2730, Acc : 1.0000, Test Acc : 0.4461\n", + "Epoch 29 : Loss : 1.0235, Acc : 1.0000, Test Acc : 0.4431\n", + "Epoch 30 : Loss : 0.7895, Acc : 1.0000, Test Acc : 0.4384\n", + "Epoch 31 : Loss : 0.5879, Acc : 1.0000, Test Acc : 0.4381\n", + "Epoch 32 : Loss : 0.4273, Acc : 1.0000, Test Acc : 0.4399\n", + "Epoch 33 : Loss : 0.3016, Acc : 1.0000, Test Acc : 0.4425\n", + "Epoch 34 : Loss : 0.2109, Acc : 1.0000, Test Acc : 0.4444\n", + "Epoch 35 : Loss : 0.1455, Acc : 1.0000, Test Acc : 0.4435\n", + "Epoch 36 : Loss : 0.0974, Acc : 1.0000, Test Acc : 0.4459\n", + "Epoch 37 : Loss : 0.0641, Acc : 1.0000, Test Acc : 0.4455\n", + "Epoch 38 : Loss : 0.0427, Acc : 1.0000, Test Acc : 0.4473\n", + "Epoch 39 : Loss : 0.0290, Acc : 1.0000, Test Acc : 0.4475\n", + "Epoch 40 : Loss : 0.0200, Acc : 1.0000, Test Acc : 0.4470\n", + "Epoch 41 : Loss : 0.0138, Acc : 1.0000, Test Acc : 0.4471\n", + "Epoch 42 : Loss : 0.0097, Acc : 1.0000, Test Acc : 0.4473\n", + "Epoch 43 : Loss : 0.0069, Acc : 1.0000, Test Acc : 0.4474\n", + "Epoch 44 : Loss : 0.0050, Acc : 1.0000, Test Acc : 0.4475\n", + "Epoch 45 : Loss : 0.0037, Acc : 1.0000, Test Acc : 0.4478\n", + "Epoch 46 : Loss : 0.0029, Acc : 1.0000, Test Acc : 0.4492\n", + "Epoch 47 : Loss : 0.0022, Acc : 1.0000, Test Acc : 0.4495\n", + "Epoch 48 : Loss : 0.0018, Acc : 1.0000, Test Acc : 0.4498\n", + "Epoch 49 : Loss : 0.0014, Acc : 1.0000, Test Acc : 0.4497\n", + "Epoch 50 : Loss : 0.0011, Acc : 1.0000, Test Acc : 0.4508\n", + "Epoch 51 : Loss : 0.0009, Acc : 1.0000, Test Acc : 0.4520\n", + "Epoch 52 : Loss : 0.0008, Acc : 1.0000, Test Acc : 0.4524\n", + "Epoch 53 : Loss : 0.0007, Acc : 1.0000, Test Acc : 0.4528\n", + "Epoch 54 : Loss : 0.0006, Acc : 1.0000, Test Acc : 0.4534\n", + "Epoch 55 : Loss : 0.0005, Acc : 1.0000, Test Acc : 0.4537\n", + "Epoch 56 : Loss : 0.0004, Acc : 1.0000, Test Acc : 0.4540\n", + "Epoch 57 : Loss : 0.0004, Acc : 1.0000, Test Acc : 0.4550\n", + "Epoch 58 : Loss : 0.0003, Acc : 1.0000, Test Acc : 0.4559\n", + "Epoch 59 : Loss : 0.0003, Acc : 1.0000, Test Acc : 0.4560\n", + "Epoch 60 : Loss : 0.0003, Acc : 1.0000, Test Acc : 0.4559\n", + "Epoch 61 : Loss : 0.0002, Acc : 1.0000, Test Acc : 0.4559\n", + "Epoch 62 : Loss : 0.0002, Acc : 1.0000, Test Acc : 0.4560\n", + "Epoch 63 : Loss : 0.0002, Acc : 1.0000, Test Acc : 0.4563\n", + "Epoch 64 : Loss : 0.0002, Acc : 1.0000, Test Acc : 0.4562\n", + "Epoch 65 : Loss : 0.0002, Acc : 1.0000, Test Acc : 0.4566\n", + "Epoch 66 : Loss : 0.0002, Acc : 1.0000, Test Acc : 0.4572\n", + "Epoch 67 : Loss : 0.0002, Acc : 1.0000, Test Acc : 0.4579\n", + "Epoch 68 : Loss : 0.0002, Acc : 1.0000, Test Acc : 0.4580\n", + "Epoch 69 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4582\n", + "Epoch 70 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4582\n", + "Epoch 71 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4585\n", + "Epoch 72 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4585\n", + "Epoch 73 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4585\n", + "Epoch 74 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4586\n", + "Epoch 75 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4583\n", + "Epoch 76 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4583\n", + "Epoch 77 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4580\n", + "Epoch 78 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4577\n", + "Epoch 79 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4573\n", + "Epoch 80 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4577\n", + "Epoch 81 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4576\n", + "Epoch 82 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4576\n", + "Epoch 83 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4574\n", + "Epoch 84 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4573\n", + "Epoch 85 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4572\n", + "Epoch 86 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4574\n", + "Epoch 87 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4573\n", + "Epoch 88 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4571\n", + "Epoch 89 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4570\n", + "Epoch 90 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4569\n", + "Epoch 91 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4567\n", + "Epoch 92 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4567\n", + "Epoch 93 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4567\n", + "Epoch 94 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4567\n", + "Epoch 95 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4569\n", + "Epoch 96 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4567\n", + "Epoch 97 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4568\n", + "Epoch 98 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4568\n", + "Epoch 99 : Loss : 0.0001, Acc : 1.0000, Test Acc : 0.4571\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "import math\n", + "\n", + "# Données et modèle du problème des 2 clusters\n", + "x_train_lab, y_train_lab, x_train_unlab, y_train_unlab, x_test, y_test = generate_mnist_dataset(num_lab=10, seed=1164)\n", + "model = create_model_mnist()\n", + "\n", + "# Hyperparamètres de l'apprentissage\n", + "epochs = 100\n", + "batch_size = 64\n", + "if batch_size < x_train_lab.shape[0]:\n", + " steps_per_epoch = math.floor(x_train_lab.shape[0]/batch_size)\n", + "else:\n", + " steps_per_epoch = 1\n", + " batch_size = x_train_lab.shape[0]\n", + "\n", + "# Instanciation d'un optimiseur et d'une fonction de coût.\n", + "optimizer = keras.optimizers.Adam(learning_rate=1e-3)\n", + "loss_fn = keras.losses.SparseCategoricalCrossentropy()\n", + "\n", + "# Préparation des métriques pour le suivi de la performance du modèle.\n", + "train_acc_metric = keras.metrics.SparseCategoricalAccuracy()\n", + "test_acc_metric = keras.metrics.SparseCategoricalAccuracy()\n", + "\n", + "# Indices de l'ensemble labellisé\n", + "indices = np.arange(x_train_lab.shape[0])\n", + "indices_unlab = np.arange(x_train_unlab.shape[0])\n", + "\n", + "# Boucle sur les epochs\n", + "for epoch in range(epochs):\n", + "\n", + " if epoch > 25:\n", + " lambdaa = 0.2\n", + " else:\n", + " lambdaa = 0\n", + "\n", + " # A chaque nouvelle epoch, on randomise les indices de l'ensemble labellisé\n", + " np.random.shuffle(indices)\n", + " np.random.shuffle(indices_unlab)\n", + "\n", + " # Et on recommence à cumuler la loss\n", + " cum_loss_value = 0\n", + "\n", + " for step in range(steps_per_epoch):\n", + "\n", + " # Sélection des données du prochain batch\n", + " x_batch = x_train_lab[indices[step*batch_size: (step+1)*batch_size]]\n", + " x_batch_unlab = x_train_unlab[indices_unlab[step*batch_size: (step+1)*batch_size]]\n", + " y_batch = y_train_lab[indices[step*batch_size: (step+1)*batch_size]]\n", + "\n", + " # Etape nécessaire pour comparer y_batch à la sortie du réseau\n", + " y_batch = np.expand_dims(y_batch, 1)\n", + "\n", + " # Les opérations effectuées par le modèle dans ce bloc sont suivies et permettront\n", + " # la différentiation automatique.\n", + " with tf.GradientTape() as tape:\n", + "\n", + " # Application du réseau aux données d'entrée\n", + " y_pred = model(x_batch, training=True) # Logits for this minibatch\n", + " y_pred_unlab = model(x_batch_unlab, training=True)\n", + "\n", + " # Calcul de la fonction de perte sur ce batch\n", + " # print(y_batch)\n", + " # print(y_pred)\n", + " loss_value = loss_fn(y_batch, y_pred) + lambdaa * binary_entropy_loss(y_pred)\n", + "\n", + " # Calcul des gradients par différentiation automatique\n", + " grads = tape.gradient(loss_value, model.trainable_weights)\n", + "\n", + " # Réalisation d'une itération de la descente de gradient (mise à jour des paramètres du réseau)\n", + " optimizer.apply_gradients(zip(grads, model.trainable_weights))\n", + "\n", + " # Mise à jour de la métrique\n", + " train_acc_metric.update_state(y_batch, y_pred)\n", + "\n", + " cum_loss_value = cum_loss_value + loss_value\n", + "\n", + " # Calcul de la précision à la fin de l'epoch\n", + " train_acc = train_acc_metric.result()\n", + "\n", + " # Calcul de la précision sur l'ensemble de test à la fin de l'epoch\n", + " test_logits = model(x_test, training=False)\n", + " test_acc_metric.update_state(np.expand_dims(y_test, 1), test_logits)\n", + " test_acc = test_acc_metric.result()\n", + "\n", + " print(\"Epoch %4d : Loss : %.4f, Acc : %.4f, Test Acc : %.4f\" % (epoch, float(cum_loss_value/steps_per_epoch), float(train_acc), float(test_acc)))\n", + "\n", + " # Remise à zéro des métriques pour la prochaine epoch\n", + " train_acc_metric.reset_states()\n", + " test_acc_metric.reset_states()" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [ + "fbmhai8PVXVd", + "kH_eMruIMMVF" + ], + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3.10.7 64-bit", + "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.7" + }, + "vscode": { + "interpreter": { + "hash": "767d51c1340bd893661ea55ea3124f6de3c7a262a8b4abca0554b478b1e2ff90" + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/IAM2022_Génération_de_texte_Sujet.ipynb b/IAM2022_Génération_de_texte_Sujet.ipynb new file mode 100644 index 0000000..09884db --- /dev/null +++ b/IAM2022_Génération_de_texte_Sujet.ipynb @@ -0,0 +1,1019 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "BwpJ5IffzRG6" + }, + "source": [ + "Dans ce TP, nous allons entraîner et tester un RNN pour la génération de texte. Plus précisément, le modèle que nous allons construire sera capable, étant donnée une séquence de caractères, de prédire le prochain caractère le plus probable.\n", + "\n", + "![model](https://drive.google.com/uc?id=1syE1phix6Pu-b8y9ktol0thCdC2lzmlV\n", + ")\n", + "\n", + "Il sera alors possible, partant d'une chaîne de caractères, de réaliser plus inférences successivement du modèle pour générer la suite de la phrase.\n", + "\n", + "![inference](https://drive.google.com/uc?id=1T6J3UgFV4Q2JhJm3984HhJIkH7ukWkb7\n", + ")\n", + "\n", + "Les phrases suivantes ont été obtenues à l'issue d'un entraînement du modèle sur une base de données regroupant les tweets de Donald Trump (à partir respectivement des débuts de phrase 'China', 'Obama', et 'Mo'). Même si les phrases ne sont pas complètement correctes, le modèle arrive à générer des mots existants (pour la plupart) et à les enchaîner d'une manière tout de même relativement crédible !\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HcygKkEVZBaa" + }, + "source": [ + "
\n",
+        "China on dollars are sources to other things!The Fake News State approvement is smart, restlected & unfair \n",
+        "\n",
+        "Obama BEAT!Not too late. This is the only requirement. Also, the Fake News is running a big democrats want \n",
+        "\n",
+        "More system. See you really weak!Thank you. You and others just doesn’t exist.\n",
+        "
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_bGsCP9DZFQ5" + }, + "source": [ + "Le reste du notebook a été adapté du tutorial https://www.tensorflow.org/text/tutorials/text_generation. Il n'y aura pas de code à compléter, l'objectif du TP est de découvrir comment préparer la base de données, implémenter et entraîner le modèle, et réaliser l'inférence.\n", + "\n", + "A vous de vous emparer du code ci-dessous pour essayer d'améliorer les performances du modèle et de générer les phrases les plus crédibles possibles ! " + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Téléchargement des données" + ], + "metadata": { + "id": "YDjEFzJ-ecuJ" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:08.261025Z", + "iopub.status.busy": "2022-05-03T11:14:08.260828Z", + "iopub.status.idle": "2022-05-03T11:14:10.284556Z", + "shell.execute_reply": "2022-05-03T11:14:10.283846Z" + }, + "id": "yG_n40gFzf9s" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "\n", + "import numpy as np\n", + "import os\n", + "import time" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EHDoRoc5PKWz" + }, + "source": [ + "Téléchargement des données" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:10.288588Z", + "iopub.status.busy": "2022-05-03T11:14:10.288339Z", + "iopub.status.idle": "2022-05-03T11:14:10.512538Z", + "shell.execute_reply": "2022-05-03T11:14:10.511842Z" + }, + "id": "pD_55cOxLkAb" + }, + "outputs": [], + "source": [ + "path_to_file = tf.keras.utils.get_file('realdonaltrump.csv', 'https://drive.google.com/uc?export=download&id=1s1isv9TQjGiEr2gG__8bOdBFvQlmepRt')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UHjdCjDuSvX_" + }, + "source": [ + "On commence par extraire les tweets du CSV (notez qu'il y a d'autres métadonnées dans le fichier, comme le nombre de retweets par exemple, qui pourraient être utilisées pour d'autres tâches)." + ] + }, + { + "cell_type": "code", + "source": [ + "import csv\n", + "tweets = []\n", + "text = ''\n", + "with open(path_to_file, newline='') as csvfile:\n", + " reader = csv.DictReader(csvfile)\n", + " for row in reader:\n", + " tweets.append(row['content'])\n", + " text += row['content']\n", + "\n", + "# Affichage des 10 premiers tweets\n", + "print(tweets[:10])" + ], + "metadata": { + "id": "BPfeRNpwC-Ev" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:10.515842Z", + "iopub.status.busy": "2022-05-03T11:14:10.515602Z", + "iopub.status.idle": "2022-05-03T11:14:10.521336Z", + "shell.execute_reply": "2022-05-03T11:14:10.520758Z" + }, + "id": "aavnuByVymwK" + }, + "outputs": [], + "source": [ + "# Nombre total de caractères du dataset\n", + "print(f'Longueur totale du texte: {len(text)} caractères')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:10.530172Z", + "iopub.status.busy": "2022-05-03T11:14:10.529967Z", + "iopub.status.idle": "2022-05-03T11:14:10.544918Z", + "shell.execute_reply": "2022-05-03T11:14:10.544310Z" + }, + "id": "IlCgQBRVymwR" + }, + "outputs": [], + "source": [ + "# Extraction des caractères uniques du texte\n", + "vocab = sorted(set(text))\n", + "print(f'{len(vocab)} unique caractères')" + ] + }, + { + "cell_type": "code", + "source": [ + "# Affichage du vocabulaire\n", + "print(vocab)" + ], + "metadata": { + "id": "hSAriIDsEa-J" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rNnrKn_lL-IJ" + }, + "source": [ + "# Préparation des données" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LFjSVAlWzf-N" + }, + "source": [ + "Il est nécessaire de convertir les caractères dans une représentation admissible par le modèle. \n", + "\n", + "La fonction `tf.keras.layers.StringLookup` convertit les chaînes de caractères en nombre, en reprenant l'indice de chaque caractère dans le vocabulaire établi précédemment.\n", + "\n", + "Il faut cependant commencer par séparer le texte en caractères, comme présenté sur l'exemple ci-dessous." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:10.547650Z", + "iopub.status.busy": "2022-05-03T11:14:10.547458Z", + "iopub.status.idle": "2022-05-03T11:14:12.216225Z", + "shell.execute_reply": "2022-05-03T11:14:12.215486Z" + }, + "id": "a86OoYtO01go" + }, + "outputs": [], + "source": [ + "example_texts = ['abcdefg', 'xyz']\n", + "\n", + "chars = tf.strings.unicode_split(example_texts, input_encoding='UTF-8')\n", + "chars" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1s4f1q3iqY8f" + }, + "source": [ + "On peut ensuire appliquer la fonction `tf.keras.layers.StringLookup` :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.219925Z", + "iopub.status.busy": "2022-05-03T11:14:12.219236Z", + "iopub.status.idle": "2022-05-03T11:14:12.230858Z", + "shell.execute_reply": "2022-05-03T11:14:12.230260Z" + }, + "id": "6GMlCe3qzaL9" + }, + "outputs": [], + "source": [ + "ids_from_chars = tf.keras.layers.StringLookup(\n", + " vocabulary=list(vocab), mask_token=None)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.234414Z", + "iopub.status.busy": "2022-05-03T11:14:12.233898Z", + "iopub.status.idle": "2022-05-03T11:14:12.241111Z", + "shell.execute_reply": "2022-05-03T11:14:12.240543Z" + }, + "id": "WLv5Q_2TC2pc" + }, + "outputs": [], + "source": [ + "ids = ids_from_chars(chars)\n", + "ids" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tZfqhkYCymwX" + }, + "source": [ + "Pour retrouver un texte à partir de sa représentation numérique (ce sera utile lors de l'étape finale de génération) il faut être capable d'inverser le processus, ce que l'on peut faire avec `tf.keras.layers.StringLookup(..., invert=True)`. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.244473Z", + "iopub.status.busy": "2022-05-03T11:14:12.244010Z", + "iopub.status.idle": "2022-05-03T11:14:12.251817Z", + "shell.execute_reply": "2022-05-03T11:14:12.251224Z" + }, + "id": "Wd2m3mqkDjRj" + }, + "outputs": [], + "source": [ + "chars_from_ids = tf.keras.layers.StringLookup(\n", + " vocabulary=ids_from_chars.get_vocabulary(), invert=True, mask_token=None)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.255016Z", + "iopub.status.busy": "2022-05-03T11:14:12.254548Z", + "iopub.status.idle": "2022-05-03T11:14:12.259845Z", + "shell.execute_reply": "2022-05-03T11:14:12.259298Z" + }, + "id": "c2GCh0ySD44s" + }, + "outputs": [], + "source": [ + "chars = chars_from_ids(ids)\n", + "chars" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-FeW5gqutT3o" + }, + "source": [ + "Enfin, on peut recréer une chaîne de caractères :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.263027Z", + "iopub.status.busy": "2022-05-03T11:14:12.262587Z", + "iopub.status.idle": "2022-05-03T11:14:12.273779Z", + "shell.execute_reply": "2022-05-03T11:14:12.273214Z" + }, + "id": "zxYI-PeltqKP" + }, + "outputs": [], + "source": [ + "tf.strings.reduce_join(chars, axis=-1).numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.276992Z", + "iopub.status.busy": "2022-05-03T11:14:12.276505Z", + "iopub.status.idle": "2022-05-03T11:14:12.280017Z", + "shell.execute_reply": "2022-05-03T11:14:12.279421Z" + }, + "id": "w5apvBDn9Ind" + }, + "outputs": [], + "source": [ + "def text_from_ids(ids):\n", + " return tf.strings.reduce_join(chars_from_ids(ids), axis=-1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hgsVvVxnymwf" + }, + "source": [ + "Il faut maintenant créer les exemples d'apprentissage, ainsi que leurs labels associés. Pour cela, nous allons diviser le texte en séquences, chacune composée de `seq_length` caractères.\n", + "\n", + "Pour chaque séquence constituant un ensemble d'apprentissage, le label à prédire correspondant est une séquence de même longueur dont tous les caractères ont été décalés d'un cran. \n", + "\n", + "Une manière simple de constituer notre base est donc de diviser le texte en séquences de longueur `seq_length+1`, et d'utiliser les `seq_length` premiers caractères comme donnée, et les `seq_length` derniers caractères comme label.\n", + "\n", + "\n", + "N.B. Cette manière de faire n'est clairement pas optimale ! Certaines séquences vont recouvrir deux tweets successifs, qui n'auront potentiellement aucun lien entre eux !" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.283397Z", + "iopub.status.busy": "2022-05-03T11:14:12.282940Z", + "iopub.status.idle": "2022-05-03T11:14:12.693441Z", + "shell.execute_reply": "2022-05-03T11:14:12.692846Z" + }, + "id": "UopbsKi88tm5" + }, + "outputs": [], + "source": [ + "all_ids = ids_from_chars(tf.strings.unicode_split(text, 'UTF-8'))\n", + "all_ids" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.696712Z", + "iopub.status.busy": "2022-05-03T11:14:12.696216Z", + "iopub.status.idle": "2022-05-03T11:14:12.700189Z", + "shell.execute_reply": "2022-05-03T11:14:12.699616Z" + }, + "id": "qmxrYDCTy-eL" + }, + "outputs": [], + "source": [ + "ids_dataset = tf.data.Dataset.from_tensor_slices(all_ids)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.703062Z", + "iopub.status.busy": "2022-05-03T11:14:12.702570Z", + "iopub.status.idle": "2022-05-03T11:14:12.721321Z", + "shell.execute_reply": "2022-05-03T11:14:12.720696Z" + }, + "id": "cjH5v45-yqqH" + }, + "outputs": [], + "source": [ + "for ids in ids_dataset.take(10):\n", + " print(chars_from_ids(ids).numpy().decode('utf-8'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.724378Z", + "iopub.status.busy": "2022-05-03T11:14:12.723876Z", + "iopub.status.idle": "2022-05-03T11:14:12.726907Z", + "shell.execute_reply": "2022-05-03T11:14:12.726324Z" + }, + "id": "C-G2oaTxy6km" + }, + "outputs": [], + "source": [ + "seq_length = 50\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-ZSYAcQV8OGP" + }, + "source": [ + "La méthode `batch` permet de regrouper les caractères du texte en séquences de la longueur voulue." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.729823Z", + "iopub.status.busy": "2022-05-03T11:14:12.729461Z", + "iopub.status.idle": "2022-05-03T11:14:12.740383Z", + "shell.execute_reply": "2022-05-03T11:14:12.739819Z" + }, + "id": "BpdjRO2CzOfZ" + }, + "outputs": [], + "source": [ + "sequences = ids_dataset.batch(seq_length+1, drop_remainder=True)\n", + "\n", + "for seq in sequences.take(1):\n", + " print(chars_from_ids(seq))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5PHW902-4oZt" + }, + "source": [ + "Voici par exemple les premières séquences extraites du dataset :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.743335Z", + "iopub.status.busy": "2022-05-03T11:14:12.742989Z", + "iopub.status.idle": "2022-05-03T11:14:12.754659Z", + "shell.execute_reply": "2022-05-03T11:14:12.754086Z" + }, + "id": "QO32cMWu4a06" + }, + "outputs": [], + "source": [ + "for seq in sequences.take(5):\n", + " print(text_from_ids(seq).numpy())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UbLcIPBj_mWZ" + }, + "source": [ + "Nous allons maintenant générer les couples (données, labels) à partir des séquences extraites :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.757751Z", + "iopub.status.busy": "2022-05-03T11:14:12.757363Z", + "iopub.status.idle": "2022-05-03T11:14:12.760852Z", + "shell.execute_reply": "2022-05-03T11:14:12.760178Z" + }, + "id": "9NGu-FkO_kYU" + }, + "outputs": [], + "source": [ + "def split_input_target(sequence):\n", + " input_text = sequence[:-1]\n", + " target_text = sequence[1:]\n", + " return input_text, target_text" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.763663Z", + "iopub.status.busy": "2022-05-03T11:14:12.763249Z", + "iopub.status.idle": "2022-05-03T11:14:12.767978Z", + "shell.execute_reply": "2022-05-03T11:14:12.767379Z" + }, + "id": "WxbDTJTw5u_P" + }, + "outputs": [], + "source": [ + "split_input_target(list(\"Tensorflow\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.770840Z", + "iopub.status.busy": "2022-05-03T11:14:12.770439Z", + "iopub.status.idle": "2022-05-03T11:14:12.816930Z", + "shell.execute_reply": "2022-05-03T11:14:12.816374Z" + }, + "id": "B9iKPXkw5xwa" + }, + "outputs": [], + "source": [ + "dataset = sequences.map(split_input_target)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.820172Z", + "iopub.status.busy": "2022-05-03T11:14:12.819702Z", + "iopub.status.idle": "2022-05-03T11:14:12.842329Z", + "shell.execute_reply": "2022-05-03T11:14:12.841738Z" + }, + "id": "GNbw-iR0ymwj" + }, + "outputs": [], + "source": [ + "for input_example, target_example in dataset.take(1):\n", + " print(\"Input :\", text_from_ids(input_example).numpy())\n", + " print(\"Target:\", text_from_ids(target_example).numpy())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MJdfPmdqzf-R" + }, + "source": [ + "Avant de pouvoir fournir les données au modèle, il est important de les ranger dans un ordre aléatoire et de les regrouper en batches.\n", + "\n", + "Le paramètre `prefetch` permet d'organiser le chargement du prochain batch de données pendant que le modèle est en train de traiter le précédent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.845656Z", + "iopub.status.busy": "2022-05-03T11:14:12.845278Z", + "iopub.status.idle": "2022-05-03T11:14:12.852723Z", + "shell.execute_reply": "2022-05-03T11:14:12.852173Z" + }, + "id": "p2pGotuNzf-S" + }, + "outputs": [], + "source": [ + "# Batch size\n", + "BATCH_SIZE = 64\n", + "\n", + "# Buffer size to shuffle the dataset\n", + "# (TF data is designed to work with possibly infinite sequences,\n", + "# so it doesn't attempt to shuffle the entire sequence in memory. Instead,\n", + "# it maintains a buffer in which it shuffles elements).\n", + "BUFFER_SIZE = 10000\n", + "\n", + "dataset = (\n", + " dataset\n", + " .shuffle(BUFFER_SIZE)\n", + " .batch(BATCH_SIZE, drop_remainder=True)\n", + " .prefetch(tf.data.experimental.AUTOTUNE))\n", + "\n", + "dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "r6oUuElIMgVx" + }, + "source": [ + "# Construction du modèle" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "m8gPwEjRzf-Z" + }, + "source": [ + "Le modèle sera composé de 3 couches seulement :\n", + "\n", + "* `tf.keras.layers.Embedding`: La couche d'entrée, qui permet d'apprendre un descripteur de dimension`embedding_dim` à associer à chacun des caractères passés en entrée;\n", + "* `tf.keras.layers.GRU`: Une cellule récurrente, avec `rnn_units` neurones (que l'on pourrait tout à fait remplacer par un LSTM)\n", + "* `tf.keras.layers.Dense`: La couche de sortie, avec `vocab_size` neurones. Notez qu'on ne spécifie pas la fonction d'activation (`softmax`) car elle est intégrée directement dans la fonction de coût." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.856129Z", + "iopub.status.busy": "2022-05-03T11:14:12.855554Z", + "iopub.status.idle": "2022-05-03T11:14:12.860086Z", + "shell.execute_reply": "2022-05-03T11:14:12.859494Z" + }, + "id": "zHT8cLh7EAsg" + }, + "outputs": [], + "source": [ + "# Taille du vocabulaire\n", + "vocab_size = len(ids_from_chars.get_vocabulary())\n", + "\n", + "# Dimension des descripteurs de caractères\n", + "embedding_dim = 256\n", + "\n", + "# Nombre de neurones du GRU\n", + "rnn_units = 512" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.862758Z", + "iopub.status.busy": "2022-05-03T11:14:12.862561Z", + "iopub.status.idle": "2022-05-03T11:14:12.868444Z", + "shell.execute_reply": "2022-05-03T11:14:12.867942Z" + }, + "id": "wj8HQ2w8z4iO" + }, + "outputs": [], + "source": [ + "class MyModel(tf.keras.Model):\n", + " def __init__(self, vocab_size, embedding_dim, rnn_units):\n", + " super().__init__(self)\n", + " self.embedding = tf.keras.layers.Embedding(vocab_size, embedding_dim)\n", + " self.gru = tf.keras.layers.GRU(rnn_units,\n", + " return_sequences=True,\n", + " return_state=True)\n", + " self.dense = tf.keras.layers.Dense(vocab_size)\n", + "\n", + " def call(self, inputs, states=None, return_state=False, training=False):\n", + " x = inputs\n", + " x = self.embedding(x, training=training)\n", + " if states is None:\n", + " states = self.gru.get_initial_state(x)\n", + " x, states = self.gru(x, initial_state=states, training=training)\n", + " x = self.dense(x, training=training)\n", + "\n", + " if return_state:\n", + " return x, states\n", + " else:\n", + " return x" + ] + }, + { + "cell_type": "markdown", + "source": [ + "N.B. Cette manière inhabituelle de définir le modèle (qui ressemble d'ailleurs beaucoup au formalisme Pytorch) est utile pour l'inférence. Nous aurions pu utiliser un modèle classique (construit avec `keras.Sequential`) mais cela ne nous aurait pas donné d'accès simple aux états internes du GRU. Il sera important de pouvoir manipuler cet état lorsque nous enchaînerons plusieurs prédictions successives, qui nécessiteront chaque fois de repartir de l'état obtenu lors de la prédiction précédente. Cette opération n'est pas possible avec le modèle Sequentiel que nous utilisons d'habitude." + ], + "metadata": { + "id": "Pjcb4E4jkmi5" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:12.871482Z", + "iopub.status.busy": "2022-05-03T11:14:12.870964Z", + "iopub.status.idle": "2022-05-03T11:14:12.884188Z", + "shell.execute_reply": "2022-05-03T11:14:12.883662Z" + }, + "id": "IX58Xj9z47Aw" + }, + "outputs": [], + "source": [ + "model = MyModel(\n", + " vocab_size=vocab_size,\n", + " embedding_dim=embedding_dim,\n", + " rnn_units=rnn_units)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RkA5upJIJ7W7" + }, + "source": [ + "Pour chaque caractère de la séquence, le modèle produit le descripteur associé, applique un pas de temps du GRU et enfin applique la couche dense pour obtenir la prédiction du réseau :\n", + "\n", + "![A drawing of the data passing through the model](https://drive.google.com/uc?id=1GYD8U9aF-MTC1XpJ3VKpY1b0clJuO4wb)" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Nous pouvons tester notre modèle sur le premier exemple d'apprentissage, pour vérifier les dimensions :" + ], + "metadata": { + "id": "skr44qgVmr3m" + } + }, + { + "cell_type": "code", + "source": [ + "for input_example_batch, target_example_batch in dataset.take(1):\n", + " example_batch_predictions = model(input_example_batch)\n", + " print(example_batch_predictions.shape, \"# (batch_size, sequence_length, vocab_size)\")" + ], + "metadata": { + "id": "BqUVnDFTmpUD" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:19.114557Z", + "iopub.status.busy": "2022-05-03T11:14:19.114071Z", + "iopub.status.idle": "2022-05-03T11:14:19.127462Z", + "shell.execute_reply": "2022-05-03T11:14:19.126830Z" + }, + "id": "vPGmAAXmVLGC" + }, + "outputs": [], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LJL0Q0YPY6Ee" + }, + "source": [ + "# Entraînement du modèle" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YCbHQHiaa4Ic" + }, + "source": [ + "Le problème que nous cherchons à résoudre est celui d'une classification à `vocab_size` classes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UAjbjY03eiQ4" + }, + "source": [ + "On utilise la fonction de coût `tf.keras.losses.sparse_categorical_crossentropy` car nos labels sont sous forme d'indices (et pas de *one-hot vectors*). Le flag `from_logits` positionné à `True` indique qu'il faut au préalable appliquer la fonction softmax à la sortie du réseau." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:19.186765Z", + "iopub.status.busy": "2022-05-03T11:14:19.186240Z", + "iopub.status.idle": "2022-05-03T11:14:19.197413Z", + "shell.execute_reply": "2022-05-03T11:14:19.196878Z" + }, + "id": "DDl1_Een6rL0" + }, + "outputs": [], + "source": [ + "model.compile(optimizer='adam', loss = tf.losses.SparseCategoricalCrossentropy(from_logits=True))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:14:19.214135Z", + "iopub.status.busy": "2022-05-03T11:14:19.213597Z", + "iopub.status.idle": "2022-05-03T11:16:14.167240Z", + "shell.execute_reply": "2022-05-03T11:16:14.166580Z" + }, + "id": "UK-hmKjYVoll" + }, + "outputs": [], + "source": [ + "history = model.fit(dataset, epochs=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kKkD5M6eoSiN" + }, + "source": [ + "# Génération de texte" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oIdQ8c8NvMzV" + }, + "source": [ + "Pour générer un texte, il suffit de partir d'une séquence initiale, d'effectuer une prédiction, et de conserver l'état interne du modèle pour pouvoir le restaurer lors de la prochaine inférence, qui prendra en entrée la séquence initiale augmentée du caractère prédit précédemment.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DjGz1tDkzf-u" + }, + "source": [ + "La classe suivante permet de réaliser une prédiction :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:16:14.171458Z", + "iopub.status.busy": "2022-05-03T11:16:14.170910Z", + "iopub.status.idle": "2022-05-03T11:16:14.180188Z", + "shell.execute_reply": "2022-05-03T11:16:14.179593Z" + }, + "id": "iSBU1tHmlUSs" + }, + "outputs": [], + "source": [ + "class OneStep(tf.keras.Model):\n", + " def __init__(self, model, chars_from_ids, ids_from_chars, temperature=1):\n", + " super().__init__()\n", + " self.temperature = temperature\n", + " self.model = model\n", + " self.chars_from_ids = chars_from_ids\n", + " self.ids_from_chars = ids_from_chars\n", + "\n", + "\n", + " @tf.function\n", + " def generate_one_step(self, inputs, states=None):\n", + " # Convert strings to token IDs.\n", + " input_chars = tf.strings.unicode_split(inputs, 'UTF-8')\n", + " input_ids = self.ids_from_chars(input_chars).to_tensor()\n", + "\n", + " # Run the model.\n", + " # predicted_logits.shape is [batch, char, next_char_logits]\n", + " predicted_logits, states = self.model(inputs=input_ids, states=states,\n", + " return_state=True)\n", + " # Only use the last prediction.\n", + " predicted_logits = predicted_logits[:, -1, :]\n", + " predicted_logits = predicted_logits/self.temperature\n", + "\n", + " # Sample the output logits to generate token IDs.\n", + " predicted_ids = tf.random.categorical(predicted_logits, num_samples=1)\n", + " predicted_ids = tf.squeeze(predicted_ids, axis=-1)\n", + "\n", + " # Convert from token ids to characters\n", + " predicted_chars = self.chars_from_ids(predicted_ids)\n", + "\n", + " # Return the characters and model state.\n", + " return predicted_chars, states" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:16:14.183384Z", + "iopub.status.busy": "2022-05-03T11:16:14.182965Z", + "iopub.status.idle": "2022-05-03T11:16:14.193938Z", + "shell.execute_reply": "2022-05-03T11:16:14.193266Z" + }, + "id": "fqMOuDutnOxK" + }, + "outputs": [], + "source": [ + "one_step_model = OneStep(model, chars_from_ids, ids_from_chars)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "p9yDoa0G3IgQ" + }, + "source": [ + "Il reste à appeler cette fonction dans une boucle opour générer un texte complet :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2022-05-03T11:16:14.197481Z", + "iopub.status.busy": "2022-05-03T11:16:14.197261Z", + "iopub.status.idle": "2022-05-03T11:16:16.999406Z", + "shell.execute_reply": "2022-05-03T11:16:16.998550Z" + }, + "id": "ST7PSyk9t1mT" + }, + "outputs": [], + "source": [ + "start = time.time()\n", + "states = None\n", + "next_char = tf.constant(['Obama '])\n", + "result = [next_char]\n", + "\n", + "for n in range(100):\n", + " next_char, states = one_step_model.generate_one_step(next_char, states=states)\n", + " result.append(next_char)\n", + "\n", + "result = tf.strings.join(result)\n", + "end = time.time()\n", + "print(result[0].numpy().decode('utf-8'), '\\n\\n' + '_'*80)\n", + "print('\\nRun time:', end - start)" + ] + }, + { + "cell_type": "markdown", + "source": [ + "A vous de jouer pour améliorer les résultats. Vous pouvez par exemple : \n", + "- Jouer avec le paramètre de température dans la classe `OneStep` pour accentuer ou diminuer le caractère aléatoire des prédictions.\n", + "- Modifier le réseau en rajoutant des couches supplémentaires, ou en modifiant le nombre de neurones de la couche GRU.\n", + "- Modifier la préparation des données pour éviter le problème des séquences chevauchant plusieurs tweets\n", + "- Entraîner le modèle plus longtemps devrait également aider !" + ], + "metadata": { + "id": "emMSmEg2qk_c" + } + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "toc_visible": true, + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "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.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/IAM2022_TP_Autoencodeurs_Sujet.ipynb b/IAM2022_TP_Autoencodeurs_Sujet.ipynb new file mode 100644 index 0000000..0d555ea --- /dev/null +++ b/IAM2022_TP_Autoencodeurs_Sujet.ipynb @@ -0,0 +1,991 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "XMMppWbnG3dN" + }, + "source": [ + "## Auto-encodeurs\n", + "\n", + "L'objectif de ce TP est de manipuler des auto-encodeurs sur un exemple simple : la base de données MNIST. L'idée est de pouvoir visualiser les concepts vus en cours, et notamment d'illustrer la notion d'espace latent.\n", + "\n", + "Pour rappel, vous avez déjà manipulé les données MNIST en Analyse de Données en première année. Les images MNIST sont des images en niveaux de gris, de taille 28x28 pixels, représentant des chiffres manuscrits de 0 à 9.\n", + "\n", + "![mnist](http://i.ytimg.com/vi/0QI3xgXuB-Q/hqdefault.jpg)\n", + "\n", + "Pour démarrer, nous vous fournissons un code permettant de créer un premier auto-encodeur simple, de charger les données MNIST et d'entraîner cet auto-encodeur. **L'autoencodeur n'est pas convolutif !** (libre à vous de le transformer pour qu'il le soit, plus tard dans le TP)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "id": "nndrdDrlSkho" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"model_11\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " input_7 (InputLayer) [(None, 784)] 0 \n", + " \n", + " model_9 (Functional) (None, 32) 104608 \n", + " \n", + " model_10 (Functional) (None, 784) 105360 \n", + " \n", + "=================================================================\n", + "Total params: 209,968\n", + "Trainable params: 209,968\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "Model: \"model_9\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " input_7 (InputLayer) [(None, 784)] 0 \n", + " \n", + " dense_12 (Dense) (None, 128) 100480 \n", + " \n", + " dense_13 (Dense) (None, 32) 4128 \n", + " \n", + "=================================================================\n", + "Total params: 104,608\n", + "Trainable params: 104,608\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "None\n", + "Model: \"model_10\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " input_8 (InputLayer) [(None, 32)] 0 \n", + " \n", + " dense_14 (Dense) (None, 128) 4224 \n", + " \n", + " dense_15 (Dense) (None, 784) 101136 \n", + " \n", + "=================================================================\n", + "Total params: 105,360\n", + "Trainable params: 105,360\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "None\n" + ] + } + ], + "source": [ + "from keras.layers import Input, Dense\n", + "from keras.models import Model\n", + "\n", + "# Dimension de l'entrée\n", + "input_img = Input(shape=(784,))\n", + "# Dimension de l'espace latent : PARAMETRE A TESTER !!\n", + "latent_dim = 32\n", + "\n", + "# Définition d'un encodeur\n", + "x = Dense(128, activation='relu')(input_img)\n", + "encoded = Dense(latent_dim, activation='linear')(x)\n", + "\n", + "# Définition d'un decodeur\n", + "decoder_input = Input(shape=(latent_dim,))\n", + "x = Dense(128, activation='relu')(decoder_input)\n", + "decoded = Dense(784, activation='sigmoid')(x)\n", + "\n", + "# Construction d'un modèle séparé pour pouvoir accéder aux décodeur et encodeur\n", + "encoder = Model(input_img, encoded)\n", + "decoder = Model(decoder_input, decoded)\n", + "\n", + "# Construction du modèle de l'auto-encodeur\n", + "encoded = encoder(input_img)\n", + "decoded = decoder(encoded)\n", + "autoencoder = Model(input_img, decoded)\n", + "\n", + "autoencoder.compile(optimizer='Adam', loss='SparseCategoricalCrossentropy')\n", + "autoencoder.summary()\n", + "print(encoder.summary())\n", + "print(decoder.summary())" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "id": "jwYr0GHCSlIq" + }, + "outputs": [], + "source": [ + "from keras.datasets import mnist\n", + "import numpy as np\n", + "\n", + "# Chargement et normalisation (entre 0 et 1) des données de la base de données MNIST\n", + "(x_train, _), (x_test, _) = mnist.load_data()\n", + "\n", + "x_train = x_train.astype('float32') / 255.\n", + "x_test = x_test.astype('float32') / 255.\n", + "\n", + "# Vectorisation des images d'entrée en vecteurs de dimension 784\n", + "x_train = np.reshape(x_train, (len(x_train), 784))\n", + "x_test = np.reshape(x_test, (len(x_test), 784))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "id": "eKPiA41bSvxC" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/50\n", + "469/469 [==============================] - 3s 6ms/step - loss: 0.0784 - val_loss: 0.0781\n", + "Epoch 2/50\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0783 - val_loss: 0.0780\n", + "Epoch 3/50\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0783 - val_loss: 0.0781\n", + "Epoch 4/50\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0783 - val_loss: 0.0780\n", + "Epoch 5/50\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0782 - val_loss: 0.0779\n", + "Epoch 6/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0782 - val_loss: 0.0780\n", + "Epoch 7/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0781 - val_loss: 0.0779\n", + "Epoch 8/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0781 - val_loss: 0.0778\n", + "Epoch 9/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0781 - val_loss: 0.0778\n", + "Epoch 10/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0780 - val_loss: 0.0778\n", + "Epoch 11/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0780 - val_loss: 0.0777\n", + "Epoch 12/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0780 - val_loss: 0.0777\n", + "Epoch 13/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0779 - val_loss: 0.0777\n", + "Epoch 14/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0779 - val_loss: 0.0777\n", + "Epoch 15/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0779 - val_loss: 0.0775\n", + "Epoch 16/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0778 - val_loss: 0.0775\n", + "Epoch 17/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0778 - val_loss: 0.0776\n", + "Epoch 18/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0778 - val_loss: 0.0776\n", + "Epoch 19/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0777 - val_loss: 0.0775\n", + "Epoch 20/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0777 - val_loss: 0.0775\n", + "Epoch 21/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0777 - val_loss: 0.0775\n", + "Epoch 22/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0776 - val_loss: 0.0775\n", + "Epoch 23/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0776 - val_loss: 0.0774\n", + "Epoch 24/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0776 - val_loss: 0.0774\n", + "Epoch 25/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0776 - val_loss: 0.0774\n", + "Epoch 26/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0775 - val_loss: 0.0774\n", + "Epoch 27/50\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0775 - val_loss: 0.0774\n", + "Epoch 28/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0775 - val_loss: 0.0773\n", + "Epoch 29/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0775 - val_loss: 0.0773\n", + "Epoch 30/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0774 - val_loss: 0.0773\n", + "Epoch 31/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0774 - val_loss: 0.0772\n", + "Epoch 32/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0774 - val_loss: 0.0774\n", + "Epoch 33/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0774 - val_loss: 0.0773\n", + "Epoch 34/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0774 - val_loss: 0.0772\n", + "Epoch 35/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0774 - val_loss: 0.0772\n", + "Epoch 36/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0773 - val_loss: 0.0774\n", + "Epoch 37/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0773 - val_loss: 0.0771\n", + "Epoch 38/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0773 - val_loss: 0.0772\n", + "Epoch 39/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0773 - val_loss: 0.0772\n", + "Epoch 40/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0773 - val_loss: 0.0772\n", + "Epoch 41/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0773 - val_loss: 0.0771\n", + "Epoch 42/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0773 - val_loss: 0.0772\n", + "Epoch 43/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0772 - val_loss: 0.0771\n", + "Epoch 44/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0772 - val_loss: 0.0771\n", + "Epoch 45/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0772 - val_loss: 0.0770\n", + "Epoch 46/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0772 - val_loss: 0.0771\n", + "Epoch 47/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0772 - val_loss: 0.0771\n", + "Epoch 48/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0771 - val_loss: 0.0771\n", + "Epoch 49/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0771 - val_loss: 0.0771\n", + "Epoch 50/50\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0771 - val_loss: 0.0770\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Entraînement de l'auto-encodeur. On utilise ici les données de test \n", + "# pour surveiller l'évolution de l'erreur de reconstruction sur des données \n", + "# non utilisées pendant l'entraînement et ainsi détecter le sur-apprentissage.\n", + "autoencoder.fit(x_train, x_train,\n", + " epochs=50,\n", + " batch_size=128,\n", + " shuffle=True,\n", + " validation_data=(x_test, x_test))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ohexDvCYrahC" + }, + "source": [ + "Le code suivant affiche des exemples d'images de la base de test (1e ligne) et de leur reconstruction (2e ligne)." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "id": "2SC9R1TRTUgN" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Prédiction des données de test\n", + "decoded_imgs = autoencoder.predict(x_test)\n", + "\n", + "\n", + "n = 10\n", + "plt.figure(figsize=(20, 4))\n", + "for i in range(n):\n", + " # Affichage de l'image originale\n", + " ax = plt.subplot(2, n, i+1)\n", + " plt.imshow(x_test[i].reshape(28, 28))\n", + " plt.gray()\n", + " ax.get_xaxis().set_visible(False)\n", + " ax.get_yaxis().set_visible(False)\n", + "\n", + " # Affichage de l'image reconstruite par l'auto-encodeur\n", + " ax = plt.subplot(2, n, i+1 + n)\n", + " plt.imshow(decoded_imgs[i].reshape(28, 28))\n", + " plt.gray()\n", + " ax.get_xaxis().set_visible(False)\n", + " ax.get_yaxis().set_visible(False)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4oV4eKk4p4Eg" + }, + "source": [ + "# Travail à faire" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zjMnHWNtrgwZ" + }, + "source": [ + "Travail à faire\n", + "\n", + "1. Pour commencer, observez les résultats obtenus avec le code fourni. Les résultats semblent imparfaits, les images reconstruites sont bruitées. Modifiez le code fourni pour transformer le problème de régression en classification binaire. Les résultats devraient être bien meilleurs ! Conservez cette formulation (même si elle est non standard) pour la suite.\n", + "2. Avec la dimension d'espace latent qui vous est fournie, on observe une (relativement) faible erreur de reconstruction. Tracez une **courbe** (avec seulement quelques points) qui montre l'évolution de l'**erreur de reconstruction en fonction de la dimension de l'espace latent**. Quelle semble être la dimension minimale de l'espace latent qui permet encore d'observer une reconstruction raisonnable des données (avec le réseau qui vous est fourni) ?\n", + "3. Pour diminuer encore plus la dimension de l'espace latent, il est nécessaire d'augmenter la capacité des réseaux encodeur et décodeur. Cherchez à nouveau la dimension minimale de l'espace latent qui permet d'observer une bonne reconstruction des données, mais en augmentant à l'envi la capacité de votre auto-encodeur.\n", + "4. Écrivez une fonction qui, étant donné deux images de votre espace de test $I_1$ et $I_2$, réalise l'interpolation (avec, par exemple, 10 étapes) entre la représentation latente ($z_1 = $encoder($I_1$) et $z_2 = $encoder($I_2$)) de ces deux données, et génère les images $I_i$ correspondant aux représentations latentes intermédiaires $z_i$. En pseudo python, cela donne : \n", + "\n", + "```python\n", + "for i in range(10):\n", + " z_i = z1 + i*(z2-z1)/10\n", + " I_i = decoder(z_i)\n", + "```\n", + "Testez cette fonction avec un auto-encodeur avec une faible erreur de reconstruction, sur deux données présentant le même chiffre écrit différemment, puis deux chiffres différents.\n", + "5. Pour finir, le code qui vous est fourni dans la suite permet de télécharger et de préparer une [base de données de visages](http://vis-www.cs.umass.edu/lfw/). ATTENTION : ici les images sont de taille $32\\times32$, en couleur, et comportent donc 3 canaux (contrairement aux images de MNIST, qui n'en comptent qu'un). Par analogie avec la question précédente, on pourrait grâce à la représentation latente apprise par un auto-encodeur, réaliser un morphing entre deux visages. Essayez d'abord d'entraîner un auto-encodeur à obtenir une erreur de reconstruction faible. Qu'observe-t-on ?\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "469/469 [==============================] - 3s 6ms/step - loss: 0.2008 - val_loss: 0.1536\n", + "Epoch 2/10\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.1478 - val_loss: 0.1415\n", + "Epoch 3/10\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.1400 - val_loss: 0.1366\n", + "Epoch 4/10\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.1360 - val_loss: 0.1335\n", + "Epoch 5/10\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.1333 - val_loss: 0.1311\n", + "Epoch 6/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1312 - val_loss: 0.1292\n", + "Epoch 7/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1295 - val_loss: 0.1278\n", + "Epoch 8/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1282 - val_loss: 0.1269\n", + "Epoch 9/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1272 - val_loss: 0.1258\n", + "Epoch 10/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1263 - val_loss: 0.1252\n", + "Epoch 1/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1883 - val_loss: 0.1332\n", + "Epoch 2/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1244 - val_loss: 0.1169\n", + "Epoch 3/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1158 - val_loss: 0.1118\n", + "Epoch 4/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1117 - val_loss: 0.1087\n", + "Epoch 5/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1089 - val_loss: 0.1065\n", + "Epoch 6/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1069 - val_loss: 0.1049\n", + "Epoch 7/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1053 - val_loss: 0.1036\n", + "Epoch 8/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1040 - val_loss: 0.1023\n", + "Epoch 9/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1029 - val_loss: 0.1014\n", + "Epoch 10/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1020 - val_loss: 0.1008\n", + "Epoch 1/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1781 - val_loss: 0.1176\n", + "Epoch 2/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1092 - val_loss: 0.1010\n", + "Epoch 3/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0992 - val_loss: 0.0951\n", + "Epoch 4/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0944 - val_loss: 0.0917\n", + "Epoch 5/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0916 - val_loss: 0.0894\n", + "Epoch 6/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0895 - val_loss: 0.0878\n", + "Epoch 7/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0880 - val_loss: 0.0865\n", + "Epoch 8/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0868 - val_loss: 0.0854\n", + "Epoch 9/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0858 - val_loss: 0.0845\n", + "Epoch 10/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0850 - val_loss: 0.0840\n", + "Epoch 1/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1735 - val_loss: 0.1119\n", + "Epoch 2/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1029 - val_loss: 0.0943\n", + "Epoch 3/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0923 - val_loss: 0.0885\n", + "Epoch 4/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0872 - val_loss: 0.0844\n", + "Epoch 5/10\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0839 - val_loss: 0.0817\n", + "Epoch 6/10\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0818 - val_loss: 0.0799\n", + "Epoch 7/10\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0802 - val_loss: 0.0789\n", + "Epoch 8/10\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0789 - val_loss: 0.0774\n", + "Epoch 9/10\n", + "469/469 [==============================] - 3s 5ms/step - loss: 0.0777 - val_loss: 0.0766\n", + "Epoch 10/10\n", + "469/469 [==============================] - 3s 5ms/step - loss: 0.0768 - val_loss: 0.0757\n", + "Epoch 1/10\n", + "469/469 [==============================] - 3s 5ms/step - loss: 0.1649 - val_loss: 0.1054\n", + "Epoch 2/10\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0978 - val_loss: 0.0902\n", + "Epoch 3/10\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0876 - val_loss: 0.0835\n", + "Epoch 4/10\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0829 - val_loss: 0.0801\n", + "Epoch 5/10\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0799 - val_loss: 0.0779\n", + "Epoch 6/10\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0779 - val_loss: 0.0765\n", + "Epoch 7/10\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0763 - val_loss: 0.0751\n", + "Epoch 8/10\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0752 - val_loss: 0.0745\n", + "Epoch 9/10\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0743 - val_loss: 0.0734\n", + "Epoch 10/10\n", + "469/469 [==============================] - 2s 5ms/step - loss: 0.0734 - val_loss: 0.0726\n", + "Epoch 1/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1591 - val_loss: 0.1011\n", + "Epoch 2/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0938 - val_loss: 0.0874\n", + "Epoch 3/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0848 - val_loss: 0.0814\n", + "Epoch 4/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0804 - val_loss: 0.0779\n", + "Epoch 5/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0777 - val_loss: 0.0759\n", + "Epoch 6/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0758 - val_loss: 0.0743\n", + "Epoch 7/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0744 - val_loss: 0.0731\n", + "Epoch 8/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0732 - val_loss: 0.0721\n", + "Epoch 9/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0723 - val_loss: 0.0713\n", + "Epoch 10/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0716 - val_loss: 0.0710\n", + "Epoch 1/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.1573 - val_loss: 0.0999\n", + "Epoch 2/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0931 - val_loss: 0.0858\n", + "Epoch 3/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0840 - val_loss: 0.0804\n", + "Epoch 4/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0796 - val_loss: 0.0772\n", + "Epoch 5/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0767 - val_loss: 0.0748\n", + "Epoch 6/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0749 - val_loss: 0.0734\n", + "Epoch 7/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0735 - val_loss: 0.0724\n", + "Epoch 8/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0725 - val_loss: 0.0716\n", + "Epoch 9/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0717 - val_loss: 0.0711\n", + "Epoch 10/10\n", + "469/469 [==============================] - 2s 4ms/step - loss: 0.0711 - val_loss: 0.0704\n" + ] + } + ], + "source": [ + "from keras.layers import Input, Dense\n", + "from keras.models import Model\n", + "\n", + "# Dimension de l'entrée\n", + "input_img = Input(shape=(784,))\n", + "\n", + "errors = []\n", + "latent_dims = [8, 16, 32, 64, 128, 256, 512]\n", + "for latent_dim in latent_dims:\n", + " # Définition d'un encodeur\n", + " x = Dense(128, activation='relu')(input_img)\n", + " encoded = Dense(latent_dim, activation='linear')(x)\n", + "\n", + " # Définition d'un decodeur\n", + " decoder_input = Input(shape=(latent_dim,))\n", + " x = Dense(128, activation='relu')(decoder_input)\n", + " decoded = Dense(784, activation='sigmoid')(x)\n", + "\n", + " # Construction d'un modèle séparé pour pouvoir accéder aux décodeur et encodeur\n", + " encoder = Model(input_img, encoded)\n", + " decoder = Model(decoder_input, decoded)\n", + "\n", + " # Construction du modèle de l'auto-encodeur\n", + " encoded = encoder(input_img)\n", + " decoded = decoder(encoded)\n", + " autoencoder = Model(input_img, decoded)\n", + "\n", + " autoencoder.compile(optimizer='Adam', loss='bce')\n", + "\n", + " autoencoder.fit(\n", + " x_train, x_train,\n", + " epochs=10,\n", + " batch_size=128,\n", + " shuffle=True,\n", + " validation_data=(x_test, x_test)\n", + " )\n", + "\n", + " errors.append(autoencoder.history.history[\"val_loss\"][-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20, 10))\n", + "plt.plot(latent_dims, errors)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "from keras.datasets import mnist\n", + "import numpy as np\n", + "\n", + "# Chargement et normalisation (entre 0 et 1) des données de la base de données MNIST\n", + "(x_train, _), (x_test, _) = mnist.load_data()\n", + "\n", + "x_train = x_train.astype('float32') / 255.0\n", + "x_test = x_test.astype('float32') / 255.0" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"model_83\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " input_53 (InputLayer) [(None, 28, 28, 1)] 0 \n", + " \n", + " conv2d_37 (Conv2D) (None, 28, 28, 64) 640 \n", + " \n", + " conv2d_38 (Conv2D) (None, 28, 28, 64) 36928 \n", + " \n", + " max_pooling2d_8 (MaxPooling (None, 14, 14, 64) 0 \n", + " 2D) \n", + " \n", + " conv2d_39 (Conv2D) (None, 14, 14, 128) 73856 \n", + " \n", + " conv2d_40 (Conv2D) (None, 14, 14, 128) 147584 \n", + " \n", + " max_pooling2d_9 (MaxPooling (None, 7, 7, 128) 0 \n", + " 2D) \n", + " \n", + " flatten_2 (Flatten) (None, 6272) 0 \n", + " \n", + " dense_114 (Dense) (None, 5) 31365 \n", + " \n", + "=================================================================\n", + "Total params: 290,373\n", + "Trainable params: 290,373\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "None\n", + "Model: \"model_84\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " input_54 (InputLayer) [(None, 5)] 0 \n", + " \n", + " dense_115 (Dense) (None, 6272) 37632 \n", + " \n", + " reshape_2 (Reshape) (None, 7, 7, 128) 0 \n", + " \n", + " up_sampling2d_5 (UpSampling (None, 14, 14, 128) 0 \n", + " 2D) \n", + " \n", + " conv2d_41 (Conv2D) (None, 14, 14, 128) 147584 \n", + " \n", + " conv2d_42 (Conv2D) (None, 14, 14, 128) 147584 \n", + " \n", + " up_sampling2d_6 (UpSampling (None, 28, 28, 128) 0 \n", + " 2D) \n", + " \n", + " conv2d_43 (Conv2D) (None, 28, 28, 64) 32832 \n", + " \n", + " conv2d_44 (Conv2D) (None, 28, 28, 1) 577 \n", + " \n", + "=================================================================\n", + "Total params: 366,209\n", + "Trainable params: 366,209\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "None\n", + "Model: \"model_85\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " input_53 (InputLayer) [(None, 28, 28, 1)] 0 \n", + " \n", + " model_83 (Functional) (None, 5) 290373 \n", + " \n", + " model_84 (Functional) (None, 28, 28, 1) 366209 \n", + " \n", + "=================================================================\n", + "Total params: 656,582\n", + "Trainable params: 656,582\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "Epoch 1/10\n", + "116/469 [======>.......................] - ETA: 3:19 - loss: 0.2379" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/home/laurent/Documents/Cours/ENSEEIHT/S9 - IAM/IAM2022_TP_Autoencodeurs_Sujet.ipynb Cell 12\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 51\u001b[0m autoencoder\u001b[39m.\u001b[39msummary()\n\u001b[1;32m 53\u001b[0m \u001b[39m# Entraînement de l'auto-encodeur. On utilise ici les données de test \u001b[39;00m\n\u001b[1;32m 54\u001b[0m \u001b[39m# pour surveiller l'évolution de l'erreur de reconstruction sur des données \u001b[39;00m\n\u001b[1;32m 55\u001b[0m \u001b[39m# non utilisées pendant l'entraînement et ainsi détecter le sur-apprentissage.\u001b[39;00m\n\u001b[0;32m---> 56\u001b[0m autoencoder\u001b[39m.\u001b[39;49mfit(x_train, x_train,\n\u001b[1;32m 57\u001b[0m epochs\u001b[39m=\u001b[39;49m\u001b[39m10\u001b[39;49m,\n\u001b[1;32m 58\u001b[0m batch_size\u001b[39m=\u001b[39;49m\u001b[39m128\u001b[39;49m,\n\u001b[1;32m 59\u001b[0m shuffle\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m,\n\u001b[1;32m 60\u001b[0m validation_data\u001b[39m=\u001b[39;49m(x_test, x_test))\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/keras/utils/traceback_utils.py:64\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 62\u001b[0m filtered_tb \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m 63\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m---> 64\u001b[0m \u001b[39mreturn\u001b[39;00m fn(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 65\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e: \u001b[39m# pylint: disable=broad-except\u001b[39;00m\n\u001b[1;32m 66\u001b[0m filtered_tb \u001b[39m=\u001b[39m _process_traceback_frames(e\u001b[39m.\u001b[39m__traceback__)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/keras/engine/training.py:1384\u001b[0m, in \u001b[0;36mModel.fit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m 1377\u001b[0m \u001b[39mwith\u001b[39;00m tf\u001b[39m.\u001b[39mprofiler\u001b[39m.\u001b[39mexperimental\u001b[39m.\u001b[39mTrace(\n\u001b[1;32m 1378\u001b[0m \u001b[39m'\u001b[39m\u001b[39mtrain\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 1379\u001b[0m epoch_num\u001b[39m=\u001b[39mepoch,\n\u001b[1;32m 1380\u001b[0m step_num\u001b[39m=\u001b[39mstep,\n\u001b[1;32m 1381\u001b[0m batch_size\u001b[39m=\u001b[39mbatch_size,\n\u001b[1;32m 1382\u001b[0m _r\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m):\n\u001b[1;32m 1383\u001b[0m callbacks\u001b[39m.\u001b[39mon_train_batch_begin(step)\n\u001b[0;32m-> 1384\u001b[0m tmp_logs \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mtrain_function(iterator)\n\u001b[1;32m 1385\u001b[0m \u001b[39mif\u001b[39;00m data_handler\u001b[39m.\u001b[39mshould_sync:\n\u001b[1;32m 1386\u001b[0m context\u001b[39m.\u001b[39masync_wait()\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/util/traceback_utils.py:150\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 148\u001b[0m filtered_tb \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m 149\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 150\u001b[0m \u001b[39mreturn\u001b[39;00m fn(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 151\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n\u001b[1;32m 152\u001b[0m filtered_tb \u001b[39m=\u001b[39m _process_traceback_frames(e\u001b[39m.\u001b[39m__traceback__)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/def_function.py:915\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 912\u001b[0m compiler \u001b[39m=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mxla\u001b[39m\u001b[39m\"\u001b[39m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_jit_compile \u001b[39melse\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mnonXla\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 914\u001b[0m \u001b[39mwith\u001b[39;00m OptionalXlaContext(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_jit_compile):\n\u001b[0;32m--> 915\u001b[0m result \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_call(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwds)\n\u001b[1;32m 917\u001b[0m new_tracing_count \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mexperimental_get_tracing_count()\n\u001b[1;32m 918\u001b[0m without_tracing \u001b[39m=\u001b[39m (tracing_count \u001b[39m==\u001b[39m new_tracing_count)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/def_function.py:947\u001b[0m, in \u001b[0;36mFunction._call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 944\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock\u001b[39m.\u001b[39mrelease()\n\u001b[1;32m 945\u001b[0m \u001b[39m# In this case we have created variables on the first call, so we run the\u001b[39;00m\n\u001b[1;32m 946\u001b[0m \u001b[39m# defunned version which is guaranteed to never create variables.\u001b[39;00m\n\u001b[0;32m--> 947\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_stateless_fn(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwds) \u001b[39m# pylint: disable=not-callable\u001b[39;00m\n\u001b[1;32m 948\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_stateful_fn \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 949\u001b[0m \u001b[39m# Release the lock early so that multiple threads can perform the call\u001b[39;00m\n\u001b[1;32m 950\u001b[0m \u001b[39m# in parallel.\u001b[39;00m\n\u001b[1;32m 951\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock\u001b[39m.\u001b[39mrelease()\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/function.py:2956\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2953\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock:\n\u001b[1;32m 2954\u001b[0m (graph_function,\n\u001b[1;32m 2955\u001b[0m filtered_flat_args) \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_maybe_define_function(args, kwargs)\n\u001b[0;32m-> 2956\u001b[0m \u001b[39mreturn\u001b[39;00m graph_function\u001b[39m.\u001b[39;49m_call_flat(\n\u001b[1;32m 2957\u001b[0m filtered_flat_args, captured_inputs\u001b[39m=\u001b[39;49mgraph_function\u001b[39m.\u001b[39;49mcaptured_inputs)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/function.py:1853\u001b[0m, in \u001b[0;36mConcreteFunction._call_flat\u001b[0;34m(self, args, captured_inputs, cancellation_manager)\u001b[0m\n\u001b[1;32m 1849\u001b[0m possible_gradient_type \u001b[39m=\u001b[39m gradients_util\u001b[39m.\u001b[39mPossibleTapeGradientTypes(args)\n\u001b[1;32m 1850\u001b[0m \u001b[39mif\u001b[39;00m (possible_gradient_type \u001b[39m==\u001b[39m gradients_util\u001b[39m.\u001b[39mPOSSIBLE_GRADIENT_TYPES_NONE\n\u001b[1;32m 1851\u001b[0m \u001b[39mand\u001b[39;00m executing_eagerly):\n\u001b[1;32m 1852\u001b[0m \u001b[39m# No tape is watching; skip to running the function.\u001b[39;00m\n\u001b[0;32m-> 1853\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_build_call_outputs(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_inference_function\u001b[39m.\u001b[39;49mcall(\n\u001b[1;32m 1854\u001b[0m ctx, args, cancellation_manager\u001b[39m=\u001b[39;49mcancellation_manager))\n\u001b[1;32m 1855\u001b[0m forward_backward \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_select_forward_and_backward_functions(\n\u001b[1;32m 1856\u001b[0m args,\n\u001b[1;32m 1857\u001b[0m possible_gradient_type,\n\u001b[1;32m 1858\u001b[0m executing_eagerly)\n\u001b[1;32m 1859\u001b[0m forward_function, args_with_tangents \u001b[39m=\u001b[39m forward_backward\u001b[39m.\u001b[39mforward()\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/function.py:499\u001b[0m, in \u001b[0;36m_EagerDefinedFunction.call\u001b[0;34m(self, ctx, args, cancellation_manager)\u001b[0m\n\u001b[1;32m 497\u001b[0m \u001b[39mwith\u001b[39;00m _InterpolateFunctionError(\u001b[39mself\u001b[39m):\n\u001b[1;32m 498\u001b[0m \u001b[39mif\u001b[39;00m cancellation_manager \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 499\u001b[0m outputs \u001b[39m=\u001b[39m execute\u001b[39m.\u001b[39;49mexecute(\n\u001b[1;32m 500\u001b[0m \u001b[39mstr\u001b[39;49m(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msignature\u001b[39m.\u001b[39;49mname),\n\u001b[1;32m 501\u001b[0m num_outputs\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_num_outputs,\n\u001b[1;32m 502\u001b[0m inputs\u001b[39m=\u001b[39;49margs,\n\u001b[1;32m 503\u001b[0m attrs\u001b[39m=\u001b[39;49mattrs,\n\u001b[1;32m 504\u001b[0m ctx\u001b[39m=\u001b[39;49mctx)\n\u001b[1;32m 505\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 506\u001b[0m outputs \u001b[39m=\u001b[39m execute\u001b[39m.\u001b[39mexecute_with_cancellation(\n\u001b[1;32m 507\u001b[0m \u001b[39mstr\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39msignature\u001b[39m.\u001b[39mname),\n\u001b[1;32m 508\u001b[0m num_outputs\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_num_outputs,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 511\u001b[0m ctx\u001b[39m=\u001b[39mctx,\n\u001b[1;32m 512\u001b[0m cancellation_manager\u001b[39m=\u001b[39mcancellation_manager)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/execute.py:54\u001b[0m, in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m ctx\u001b[39m.\u001b[39mensure_initialized()\n\u001b[0;32m---> 54\u001b[0m tensors \u001b[39m=\u001b[39m pywrap_tfe\u001b[39m.\u001b[39;49mTFE_Py_Execute(ctx\u001b[39m.\u001b[39;49m_handle, device_name, op_name,\n\u001b[1;32m 55\u001b[0m inputs, attrs, num_outputs)\n\u001b[1;32m 56\u001b[0m \u001b[39mexcept\u001b[39;00m core\u001b[39m.\u001b[39m_NotOkStatusException \u001b[39mas\u001b[39;00m e:\n\u001b[1;32m 57\u001b[0m \u001b[39mif\u001b[39;00m name \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "from keras.layers import Input, Dense\n", + "from keras.models import Model\n", + "\n", + "import keras\n", + "from keras.layers import *\n", + "from keras import *\n", + "\n", + "# Dimension de l'entrée\n", + "input_img = Input(shape=(28, 28, 1))\n", + "latent_dim = 5\n", + "\n", + "# Définition d'un encodeur\n", + "x = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(input_img)\n", + "x = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(x)\n", + "x = MaxPooling2D(pool_size=(2, 2))(x)\n", + "\n", + "x = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(x)\n", + "x = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(x)\n", + "x = MaxPooling2D(pool_size=(2, 2))(x)\n", + "x = Flatten()(x)\n", + "\n", + "encoded = Dense(latent_dim, activation='linear')(x)\n", + "\n", + "# Définition d'un decodeur\n", + "decoder_input = Input(shape=(latent_dim,))\n", + "\n", + "x = Dense(7*7*128, activation='linear')(decoder_input)\n", + "x = Reshape((7,7,128))(x)\n", + "\n", + "x = UpSampling2D(size = (2,2))(x)\n", + "x = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(x)\n", + "x = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(x)\n", + "\n", + "x = UpSampling2D(size = (2,2))(x)\n", + "x = Conv2D(64, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(x)\n", + "decoded = Conv2D(1, 3, activation = 'sigmoid', padding = 'same', kernel_initializer = 'he_normal')(x)\n", + "\n", + "# Construction d'un modèle séparé pour pouvoir accéder aux décodeur et encodeur\n", + "encoder = Model(input_img, encoded)\n", + "print(encoder.summary())\n", + "\n", + "decoder = Model(decoder_input, decoded)\n", + "print(decoder.summary())\n", + "\n", + "# Construction du modèle de l'auto-encodeur\n", + "encoded = encoder(input_img)\n", + "decoded = decoder(encoded)\n", + "autoencoder = Model(input_img, decoded)\n", + "\n", + "autoencoder.compile(optimizer='Adam', loss='bce')\n", + "autoencoder.summary()\n", + "\n", + "# Entraînement de l'auto-encodeur. On utilise ici les données de test \n", + "# pour surveiller l'évolution de l'erreur de reconstruction sur des données \n", + "# non utilisées pendant l'entraînement et ainsi détecter le sur-apprentissage.\n", + "autoencoder.fit(x_train, x_train,\n", + " epochs=10,\n", + " batch_size=128,\n", + " shuffle=True,\n", + " validation_data=(x_test, x_test))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20, 10))\n", + "plt.plot(factors, errors)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B6dM--9H_wEM" + }, + "source": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "# Visages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Ot-zkfDBQUkl" + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import tarfile, tqdm, cv2, os\n", + "from sklearn.model_selection import train_test_split\n", + "import numpy as np\n", + "\n", + "# Télécharger les données de la base de données \"Labelled Faces in the Wild\"\n", + "!wget http://www.cs.columbia.edu/CAVE/databases/pubfig/download/lfw_attributes.txt\n", + "!wget http://vis-www.cs.umass.edu/lfw/lfw-deepfunneled.tgz\n", + "!wget http://vis-www.cs.umass.edu/lfw/lfw.tgz\n", + " \n", + "ATTRS_NAME = \"lfw_attributes.txt\"\n", + "IMAGES_NAME = \"lfw-deepfunneled.tgz\"\n", + "RAW_IMAGES_NAME = \"lfw.tgz\"\n", + "\n", + "def decode_image_from_raw_bytes(raw_bytes):\n", + " img = cv2.imdecode(np.asarray(bytearray(raw_bytes), dtype=np.uint8), 1)\n", + " img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + " return img\n", + "\n", + "def load_lfw_dataset(\n", + " use_raw=False,\n", + " dx=80, dy=80,\n", + " dimx=45, dimy=45):\n", + "\n", + " # Read attrs\n", + " df_attrs = pd.read_csv(ATTRS_NAME, sep='\\t', skiprows=1)\n", + " df_attrs = pd.DataFrame(df_attrs.iloc[:, :-1].values, columns=df_attrs.columns[1:])\n", + " imgs_with_attrs = set(map(tuple, df_attrs[[\"person\", \"imagenum\"]].values))\n", + "\n", + " # Read photos\n", + " all_photos = []\n", + " photo_ids = []\n", + "\n", + " # tqdm in used to show progress bar while reading the data in a notebook here, you can change\n", + " # tqdm_notebook to use it outside a notebook\n", + " with tarfile.open(RAW_IMAGES_NAME if use_raw else IMAGES_NAME) as f:\n", + " for m in tqdm.tqdm_notebook(f.getmembers()):\n", + " # Only process image files from the compressed data\n", + " if m.isfile() and m.name.endswith(\".jpg\"):\n", + " # Prepare image\n", + " img = decode_image_from_raw_bytes(f.extractfile(m).read())\n", + "\n", + " # Crop only faces and resize it\n", + " img = img[dy:-dy, dx:-dx]\n", + " img = cv2.resize(img, (dimx, dimy))\n", + "\n", + " # Parse person and append it to the collected data\n", + " fname = os.path.split(m.name)[-1]\n", + " fname_splitted = fname[:-4].replace('_', ' ').split()\n", + " person_id = ' '.join(fname_splitted[:-1])\n", + " photo_number = int(fname_splitted[-1])\n", + " if (person_id, photo_number) in imgs_with_attrs:\n", + " all_photos.append(img)\n", + " photo_ids.append({'person': person_id, 'imagenum': photo_number})\n", + "\n", + " photo_ids = pd.DataFrame(photo_ids)\n", + " all_photos = np.stack(all_photos).astype('uint8')\n", + "\n", + " # Preserve photo_ids order!\n", + " all_attrs = photo_ids.merge(df_attrs, on=('person', 'imagenum')).drop([\"person\", \"imagenum\"], axis=1)\n", + "\n", + " return all_photos, all_attrs\n", + "\n", + "# Prépare le dataset et le charge dans la variable X\n", + "X, attr = load_lfw_dataset(use_raw=True, dimx=32, dimy=32)\n", + "# Normalise les images\n", + "X = X/255\n", + "# Sépare les images en données d'entraînement et de test\n", + "X_train, X_test = train_test_split(X, test_size=0.1, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "kt5l_VB7pI5i" + }, + "outputs": [], + "source": [ + "n = 10\n", + "plt.figure(figsize=(20, 4))\n", + "for i in range(n):\n", + "\n", + "\n", + " ax = plt.subplot(1, n, i+1)\n", + " plt.imshow(X_train[i].reshape(32, 32, 3))\n", + " plt.gray()\n", + " ax.get_xaxis().set_visible(False)\n", + " ax.get_yaxis().set_visible(False)\n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [ + "B6dM--9H_wEM" + ], + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3.10.7 64-bit", + "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" + }, + "vscode": { + "interpreter": { + "hash": "767d51c1340bd893661ea55ea3124f6de3c7a262a8b4abca0554b478b1e2ff90" + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/IAM2022_TP_GAN_Sujet.ipynb b/IAM2022_TP_GAN_Sujet.ipynb new file mode 100644 index 0000000..00b8a3a --- /dev/null +++ b/IAM2022_TP_GAN_Sujet.ipynb @@ -0,0 +1,456 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "Ls4hgfTEHgGR" + }, + "source": [ + "# Réseaux Génératifs Antagonistes\n", + "\n", + "Dans ce TP nous allons mettre en place l'entraînement d'un réseau de neurone génératif, entraîné de manière antagoniste à l'aide d'un réseau discriminateur. \n", + "\n", + "
\n", + "
Schéma global de fonctionnement d'un GAN ([Goodfellow 2014])
\n", + "\n", + "Dans un premier temps, nous allons illustrer le fonctionnement du GAN sur l'exemple simple, canonique, de la base de données MNIST. \n", + "Votre objectif sera par la suite d'adapter cet exemple à la base de données *Labelled Faces in the Wild*, et éventuellement d'implémenter quelques astuces permettant d'améliorer l'entrainement.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "TRziuDJMInpM" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "from keras import layers\n", + "import numpy as np\n", + "import os\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IFNzLxouIfwy" + }, + "source": [ + "On commence par définir les réseaux discriminateur et générateur, en suivant les recommandations de DCGAN (activation *LeakyReLU*, *stride*, *Batch Normalization*, activation de sortie *tanh* pour le générateur)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "IfPhxKGLHfD-" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"discriminator\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " conv2d_3 (Conv2D) (None, 14, 14, 64) 640 \n", + " \n", + " batch_normalization_5 (Batc (None, 14, 14, 64) 256 \n", + " hNormalization) \n", + " \n", + " leaky_re_lu_5 (LeakyReLU) (None, 14, 14, 64) 0 \n", + " \n", + " conv2d_4 (Conv2D) (None, 7, 7, 128) 73856 \n", + " \n", + " batch_normalization_6 (Batc (None, 7, 7, 128) 512 \n", + " hNormalization) \n", + " \n", + " leaky_re_lu_6 (LeakyReLU) (None, 7, 7, 128) 0 \n", + " \n", + " global_max_pooling2d_1 (Glo (None, 128) 0 \n", + " balMaxPooling2D) \n", + " \n", + " dense_2 (Dense) (None, 1) 129 \n", + " \n", + "=================================================================\n", + "Total params: 75,393\n", + "Trainable params: 75,009\n", + "Non-trainable params: 384\n", + "_________________________________________________________________\n", + "Model: \"generator\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " dense_3 (Dense) (None, 6272) 809088 \n", + " \n", + " batch_normalization_7 (Batc (None, 6272) 25088 \n", + " hNormalization) \n", + " \n", + " leaky_re_lu_7 (LeakyReLU) (None, 6272) 0 \n", + " \n", + " reshape_1 (Reshape) (None, 7, 7, 128) 0 \n", + " \n", + " conv2d_transpose_2 (Conv2DT (None, 14, 14, 128) 262272 \n", + " ranspose) \n", + " \n", + " batch_normalization_8 (Batc (None, 14, 14, 128) 512 \n", + " hNormalization) \n", + " \n", + " leaky_re_lu_8 (LeakyReLU) (None, 14, 14, 128) 0 \n", + " \n", + " conv2d_transpose_3 (Conv2DT (None, 28, 28, 128) 262272 \n", + " ranspose) \n", + " \n", + " batch_normalization_9 (Batc (None, 28, 28, 128) 512 \n", + " hNormalization) \n", + " \n", + " leaky_re_lu_9 (LeakyReLU) (None, 28, 28, 128) 0 \n", + " \n", + " conv2d_5 (Conv2D) (None, 28, 28, 1) 6273 \n", + " \n", + "=================================================================\n", + "Total params: 1,366,017\n", + "Trainable params: 1,352,961\n", + "Non-trainable params: 13,056\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "latent_dim = 128\n", + "discriminator = keras.Sequential(\n", + " [\n", + " keras.Input(shape=(28, 28, 1)),\n", + " layers.Conv2D(64, (3, 3), strides=(2, 2), padding=\"same\"),\n", + " layers.BatchNormalization(momentum = 0.8),\n", + " layers.LeakyReLU(alpha=0.2),\n", + " layers.Conv2D(128, (3, 3), strides=(2, 2), padding=\"same\"),\n", + " layers.BatchNormalization(momentum = 0.8),\n", + " layers.LeakyReLU(alpha=0.2),\n", + " layers.GlobalMaxPooling2D(),\n", + " layers.Dense(1, activation=\"sigmoid\"),\n", + " ],\n", + " name=\"discriminator\",\n", + ")\n", + "discriminator.summary()\n", + "\n", + "generator = keras.Sequential(\n", + " [\n", + " keras.Input(shape=(latent_dim,)),\n", + " layers.Dense(7 * 7 * 128), \n", + " layers.BatchNormalization(momentum = 0.8),\n", + " layers.LeakyReLU(alpha=0.2),\n", + " layers.Reshape((7, 7, 128)),\n", + " layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding=\"same\"),\n", + " layers.BatchNormalization(momentum = 0.8),\n", + " layers.LeakyReLU(alpha=0.2),\n", + " layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding=\"same\"),\n", + " layers.BatchNormalization(momentum = 0.8),\n", + " layers.LeakyReLU(alpha=0.2),\n", + " layers.Conv2D(1, (7, 7), padding=\"same\", activation=\"tanh\"),\n", + " ],\n", + " name=\"generator\",\n", + ")\n", + "generator.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kZ0FTcu6yl56" + }, + "source": [ + "Le code suivant décrit ce qui se passe à chaque itération de l'algorithme, ce qui est également résumé dans le cours sur le slide suivant : \n", + "\n", + "
\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "_RnxhJX_KJxF" + }, + "outputs": [], + "source": [ + "# Instanciation de deux optimiseurs, l'un pour le discrimnateur et l'autre pour le générateur\n", + "d_optimizer = keras.optimizers.Adam(learning_rate=0.0008)\n", + "g_optimizer = keras.optimizers.Adam(learning_rate=0.0004)\n", + "\n", + "# Instanciation d'une fonction de coût entropie croisée\n", + "loss_fn = keras.losses.BinaryCrossentropy(from_logits=True)\n", + "\n", + "\n", + "# La fonction prend en entrée un mini-batch d'images réelles\n", + "@tf.function\n", + "def train_step(real_images):\n", + " batch_size = tf.shape(real_images)[0]\n", + "\n", + " # ENTRAINEMENT DU DISCRIMINATEUR\n", + " # Échantillonnage d’un mini-batch de bruit\n", + " random_latent_vectors = tf.random.normal(shape=(batch_size, latent_dim,))\n", + " # Création d'un mini-batch d'images générées à partir du bruit\n", + " generated_images = generator(random_latent_vectors)\n", + " # Échantillonnage d’un mini-batch de données combinant images générées et réelles\n", + " combined_images = tf.concat([generated_images, real_images], axis=0)\n", + "\n", + " # Création des labels associés au mini-batch de données créé précédemment\n", + " # Pour l'entraînement du discriminateur :\n", + " # - les données générées sont labellisées \"0\" \n", + " #  - les données réelles sont labellisées \"1\" \n", + " labels = tf.concat([tf.zeros((batch_size, 1)), tf.ones((batch_size, 1))], axis=0)\n", + "\n", + " # Entraînement du discriminateur\n", + " with tf.GradientTape() as tape:\n", + " # L'appel d'un modèle (ici discriminator) à l'intérieur de Tf.GradientTape\n", + " # permet de récupérer les gradients pour faire la mise à jour\n", + "\n", + " # Prédiction du discriminateur sur notre batch d'images réelles et générées\n", + " predictions = discriminator(combined_images)\n", + " # Calcul de la fonction de coût\n", + " d_loss = loss_fn(labels, predictions)\n", + "\n", + " # Récupération des gradients de la fonction de coût par rapport aux paramètres du discriminateur\n", + " grads = tape.gradient(d_loss, discriminator.trainable_weights)\n", + " # Mise à jour des paramètres par l'optimiseur grâce aux gradients de la fonction de coût\n", + " d_optimizer.apply_gradients(zip(grads, discriminator.trainable_weights))\n", + " ### NOTE : ON N'ENTRAINE PAS LE GENERATEUR A CE MOMENT !\n", + "\n", + " # ENTRAINEMENT DU GENERATEUR\n", + " # Échantillonnage d’un mini-batch de bruit\n", + " random_latent_vectors = tf.random.normal(shape=(batch_size, latent_dim,))\n", + " # Création des labels associés au mini-batch de données créé précédemment\n", + " # Pour l'entraînement du générateur :\n", + " # - les données générées sont labellisées ici \"1\" \n", + " misleading_labels = tf.ones((batch_size, 1))\n", + "\n", + " # Entraînement du générateur sans toucher aux paramètres du discriminateur !\n", + " with tf.GradientTape() as tape:\n", + " predictions = discriminator(generator(random_latent_vectors))\n", + " g_loss = loss_fn(misleading_labels, predictions)\n", + " \n", + " # Récupération des gradients de la fonction de coût par rapport aux paramètres du générateur\n", + " grads = tape.gradient(g_loss, generator.trainable_weights)\n", + " # Mise à jour des paramètres par l'optimiseur grâce aux gradients de la fonction de coût\n", + " g_optimizer.apply_gradients(zip(grads, generator.trainable_weights))\n", + "\n", + " return d_loss, g_loss, generated_images" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "all1LAF92h1u" + }, + "source": [ + "Il reste à écrire l'algorithme final qui va faire appel au code d'itération écrit précédemment" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "lQJWoazN2pwd" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Start epoch 0\n" + ] + }, + { + "ename": "TypeError", + "evalue": "in user code:\n\n File \"/tmp/ipykernel_11002/1607979120.py\", line 26, in train_step *\n labels = tf.concat(tf.zeros((batch_size, 1)), tf.ones((batch_size, 1)), axis=0)\n\n TypeError: Got multiple values for argument 'axis'\n", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/home/laurent/Documents/Cours/ENSEEIHT/S9 - IAM/IAM2022_TP_GAN_Sujet.ipynb Cell 8\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39m\\n\u001b[39;00m\u001b[39mStart epoch\u001b[39m\u001b[39m\"\u001b[39m, epoch)\n\u001b[1;32m 15\u001b[0m \u001b[39mfor\u001b[39;00m step, real_images \u001b[39min\u001b[39;00m \u001b[39menumerate\u001b[39m(dataset):\n\u001b[1;32m 16\u001b[0m \u001b[39m# Descente de gradient simultanée du discrimnateur et du générateur\u001b[39;00m\n\u001b[0;32m---> 17\u001b[0m d_loss, g_loss, generated_images \u001b[39m=\u001b[39m train_step(real_images)\n\u001b[1;32m 19\u001b[0m \u001b[39m# Affichage régulier d'images générées.\u001b[39;00m\n\u001b[1;32m 20\u001b[0m \u001b[39mif\u001b[39;00m step \u001b[39m%\u001b[39m \u001b[39m200\u001b[39m \u001b[39m==\u001b[39m \u001b[39m0\u001b[39m:\n\u001b[1;32m 21\u001b[0m \u001b[39m# Métriques\u001b[39;00m\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/util/traceback_utils.py:153\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 151\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n\u001b[1;32m 152\u001b[0m filtered_tb \u001b[39m=\u001b[39m _process_traceback_frames(e\u001b[39m.\u001b[39m__traceback__)\n\u001b[0;32m--> 153\u001b[0m \u001b[39mraise\u001b[39;00m e\u001b[39m.\u001b[39mwith_traceback(filtered_tb) \u001b[39mfrom\u001b[39;00m \u001b[39mNone\u001b[39m\n\u001b[1;32m 154\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[1;32m 155\u001b[0m \u001b[39mdel\u001b[39;00m filtered_tb\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/framework/func_graph.py:1147\u001b[0m, in \u001b[0;36mfunc_graph_from_py_func..autograph_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 1145\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e: \u001b[39m# pylint:disable=broad-except\u001b[39;00m\n\u001b[1;32m 1146\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mhasattr\u001b[39m(e, \u001b[39m\"\u001b[39m\u001b[39mag_error_metadata\u001b[39m\u001b[39m\"\u001b[39m):\n\u001b[0;32m-> 1147\u001b[0m \u001b[39mraise\u001b[39;00m e\u001b[39m.\u001b[39mag_error_metadata\u001b[39m.\u001b[39mto_exception(e)\n\u001b[1;32m 1148\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 1149\u001b[0m \u001b[39mraise\u001b[39;00m\n", + "\u001b[0;31mTypeError\u001b[0m: in user code:\n\n File \"/tmp/ipykernel_11002/1607979120.py\", line 26, in train_step *\n labels = tf.concat(tf.zeros((batch_size, 1)), tf.ones((batch_size, 1)), axis=0)\n\n TypeError: Got multiple values for argument 'axis'\n" + ] + } + ], + "source": [ + "# Préparation de la base de données : on utilise toutes les images (entraînement + test) de MNIST\n", + "batch_size = 32\n", + "(x_train, _), (x_test, _) = keras.datasets.mnist.load_data()\n", + "all_digits = np.concatenate([x_train, x_test])\n", + "all_digits = (all_digits.astype(\"float32\")-127.5) / 127.5 # Images normalisées\n", + "all_digits = np.reshape(all_digits, (-1, 28, 28, 1))\n", + "dataset = tf.data.Dataset.from_tensor_slices(all_digits)\n", + "dataset = dataset.shuffle(buffer_size=1024).batch(batch_size)\n", + "\n", + "epochs = 20 # Une 20aine d'epochs est nécessaire pour voir des chiffres qui semblent réalistes\n", + "\n", + "for epoch in range(epochs):\n", + " print(\"\\nStart epoch\", epoch)\n", + "\n", + " for step, real_images in enumerate(dataset):\n", + " # Descente de gradient simultanée du discrimnateur et du générateur\n", + " d_loss, g_loss, generated_images = train_step(real_images)\n", + "\n", + " # Affichage régulier d'images générées.\n", + " if step % 200 == 0:\n", + " # Métriques\n", + " print(\"Perte du discriminateur à l'étape %d: %.2f\" % (step, d_loss))\n", + " print(\"Perte du générateur à l'étape %d: %.2f\" % (step, g_loss))\n", + "\n", + " plt.figure(figsize=(20, 4))\n", + " for i in range(10):\n", + " plt.subplot(1,10, i+1)\n", + " plt.imshow(generated_images[i, :, :, 0]*128+128, cmap='gray')\n", + " \n", + " plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kwIc9354oNIV" + }, + "source": [ + "# Travail à faire :\n", + "\n", + "Prenez le temps de lire, de comprendre et de compléter le code qui vous est fourni. Observez attentivement l'évolution des métriques ainsi que les images générées au cours de l'entraînement. L'objectif de ce TP est d'abord de vous fournir un exemple de code implémentant les GANs, mais surtout de vous faire sentir la difficulté d'entraîner ces modèles.\n", + "\n", + "Dans la suite du TP, nous vous fournissons ci-dessous un code de chargement de la base de données de visages *Labelled Faces in the Wild*. Votre objectif est donc d'adapter le code précédent pour générer non plus des chiffres mais des visages.\n", + "\n", + "Quelques précisions importantes, et indications : \n", + "\n", + "\n", + "* MNIST est une base de données d'images noir et blanc de dimension 28 $\\times$ 28, LFW est une base de données d'images couleur de dimension 32 $\\times$ 32 $\\times$ 3\n", + "* La diversité des visages est bien plus grande que celle des chiffres ; votre générateur doit donc être un peu plus complexe que celui utilisé ici (plus de couches, et/ou plus de filtres par exemple) \n", + "* Pour faire fonctionner ce second exemple, il pourrait être nécessaire de modifier quelques hyperparamètres (dimension de l'espace latent, taux d'apprentissage des générateur et discriminateur, etc.)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ohexDvCYrahC" + }, + "source": [ + "Le code suivant télécharge et prépare les données de la base LFW." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Ot-zkfDBQUkl" + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import tarfile, tqdm, cv2, os\n", + "from sklearn.model_selection import train_test_split\n", + "import numpy as np\n", + "\n", + "# Télécharger les données de la base de données \"Labelled Faces in the Wild\"\n", + "!wget http://www.cs.columbia.edu/CAVE/databases/pubfig/download/lfw_attributes.txt\n", + "!wget http://vis-www.cs.umass.edu/lfw/lfw-deepfunneled.tgz\n", + "!wget http://vis-www.cs.umass.edu/lfw/lfw.tgz\n", + " \n", + "ATTRS_NAME = \"lfw_attributes.txt\"\n", + "IMAGES_NAME = \"lfw-deepfunneled.tgz\"\n", + "RAW_IMAGES_NAME = \"lfw.tgz\"\n", + "\n", + "def decode_image_from_raw_bytes(raw_bytes):\n", + " img = cv2.imdecode(np.asarray(bytearray(raw_bytes), dtype=np.uint8), 1)\n", + " img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + " return img\n", + "\n", + "def load_lfw_dataset(\n", + " use_raw=False,\n", + " dx=80, dy=80,\n", + " dimx=45, dimy=45):\n", + "\n", + " # Read attrs\n", + " df_attrs = pd.read_csv(ATTRS_NAME, sep='\\t', skiprows=1)\n", + " df_attrs = pd.DataFrame(df_attrs.iloc[:, :-1].values, columns=df_attrs.columns[1:])\n", + " imgs_with_attrs = set(map(tuple, df_attrs[[\"person\", \"imagenum\"]].values))\n", + "\n", + " # Read photos\n", + " all_photos = []\n", + " photo_ids = []\n", + "\n", + " # tqdm in used to show progress bar while reading the data in a notebook here, you can change\n", + " # tqdm_notebook to use it outside a notebook\n", + " with tarfile.open(RAW_IMAGES_NAME if use_raw else IMAGES_NAME) as f:\n", + " for m in tqdm.tqdm_notebook(f.getmembers()):\n", + " # Only process image files from the compressed data\n", + " if m.isfile() and m.name.endswith(\".jpg\"):\n", + " # Prepare image\n", + " img = decode_image_from_raw_bytes(f.extractfile(m).read())\n", + "\n", + " # Crop only faces and resize it\n", + " img = img[dy:-dy, dx:-dx]\n", + " img = cv2.resize(img, (dimx, dimy))\n", + "\n", + " # Parse person and append it to the collected data\n", + " fname = os.path.split(m.name)[-1]\n", + " fname_splitted = fname[:-4].replace('_', ' ').split()\n", + " person_id = ' '.join(fname_splitted[:-1])\n", + " photo_number = int(fname_splitted[-1])\n", + " if (person_id, photo_number) in imgs_with_attrs:\n", + " all_photos.append(img)\n", + " photo_ids.append({'person': person_id, 'imagenum': photo_number})\n", + "\n", + " photo_ids = pd.DataFrame(photo_ids)\n", + " all_photos = np.stack(all_photos).astype('uint8')\n", + "\n", + " # Preserve photo_ids order!\n", + " all_attrs = photo_ids.merge(df_attrs, on=('person', 'imagenum')).drop([\"person\", \"imagenum\"], axis=1)\n", + "\n", + " return all_photos, all_attrs\n", + "\n", + "# Prépare le dataset et le charge dans la variable X\n", + "X, attr = load_lfw_dataset(use_raw=True, dimx=32, dimy=32)\n", + "# Normalise les images\n", + "X = (X.astype(\"float32\")-127.5)/127.5\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3.10.8 64-bit", + "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" + }, + "vscode": { + "interpreter": { + "hash": "767d51c1340bd893661ea55ea3124f6de3c7a262a8b4abca0554b478b1e2ff90" + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/IAM_2022_Classification_Audio_Sujet_totally_not_a_virus.ipynb b/IAM_2022_Classification_Audio_Sujet_totally_not_a_virus.ipynb new file mode 100644 index 0000000..f1e686c --- /dev/null +++ b/IAM_2022_Classification_Audio_Sujet_totally_not_a_virus.ipynb @@ -0,0 +1,3866 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "XMMppWbnG3dN" + }, + "source": [ + "## Classification d'extraits sonores\n", + "\n", + "L'objectif de ce TP est de manipuler des données audio, sous plusieurs formes. Nous travaillerons sur une base de données extraite de [VoxLingua](http://bark.phon.ioc.ee/voxlingua107/). Le problème que nous chercherons à résoudre est celui de la **reconnaissance du langage parlé**. Pour simplifier le problème (et le rendre traitable dans le temps du TP), nous nous limiterons à seulement 7 langues, toutes d'origine latine : le français, l'espagnol, le catalan, l'occitan, le portugais, l'italien, et le roumain.\n", + "\n", + "La base de données sur laquelle nous travaillerons contient 200 extraits audio par langue dans la base d'apprentissage, et 30 par langue dans la base de test. Elle vous permettra de prototyper rapidemet vos réseaux, mais induira très certainement **un fort surapprentissage**. \n", + "\n", + "Le traitement du signal audio par apprentissage profond est un vaste domaine, pour lequel il existe de multiples façons de traiter les problèmes. Nous en verrons aujourd'hui 3, qui seront complétées dans quelques semaines par les *transformers*. \n", + "\n", + "Commençons par télécharger les données :\n" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "id": "dYm7kc44QypI" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fatal: destination path 'spokenlanguage' already exists and is not an empty directory.\n" + ] + } + ], + "source": [ + "!git clone https://github.com/axelcarlier/spokenlanguage.git" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ELdFUUV3MHzl" + }, + "source": [ + "Les données sont chargées dans des variables *x_train*, *x_test*, *y_train* et *y_test*. " + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "id": "B_IqI8frYS7l" + }, + "outputs": [], + "source": [ + "import os\n", + "from scipy.io import wavfile\n", + "import numpy as np\n", + "\n", + "languages = ['ca', 'es', 'fr', 'it', 'oc', 'pt', 'ro']\n", + "nb_images_train = 1400\n", + "nb_images_test = 210\n", + "sr = 16000\n", + "\n", + "x_train = np.zeros((nb_images_train, 5*sr), dtype='float')\n", + "y_train = np.zeros((nb_images_train, len(languages)), dtype='float')\n", + "x_test = np.zeros((nb_images_test, 5*sr), dtype='float')\n", + "y_test = np.zeros((nb_images_test, len(languages)), dtype='float')\n", + "\n", + "index_train = 0\n", + "index_test = 0\n", + "for lang in languages:\n", + "\n", + " lang_index = languages.index(lang)\n", + " \n", + "\n", + " for file in os.listdir('spokenlanguage/Train/' + lang + '/'):\n", + " samplerate, data = wavfile.read('spokenlanguage/Train/' + lang + '/' + file)\n", + "\n", + " x_train[index_train, :min(len(data), 5*16000)] = data[:min(len(data), 5*16000)]\n", + " y_train[index_train, lang_index] = 1\n", + " index_train = index_train + 1\n", + "\n", + " for file in os.listdir('spokenlanguage/Test/' + lang + '/'):\n", + " samplerate, data = wavfile.read('spokenlanguage/Test/' + lang + '/' + file)\n", + "\n", + " x_test[index_test, :min(len(data), 5*16000)] = data[:min(len(data), 5*16000)]\n", + " y_test[index_test, lang_index] = 1\n", + " index_test = index_test + 1\n", + "\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "M33prjhqSmOU" + }, + "source": [ + "Prenez le temps de regarder leur format. Les extraits sont coupés après 5 secondes, et sont complétés avec des '0' (*zero-padding*) lorsqu'ils sont trop courts. Chaque extrait a une fréquence d'échantillonnage de 16000/sec, et chaque donnée est donc réduite (ou étendue) à 80000 échantillons." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "id": "5GosCvz1JYvW" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAEICAYAAABMGMOEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAxPklEQVR4nO3dd5wU9fkH8M/DHRydo4nA0ZuC0jwRpGgUKWLEHkx+ipUkYkETDUYTVGIklpiQGBWVBE0EuyBFRIqiCHj0DsdxyFGkHx2ufH9/7Owxu7ezO7s7de/zfr3udbuzs7PP7e7NM98uSikQERHFUsntAIiIyB+YMIiIyBQmDCIiMoUJg4iITGHCICIiU5gwiIjIFCYMIgeISAcRWSkiR0XkQbfjIUpEutsBEFUQjwGYr5Tq6nYgRIliCYPIGS0ArIv0gIikORwLUUKEI72J7CUi8wBcBqAIQDGAaQAKEUgilwEYqpT60r0IicxhCYPIZkqpKwAsBHC/UqomgDMAfg7gWQC1AHzjYnhEprENg8gdU5VS32q3T7kaCZFJLGEQuWOH2wEQxYsJg8gdbDwk32HCICIiU5gwiIjIFHarJSIiU1jCICIiU5gwiIjIFCYMIiIyhQmDiIhMSdmR3g0aNFAtW7Z0OwwiIl9ZtmzZfqVUw0iPpWzCaNmyJXJyctwOg4jIV0Rku9FjrJIiIiJTmDCIiMgUJgwiIjKFCYOIiExhwiAiIlOYMIiIyBQmDCIiMoUJwwcKTxZh2qpdbodBRBVcyg7cSyW/eX8lvtywFx0b10bbc2q6HQ4RVVAsYfjArsOnAACnikpcjoSIKjImDCIiMoUJg4iITGHCICIiU5gwiIjIFCYMIiIyhQmDiIhMYcIgIiJTmDCIiMgUJgwfKTxZ5HYIRFSBMWH4QEmpAgAMn7jU5UiIqCJjwvCBUhVIGMVa4iAicgMTBhERmcKEQUREpjBh+AAroojIC5gwiIjIFCYM8rV2T8zEnf+2tveYUgrLfzgEpVi2I9JjwiBfKypRmL9pn6XH/HTlTtzwr0X4bPVuS49L5HdMGORbdpUA8vYdBwDk7z9uy/GJ/IoJg3zrg2UFbodAVKEwYZBv7Tp80u0QiCoUJgwiIjKFCcMHxO0AiIjAhOELwoxBRB5gScIQkYkisldE1uq21ROROSKyRftdV9suIjJeRHJFZLWIdNc9Z7i2/xYRGa7bfpGIrNGeM14kdU6huwtPls1GS0TkZVaVMP4DYFDYttEA5iql2gGYq90HgMEA2mk/IwC8CgQSDIAxAC4B0APAmGCS0fa5V/e88NfypPW7jqA0SjJ4ZX4uej03D8/O2OBgVKnD7nF1HLdHFMqShKGU+hrAwbDNQwFM0m5PAnCdbvvbKmAxgEwRaQxgIIA5SqmDSqlDAOYAGKQ9VlsptVgFOt6/rTuWZy3/4RCuHr8Qr3+dZ7jPC7M3AQC+WL/HqbAoDi9/udntEIg8xc42jEZKqeBQ2T0AGmm3mwLYoduvQNsWbXtBhO3liMgIEckRkZx9+6wd/RuvnYcCXT7X7ipM+libfzyW9DHIPJYsiCJzpNFbKxnY/m+olJqglMpWSmU3bNjQ7pezTMEhjidIROq0ZBH5g50J40etOgna773a9p0Amun2y9K2RdueFWE7ERE5yM6EMQ1AsKfTcABTddtv13pL9QRQqFVdzQYwQETqao3dAwDM1h47IiI9td5Rt+uORUREDkm34iAiMhnA5QAaiEgBAr2dxgF4X0TuBrAdwC3a7jMBXA0gF8AJAHcCgFLqoIiMBfC9tt8zSqlgQ/p9CPTEqgZglvZDVObAsdOoXzPDkmPN37Q39k5EFZAlCUMpdavBQ1dG2FcBGGlwnIkAJkbYngPggmRidA0bUG2jb5wusailWimFdbuOWHIsolTDkd42YYOsP+04yA4IREaYMIh0FIuERIaYMGwyf6O740CIiKzGhGGTj5bbs7iP39aZXrrtIH44cMKWY+ur/YRz+hLZjgnDbhafx95ZvN3aA9rslte/Q78X5rsdBhFZgAnDbhYXCDbsPmrtAVNE3j5rpk8JL8AdOHbakuMSpQImDBsUlZS6HYLnbPnxKIotfl/0J/db31hs6bHjsSh3P976Zptrr2+3whNF/E4TACYMWxw+UeR2CJ5z1ctf48Uv7Jv91c0lRX7+5hKMnb7evQBspJRCl2e+wKMfrHI7FPIAJgybHThurkpj9rrUn+L8w2X2dASwkhfGzxSVlOKR91dix0F7OgvEI1iKm7pql7uBkCcwYdhscV74MiGR7T6c+gPG9h87ja0WtTWkssV5B/Dx8p3o+zw7C5C3MGGQo348csrtEIgoQUwYPjN56Q9uh+AZdlQfhfeScnvUy7RVu7B0m7lSqh027w30yvPZ8B+yiSWTD1IoTi/hDCdOYm6fKB+cvAIAkD9uiCuv/8C7K1x5XfImljCIovDbyHoiOzFh2GDf0fgHe/G0REGc5oS8ignDBnf/J8ftEMgih09yTA1REBOGDfawJ5BvhTek/+q/yxyPwarFoIisxoThQ6xXD8i1YUxH+FvrxuC54ROXOv6aRvhNIz0mDB9aVVDodggJi1U/f7q4BCUm5/mYsXq3FSFFVdFzMy9OSI8Jw4dOFZW4HYJtOjz5OW57a0lCz73trSU4ePwMeo+bh017ys/qW3iiCMdPF8d1zFKeMInKMGF4REU5L+00MQXKoq0HEjr2wi370X3sHOw8fBKvfbW13ONdnvkCff4yL6Fju23Z9kOmS15m9Xt+Pu77n/NtNORfTBg+tKfQv43qv3V51tNDcc4kHM8p2s4R2Te+ugivzM+19Jg/HDyBmWtSf9JLsg4Thg+Nem+l2yFUGFXT00zve8vr39kYCbD5R+cXz6ogBV8yiQmDKIqTKdxeZAozBukwYVBK+mTFTrdDSEjuXuNShHhhsQ6Lbdh9BJ+vZbWYX3DyQY/gOhEEAFOW7nA7hBD5B47bevzBf18YeB2XJlek+LCE4RH/WxLftOWp3LXWbn5Nzt8l2HssGW4ufUvew4ThU+f94XO3Q4hpwaa9lh5v675jWPHDoYSeO2lRftntqXFWV32ywhtLy+4/Fv+klkaMLjjOFJdi0qL8iF147Rwo6UaDPsWPCcPHWo6egZajZ6CopNTtUCIyqpv+zfurcOJMfAPoAODKl77C9f9aZHp//Sjl977XVfXE2Rbw8HurLD1Ze8GzMzZE3P7aV1sxZto6fJBTvmrM6m69ek98ssa2Y5N1mDA8JNGBWcdOlT/5LtyyD28uzINSynPTO3y0vCD0BG6Taat2RdweLV0YvVPxfjbjZm1E97Fz4nqOGaUW1RHtNhjLU6jNznsszhHxVDEwYXiIlVdZt721FH+asQGtHp+JVo/PtOy4VnGiv8+2/WcbbPWn2UoO9DZ67autOHj8TNzPixWanVf5bvLYNQ0ZYMLwkCkRrrr3Ho09qnvBZmvbCqwS7eT31Gfroz533sYfk359o5NQpShxJZtK7O6M8NXmfZYcx2s9dLe7MCswxc/2hCEi+SKyRkRWikiOtq2eiMwRkS3a77radhGR8SKSKyKrRaS77jjDtf23iMhwu+PW2114Eoty94dsm756F/K1K1ilFBbl7rel6mfbvtjdGl+cvdny13XbXf/JwRYLG0L158dETpZKAYdMlBj+u3h7/Ad3wWKDHldnio3bw+xMMomsUknOc6qE8ROlVFelVLZ2fzSAuUqpdgDmavcBYDCAdtrPCACvAoEEA2AMgEsA9AAwJphknDDgr1/j52+GzqB6/7srMOBvXwMAJi/dgZ+/uQSfrd6NC5+abelrV+RujXf8+3vLjqV/GxMZANfzubnoNnYOdhdGnzzR6gkCw1lVnXbUoI3iHS3hGbVxUMXmVpXUUACTtNuTAFyn2/62ClgMIFNEGgMYCGCOUuqgUuoQgDkABjkVbPg/1y5txtXg1dj2g4FSwM5DJ3E0QgP0krzE+8+v2BG7G+nOwyex4+AJtPn9TDw3K3LvF6dt3HMEk2MMQluwaS9ajp6Bb7XS24bdR0IeP3Iq8kSBU1cmN4o7mXPuuFkboz6eZ6JEmBSHqpKOGrz3VkqkjYfc5UTCUAC+EJFlIjJC29ZIKRXs1L0HQCPtdlMA+rNMgbbNaLsrHvtwdVz7P55EY3ZJibkr1htfXYSSUoXXv8qL+LjTRf5Bf1sYc5/ffhB4H7/cEGivmLUmtJ+/0bnxoSkrkwkt6iJOsd7tqSt3RW1HeC9Cd1QrOdX0MG/jvnLfGau/Q4l0rSZ3OZEw+iiluiNQ3TRSRPrpH1SBin9LyvEiMkJEckQkZ98+axoHI4l3UZ28fccTHnBmtoYj1jiB+RYPorPCoROBK8zgCfyTsJLDkQiltSAzS6cavXU7DyfXwJrIEqprCgox9J/f4OSZ5BrFnWqs3n/sNH7x5uKQbXtjJIyTZ0rKSt+UmmxPGEqpndrvvQA+QaAN4ketqgna7+DZbCeAZrqnZ2nbjLaHv9YEpVS2Uiq7YcOGVv8pxkyc1BOd9dRscvJjW0d4ff+Og+ZPNsFkY5a+Af2/i+ObhiUZe4+cwj/nbcHTn63DqoJCrNkZWF53056jaPP7mSg45N3eQZt/jG8KlfP/+DkuHTcv4eosfY/A7QeOY+8RtqN4ja0JQ0RqiEit4G0AAwCsBTANQLCn03AAU7Xb0wDcrvWW6gmgUKu6mg1ggIjU1Rq7B2jbXGG0IpwdV38+zAOYsz6+LrETv92G5QYlsL/O2WzYlhGP4rDkFK03kJUemLwCL36xGTnbA3/f+l2BhDF56Q8oKVX4Yl3oexWrQd6JMSTJSrQUNUpX1XjZCwvQ489zTT0vf/9xzN/ovRJ0KrK7hNEIwDcisgrAUgAzlFKfAxgH4CoR2QKgv3YfAGYCyAOQC+ANAPcBgFLqIICxAL7Xfp7RtvlHomd+q7rqOph57n07J+7nvPF15LaX8XO3YMj4heVGOEdrhygT5b177MPIK/+ZPR3n7zfXuB3ekB8cf5IX7JJt8vWCfJAvYv5NhSeKMPJ/y8tGlQclujTv5S8uwJ3/sa5HHRmzdXpzpVQegC4Rth8AcGWE7QrASINjTQQw0eoYk7Vyx2FbF9lJ5Dy/pqDQ8jjsFq3qbcfBk3jiU2vnGjJquDb7fn+6cidG9W8fc78ig04LX0d4/ete+RYrdxw2GYF/vfVNHmas2Y0Za8pPZri78CQa16kW9fkXjJmN23q1wO8GnWdXiGSA62Ek6bpXvrX1+PE2sAPAT//5jQ2RxHb8dDE6jUmspnD2uujVWO/nhM4Ym+yVttG76vQkg2Onr0edapVx00VZppLFt7nWT3G+pqAQF2bVsex4x6PMQ3WqqATrw0pder2emxfz+MdOF+PVBVuZMFzAqUEsNHeD8UnP7RqpNxZGrvKxkp/61Ru9r3dbXLVRXBq7reS3H6zC4iTG6iRr/3Frk+Q9UaokH3l/Jb7cwPYGv2LCiOLwiTOmum8GfZ9vvuusmTmiAOt6P23Z689Fg+xiNI1LtK68ev+YZzwJ4AFdKcWoSircBIM2HDvMjFAVZJaZHlDRBi8u255Y93LyBiaMKH7y4gL0fX6+JccKL6YvMlm1oFzqJ7Xr8MmoVQvhzhSXWvZeRRJ+gjdTJRXtnUv2XY02BcirC7ZGfe7aneXbmOY52Mtn3a7E27iM1tGwy82vmV//hOzHhBHFoRPWTY8w4p1lIfdNJwKX+tVeOm4ebnrtO9P7h/d4sZupXlLRuNhf2c5OEmYkU815PIEus6eLSwy7TccSXmp/XzejMwcJOo8JI05Tljo36AtIrNHbKuFdQqNJpprDjPAL+rz9savYosVvNPlePH7932UhS7+a5fbaD06//FPT1uOGfy0KWZ8kEYdPnMFjH52dluf3XKXPcUwYYUpLFY6cKjKs4x79sbNfUrdPLmY5XTd9/7srYu5jd+PqrLV7MGbaurift8flEczFYUv62rlWN3B2sGKypdDwakC//G+kEiaMMH+ZvRGdn/oCA17+2u1QAPhjyo/CE0XYtMe6tSusZNWSplZ6cHLsZGen8KrWD5cVGOxZntk1XyLNnfbuku348Yh1PbK898mmPiaMMNNXBa627O5VZPbqyK1G73jc9NoibLJwsSMrHTh+xnNrmvvZdJOlkVW6MSXBdz98LE2y+Lk6jwkjjNe+hG6Hs8DELLde7rI7fu6WuK6gKwKj79RLX2yy5fVWJznzQDK9ushaTBgO8uP8/3f5fI6e4tJSTyc0NxiVWqONLXHTkPHuzFxA5TFhOCiRkdBeK/H4kdPtGG53m43Jhrcj2VUQE+FmD8KKigkjzK4oaxl/vDy5qo1juq6cZsd4eLDN1leOnio2/R4m2+0z6H9LnO16Ha9Ib0c8gzQjee/70JUGE1k3PZorXlxQbtu3uQfi6vpNyWPCiMMj70eeEtusp6cFprY+droYY6evN/UcPzR6e9n01bsxe90eU/t+tmqXzdFYI7xbbLwilVrjmTTylfnlq66ijXy3Qt7+4xFf469zNtv6uhSKCcNBwRLGMZPzFQHWNnoX6U40s9ftweMfx16bPBVKODtNjghOdDSy08z2VDKS7Ef6wuzyjeNLtoUuT3OqqCTpxBbO7IJKZB8mDBdEK62HrwRn5ZQboz86O+jwl+8sw+SlO6LsXZ5SCut3pW4VgF9m2y1KuoRhUSBRPDdrI9o+Mcv211ldcNj216CzmDAcZKZaN3zEdLJXk3ofLS/AqSQaZCctysfV4xdi0db9lsVEzrMiX+gvbNxcsMvKgYAUGxOGg46fLsa2/cejTpv3ok194YMemhJ9lHFpqQoZdKW3VitdFBxMzUnffLD6aVRKKTz6waqYCzFZ0fPuCd08Tm4t2EXOY8Jw0NZ9x/GTFxdEPTPtPGTvyTjWim2vf52HoQarCJadZ3TxW11P7YYfj5zCoeNnLO/Z47RDJ4rwwbIC3PnvpVH3s6JKysnp2Mk7mDBcEG1qbpFAXbpSCqeLne/Pv3GPcRtFsMdWJd2JdZUP1w8PGjN1LUpKFS7581x0Gzsn6WVfnRLrfB/78eQzRvAIsUorb32zLenXSkRpqTK9SBmZx4Thgmgnpt2Fp9B97Bx8kFOA08XWX73H+geP9PCpohJs3Xes7DF9+H45yUYy6bvtWKNbzMgvf8pjH66OOF1GJe0PcKJRO/g9+m+MMSdmu49b7Z/zc9Hj2bmme8iROUwYLjCz8MvCXHsalhM5lzz83kpc+dJXZYO7Kum+NXdMjF794SdOLwKVjCHjv0H+/uN4U7dWe7DkGmsEtIllxk1b7rElVw+fOIP5G/divjYH2p5CJgwrMWG44Php704dEanE8K2WvIIlHn2Vmtk1sL1KX+LaGmUtai8aNmEx/jRjQ9k626L9Nx89VYxl2w+i97h52H+sfC8iK6ukPlnh/JQgRiYtykfXZ+bgzv98j0NaF2nOHmItJgwXmPmHLVUKyob25Fj/QEejJICyNm+/1N2kuGNh03kcPHZ2HMmNr36HnYdP4hJtsFvL0TPwgLYOhxXjTQ6fKPJchwf9Ylb5B04A4HfVauluB1ARHToeu+pjxurd2GzDokThE+OdKS7FwL99jWqV0/DJyEsj9n4JliKCV+N+702kZ0c7kVOCCaOoJPC5TI6wfHBJ6dnOE5+t2oULmtQut052oop9MA0ASxjWYsJwwch3l5vaz4lpuYdPXFo26V6HJz+Pum+kRm+/GzZhsdshJO1X7yxDRuVKWLglcruX/nN9btZGp8LyBOYLa7FKqoL7Li/6uAy9b7S2jFgDw8hZS/MPGiaLiu7EGe+2F/oRSxgUt7e+2YYuzTLRtmFNt0MhF533h+glUi847fW1SXyGJYwKaHEcpQojD05egQWbOdqXvI1VUtZiwqiArKq3f/5ze+e9IiJvYcIgopTFJY6txYRBRESmMGEQUcpiAcNavkkYIjJIRDaJSK6IjHY7HiKiisYXCUNE0gC8AmAwgI4AbhWRju5GRURexwKGtfwyDqMHgFylVB4AiMgUAEMBuDN3MhH5wn3/W46H+7d3OwzHDe3aBC0b1LD8uH5JGE0B7NDdLwBwSfhOIjICwAgAaN68uTOREZGnvfzlZrdDcFyXZnUqdMIwRSk1AcAEAMjOzmZplKiC++M1HXHHpS3dDsNxds0P6peEsRNAM939LG0bEZGhPu0aoFKlVJou012+aPQG8D2AdiLSSkSqABgGYJrLMRERVSi+KGEopYpF5H4AswGkAZiolFoX42lERGQhXyQMAFBKzQQw0+04iMg/OHDPWn6pkiIiIpcxYRBRylIcumcpJgwin7u+W1O3Q6AKggnDw179RXdHX++X/Vo7+npkjW7NMzG0axO3w6AKgAnDw3q0qmfLcbc8O7js9vQH+pTdrpkRXx+If99xsWUxUeJuvqgZmmRWczsMqgCYMDyqVtV01Kpa2fLj1qlWGZXTzn7slRIYEvr8jZ2xaPQV+Ml551gZGiWoWpU0XNO5MQBgzsP9MOuhviGP39u3lRthueLJIeeH3GcvKWsxYbjgN1dFnwytUe0M/OXGzrY02PVuWz/q4z1bG5dqJt3VA+NuuBC3XHz2ivZn2c0M9/eDfu0buh2CJTo1qYP8cUPQrlEtnN+4dtn2xnWq4okh9kzs/PF9l9py3GT0bB39+03JYcJwQayL+m9/dwWuvrCx41dH+pe7vVeLco9f1r4hhvUIndTxgqa1y+3nJxc1r4vm9aq7HYZtvnv8SgDAqP7tLD1uu3NqonvzupYe0w4sYViLCcMFsb7EwWoiO77sTeqE1nW3qB/5ZGm2qkrsmuXMQelpgb/hxu5ZLkdiXv64IVEfn3Z/b3w7+oqy+6P6t8fCx36Ce/pYUz31kJaA6tWoYsnxrPDYoA5uh5DymDBcEC0PpFUS22aaBIBHtX+q/HFDkD9uCGroGrqVAoZcGKgLP79xLVPH69O2gfVBOkhB4a3hF+NXl7VB1+aZbodjmc5ZmWga1hDerF51PHlNR/znzuQ7K1zTOdArq3ZV70wWcd/lbctdZDWsleFOMCmKCcNj1j41sOyqvWplaz+eGlXSkJGeFnWf/+vZAhvHDkIzXTXN9Af6YMqInhH3t2POfae1alADowefh3NrV3U7FN/540+9tfClvt3v3r6tmDAsxoThMfrShdXVPW/cnh318T7tGkBEULVyGgRnX/uCpnXYmOhBteLsBh1k5ffqivMaYc1TAyw7npXq1WCysBoThguucKk7aquG0UsDF7XwfiOmlerXqOKrdotwCx69HPN+c5njr9s67Hvk1XasO3u3dDuElOOdCsgKYHivFvhFzxZo38hc+4CbPHoOsNSyP1wVct9vf3L9mhmoX9P5q+hPR/YOue+l9y3YhnFh0zqoWjl69SvFjyUMB2W3rOdqsoinR0vwJMDFyiqGrs0yTe9b24YBpVarCBc8bmDCCNOjpT3TcZhl1xf9hZs6x2zwjsTv1VQXt/R3/E7p3bY+eiXYTuWlk3Obc2qikgAPXWntuBMKYJVUmKpV7CvGuvWP9eSQ83FzjBHZrRtErpc2MxakS1YdrCooTDg+OwkElQQoNfF3eOnE54ZEZxbQTzXjtpoZ6ch7LvoYFUqcdz5pAoCQ3klWuadv9Flo5zzcD5/cF1YvrYWRCgNlOzbx92h0qymDqwAzSbVxnfJdj6MljHfvvcR0XOR9TBgu+f3V5znyOkbjJ/TaNaqFOtVD66WDacvo5OIbYk8SdtOHv+ply3Ht+KwvbZP8wM7Zo/pZEAlZgQnDwC3Z9na3bN2gZsTtVleLtKyf2MC6VClhxPN2ds7KtCsMSyU7i3Gkz1Qp4BYTE0nG836ew0FzKYcJw8DV2hQZQQ9a3IhW6tCV+7kRqhDMSY2r8poZ6aaTcMNaGeiWQtODxOvCrDqWHm/pE/0BAC/d3KVsWyJzWVX0tiUvYcIwoBCYZjzokRhTksfLKGF45X+jU5PauKBpbfzhGhNTP3j4P/r5mzqjbcPIpTkK1f4ce7p839A9uSVko327GrgwDqUiY8KIIr2SfW9PSalthy7TJOHSBVC1chqmP9DXF1NYR1O/Zgaevf5C0/vbnfqsmB/MjnVSAKCSTYNuRARLf38l1j8zMOFjVEk3et/8XmnqL0wYBgTAP37eDQDw5SOB6Rdu61l+jYhElRiVMMKu1v96S5eI+5kx5tpOCT83lVSzsat0vGY91M/9GX6TOMcmOg3IObWronoV89WDoa8JLPjt5Xj/l/Y09pN5TBgGFIDuzesif9wQtD0nUKUx9roLrDu+yTaMvu0SXxFuQMdGCT83Hrde7O9V95zUqkENDO3aJKlj1Khi/fCpZK/TL20TOujPaGLExBKOoElmNdvWuCfzmDDCOFUbX2LQ6T389c1WP/z7jrNrHMQzzYMVhvVoHnNBn4pu4h3Z+OrRywHEf3Lu2Dh0HEmzJFcItKNKKzwJTnugT8T9EkoX3m0iq3CYMMI4VSNqlDAS9RPdDLifjuyN/HFDPDuLaCJe/lniVXN2Mlvt36h2VbTQujjHOxeTFQse6SUyRUy8Whmtk2LxV/IGH8827EdMGAbsPtUa1UiVO8dXkDa9WCOCzS4Zq+fEPFgXJzD32MBO8VUVWj31Rnj1EQB0cGhSzGu7xF8dp//ku+hKz/VqVMHoQc4MgKUAJgwDRufpW7KzkJ5gbxL9iGOjtbST8ddbuuDtu3pYflwnZGVWx6j+1o51sXv50P7nN8Jbd5i7+tdfIMRb8qtl8d8R6fWTbVcxq1OT+Md61NT9/VNH9sao/u3QvXkm/nv3Jbb17KLImDDCxPr6PX9TF7xnQW+NmgYngfB/5ngKGDd0z0K/9ok3krslq241NK9fPeTqMZyIROlaeda9fVvhnz/vhiZ1quKlW7rGHUs8J/OOjWuhZoKr3sUjPa0S0mw8Mf768jZlf/ddveMfWGen6Q/0wTm1QruHj+rfHh/f15tzhLmAs9UmJPl6ovPONfdl9/tUTmbMeTjQbTnWKTEjvRLOFEcfwFIzozKu6dwE13R25orZbk50YNC/75XTky89J9MVPNwFTa0dfU7JYQkjTHA2zmhXjkYn8VpV07Fx7CBTr2P2itHGsYOWa5jg3EFG4yRe/UX3kPsf/fpS/CbGiHu7BrVFEqs0MqjTuUm/RnDyyMxqzixaZMVEjW4tQUz289HpyBljftoJ42/tllBjZqcmtS1fFjK8OO5ln90fuSulWfoTcKsGNdC/YyMM6RyY00sAtG9UCw9c2Q49W9fD9d0iTzdxdwJzFeldGMcV7b39ok8bXz3KgEH9xHzRLh6C36ePfn2p6bjiFU+Tin66HCOZ1c2v7BhNcPwTeYdtCUNEnhKRnSKyUvu5WvfY4yKSKyKbRGSgbvsgbVuuiIzWbW8lIku07e+JiDXfyAiqVUmL2ZPD6Bo2VvVRtBNIMrzS5TTxiQ4D9Oet+b+9HJXTKuGRq9qjS1YdXNbhbNvMlBG98PLPukY8RrIzuT4ex7TzRqXQ4En1p7rvUfh34yWt2qZP2wbIqlsNQPmkoO9c0dKom6oFbuvZsux2rwg9qPQm3J4d+QEbmlh8P7V+CrK7hPGyUqqr9jMTAESkI4BhADoBGATgXyKSJiJpAF4BMBhARwC3avsCwF+0Y7UFcAjA3TbHHVXwe9yodgb+FMfo78s72NMgbTRVuh9cpRuNHulKt03Dmph6fx/H1pGubFAHGE8X3VYNaiB/3JCQsTFGFFTZuTZ8zfXZDzuzDoQ+0V8Wo9OE0WR/7RIoDUTqKZjzZP+4j0POcaNKaiiAKUqp00qpbQByAfTQfnKVUnlKqTMApgAYKoF6iisAfKg9fxKA65wPu7zm9arjpovODhyK1YvHroF0ia554QVvGF2xxqlDo1q4tYfxFCWXJDmtxOu3XZTU86P5P22OsgY1zyaMG7o3RZuwWXarpFXCw/2tnTU5kkQ+k24JTFIZaW42fUJiAcN77E4Y94vIahGZKCLBb1RTADt0+xRo24y21wdwWClVHLa9HBEZISI5IpKzb98+K/+OEPqisj4H6Of9d8rapweWWy3PTROSOLEm0+D668vb4LkbOhs+3qi2ueqySDl9yoieaFAzA/njhiB/3BB0yaqDulHe8zE/LT/po1FjvEBwT9/WyB83BLWqVo5abbn52cF4yOKxKpFYMaOuGcm2N5HzkvpmiMiXIrI2ws9QAK8CaAOgK4DdAF5KPtzolFITlFLZSqnshg3tH48gkLIRyJ2a1MY5Jk9KVghWezgxDiAeA+LoGTTzwb4h9706k0nP1qH1+lPv74MVfxxguP/5jWN3me7evC7Ob1wboweHtpk8M9S6CS69LlaJmwUM70nqbKOUMlXhKCJvAJiu3d0JQF93kKVtg8H2AwAyRSRdK2Xo93dFdW220HPrVEXltEp4955LTJ0krOTlBsF37u6BWWv34N0lP0Tdr3XD0Kq0ZPJFb7enDI8hvO6/RkY6Zj3U12DviukftwaWE6iVkY6jp4vZS8qD7OwlpV/j9HoAa7Xb0wAME5EMEWkFoB2ApQC+B9BO6xFVBYGG8WkqcGacD+Am7fnDAUy1K24zLsyqg78P64o/3xBYmOfStg1Qt0b0jls/M7Fecqro264hBiYyBiGJjBHvGJDwBma7NcmsZmo/L18IxHJj96yo7UixBHuVXad1mXZ93RAqx876jOdFpCsCJct8AL8EAKXUOhF5H8B6AMUARiqlSgBARO4HMBtAGoCJSql12rF+B2CKiPwJwAoAb9kYtylDu8a37GSjJLuchkuFmWirhE2qZ3b0uxU+N3l179QcS6ngJYtGeAc7j3CeKO+xLWEopW6L8tizAJ6NsH0mgJkRtuch0IuKUsT6ZwaWOyE4edVvtr2pw7nOzOIalAoXAska1b8dBIGJPslbvNVimiLSKkm59S6sPg08HGOKDLfFmi67ug2rxkVjtqKHJ2z31apaGU9e0zH2jpovH7kMBYdO2BgRBXFqEBtEGvxkdc304AuSn6fITufWqWq4Cl+s9gY/n7Ovi1CFNeTCxhH29B8zswWbFV7bNOan5hNEuLbn1MTlHTh/lRNYwrCBnxsunfD9E8ad61b84SpP1V03inMur/BPft3TA5ERx4k2uPaF0YhqJwTn03rj9mzc+3ZO2fYPf5X8tP4AMHtUv7JxLHWqVUbhySJcF2ebILmDCcMh9UwMrru9V/mRr0asXoXNK2L1NkvUhU1r47NVu+J+XquGyY2irxHnOJkBHRvh+Rs741oXG9szq1eJWDpMdq6wIH27UPDiys+lyookNc86LguvB3/hps64rVfLmM97KsII4VTSo1U9rH9mYOwdbXBPn+gzyxrpmpVpbSAxiAhuubiZ5bMee50V06qT/ZgwHHBzdjNT61+YrYrx65QKvxt0nuON3UGJVnPF+7xUq41MZlyFGW20wXlpaUwYfsAqKR9yelS5Vc5zuIuqESsWNqoo7E6AE4dfjFUFhz03xQ1FxhKGDXitdNajAzsACEwOGG99PnmLHdVGdWtUYQ8nH2HCILKQnQsdEbmNCcOHuGaydz14RVu3Q4hL9+aZUR8PdvMFnF0vnbyJCcMGT11rb28npyfOI/PSfdLd+Y5LWwKIPfXJI1d1cCAa8gt/fLt9plm98ktPxmKmFxWFamzxhI7JCp6E/aB9jKlbgqrZtA49+RMThkcM0K1tTea8mOAKh23OYTtDIjhWgthtxSNSrf++E+I9fa17eiAW5x2IONdXRXNpm8AqgpySg+LBhEEVRo2MdFx5PktyQKA3l9HkkERGWCXlERe1qGtqv77t/LUKWbCBvl51GxrqtSJGz9b1rD82EZXDEoZH3NPXn9N9xPKz7GZIryS4vhurPvyqRpU0HD9TEtLFliomfgM8IlUX7qlUSXCzTeuZX9SiLgZ2aoTHBp1ny/EpYN0zg9wOgTyCCcNmzRPoYkvmZKSn4fXbst0Og6jCYBsGERGZwoThojZJLs5DROQkJgwXzR7Vz+0QyAJdsgJLmrL6kVId2zBs1rVZpuFjicw7ZPc8VRS/T0f2xre5B8oGwxGlKpYwbNJFSxTP39TZ0uO2aVjT0uNR8kQEfdo1SHhVPyK/YAnDJu/c3QM/HDhR4dZmJqLUxRKGTWpXrYwLmtax5Fgc9EZEXsCE4QMZ6fyYiMh9PBMREZEpTBhERGQKE4YPcK0MIvICJgwfUGDGICL3MWH4AEsY7uBAPKJQSSUMEblZRNaJSKmIZIc99riI5IrIJhEZqNs+SNuWKyKjddtbicgSbft7IlJF256h3c/VHm+ZTMxEZtWvmeF2CESekmwJYy2AGwB8rd8oIh0BDAPQCcAgAP8SkTQRSQPwCoDBADoCuFXbFwD+AuBlpVRbAIcA3K1tvxvAIW37y9p+FQoLGETkBUklDKXUBqXUpggPDQUwRSl1Wim1DUAugB7aT65SKk8pdQbAFABDJbB60BUAPtSePwnAdbpjTdJufwjgSknV1YaIiDzMrjaMpgB26O4XaNuMttcHcFgpVRy2PeRY2uOF2v7liMgIEckRkZx9+/ZZ9KfY67cD2uPTkb2j7sM2DGc9OrCD2yEQeVLMuaRE5EsA50Z46Aml1FTrQ0qcUmoCgAkAkJ2d7YvT7P1XtHM7BAqTVbea2yEQeVLMhKGU6p/AcXcC0C/knKVtg8H2AwAyRSRdK0Xo9w8eq0BE0gHU0fYnIiIH2VUlNQ3AMK2HUysA7QAsBfA9gHZaj6gqCDSMT1NKKQDzAdykPX84gKm6Yw3Xbt8EYJ62f4VxbdcmAIBfXtba5UgqhvRKgX+LKgmsV0KUyiSZc6+IXA/gHwAaAjgMYKVSaqD22BMA7gJQDGCUUmqWtv1qAH8DkAZgolLqWW17awQawesBWAHg/5RSp0WkKoB3AHQDcBDAMKVUXqzYsrOzVU5OTsJ/G1VcxSWlePGLzfjVZa2RWb2K2+EQOUpElimlsiM+lqoX60wYRETxi5YwWOYmIiJTmDCIiMgUJgwiIjKFCYOIiExhwiAiIlOYMIiIyBQmDCIiMoUJg4iITEnZgXsisg/A9gSf3gDAfgvDsQrjig/jig/jio9X4wKSi62FUqphpAdSNmEkQ0RyjEY6uolxxYdxxYdxxcercQH2xcYqKSIiMoUJg4iITGHCiGyC2wEYYFzxYVzxYVzx8WpcgE2xsQ2DiIhMYQmDiIhMYcIgIiJTmDDCiMggEdkkIrkiMtqm15goIntFZK1uWz0RmSMiW7TfdbXtIiLjtXhWi0h33XOGa/tvEZHhuu0Xicga7TnjRURMxNRMROaLyHoRWSciD3kkrqoislREVmlxPa1tbyUiS7Rjvact+QttWeD3tO1LRKSl7liPa9s3ichA3faEP3MRSRORFSIy3WNx5Wvv9UoRydG2ufpZas/LFJEPRWSjiGwQkV5uxyUiHbT3KfhzRERGuR2X9ryHJfC9XysikyXw/+Ded0wpxR/tB4FlY7cCaA2gCoBVADra8Dr9AHQHsFa37XkAo7XbowH8Rbt9NYBZAARATwBLtO31AORpv+tqt+tqjy3V9hXtuYNNxNQYQHftdi0AmwF09EBcAqCmdrsygCXaMd5HYLleAHgNwK+12/cBeE27PQzAe9rtjtrnmQGglfY5pyX7mQN4BMC7AKZr970SVz6ABmHbXP0stedNAnCPdrsKgEwvxBV2DtgDoIXbcQFoCmAbgGq679Ydbn7HXD9Je+kHQC8As3X3HwfwuE2v1RKhCWMTgMba7cYANmm3Xwdwa/h+AG4F8Lpu++vatsYANuq2h+wXR3xTAVzlpbgAVAewHMAlCIxiTQ//3ADMBtBLu52u7Sfhn2Vwv2Q+cwBZAOYCuALAdO11XI9L2z8f5ROGq58lgDoInADFS3GFxTIAwLdeiAuBhLEDgQSUrn3HBrr5HWOVVKjgBxRUoG1zQiOl1G7t9h4AjWLEFG17QYTtpmlF2W4IXM27HpcEqn1WAtgLYA4CV0WHlVLFEY5V9vra44UA6icQrxl/A/AYgFLtfn2PxAUACsAXIrJMREZo29z+LFsB2Afg3xKoxntTRGp4IC69YQAma7ddjUsptRPAiwB+ALAbge/MMrj4HWPC8CAVSPeu9HcWkZoAPgIwSil1xAtxKaVKlFJdEbii7wHgPKdjCCci1wDYq5Ra5nYsBvoopboDGAxgpIj00z/o0meZjkBV7KtKqW4AjiNQ1eN2XAAArS3gWgAfhD/mRlxam8lQBBJtEwA1AAxyMoZwTBihdgJoprufpW1zwo8i0hgAtN97Y8QUbXtWhO0xiUhlBJLF/5RSH3slriCl1GEA8xEoSmeKSHqEY5W9vvZ4HQAHEog3lt4ArhWRfABTEKiW+rsH4gJQdnUKpdReAJ8gkGjd/iwLABQopZZo9z9EIIG4HVfQYADLlVI/avfdjqs/gG1KqX1KqSIAHyPwvXPvOxZP/V6q/yBwBZSHQEYPNgJ1sum1WiK0DeMFhDawPa/dHoLQBral2vZ6CNQH19V+tgGopz0W3sB2tYl4BMDbAP4Wtt3tuBoCyNRuVwOwEMA1CFwF6hv+7tNuj0Row9/72u1OCG34y0Og0S/pzxzA5Tjb6O16XAhcidbS3V6EwJWpq5+l9ryFADpot5/SYnI9Lu25UwDc6aHv/iUA1iHQdicIdBh4wM3vmOsnaa/9INADYjMC9eRP2PQakxGokyxC4KrrbgTqGucC2ALgS90XTQC8osWzBkC27jh3AcjVfvRf9GwAa7Xn/BNhjYwGMfVBoMi9GsBK7edqD8TVGcAKLa61AP6obW+t/RPmav9AGdr2qtr9XO3x1rpjPaG99iboeqkk+5kjNGG4HpcWwyrtZ13wuW5/ltrzugLI0T7PTxE4sXohrhoIXI3X0W3zQlxPA9ioPfcdBE76rn3HODUIERGZwjYMIiIyhQmDiIhMYcIgIiJTmDCIiMgUJgwiIjKFCYOIiExhwiAiIlP+H0Np+m0cbJ3eAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import random\n", + "ind_sample = random.randint(0, x_train.shape[0])\n", + "\n", + "# Affichage du signal 1D d'un des extraits\n", + "plt.plot(x_train[ind_sample])\n", + "plt.title(languages[np.argmax(y_train[ind_sample])])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8llVnKALTNVK" + }, + "source": [ + "## Travail à faire\n", + "\n", + "\n", + "\n", + "1. Construisez un premier réseau de neurones, simple, qui permet de classifier les signaux 1D selon les 7 classes (langues). Vous pouvez vous contenter d'une architecture simple (conv1D/pooling) pour obtenir ces premiers résultats. \n", + "\n", + " N.B. 1 : **Attention à la normalisation des données !**\n", + "\n", + " N.B. 2 : **Ne cherchez pas à corriger le surapprentissage !**\n", + "\n", + "2. Transformez le signal 1D en un log-spectrogramme de Mel, comme présenté ci-dessous dans l'exemple fourni. Vous vous retrouvez devant un problème de classification d'image, que vous pouvez maintenant tenter de résoudre avec des convolutions 2D, et un simple réseau de type VGG. \n", + "\n", + " N.B. : **Attention à la normalisation des données !**\n", + "\n", + "3. En dernier recours, testez maintenant une architecture récurrente, comme par exemple un [LSTM](https://keras.io/api/layers/recurrent_layers/lstm/). Vous pouvez considérer un signal audio comme une séquence de vecteurs d'intensités (correspondant à chaque fréquence du spectrogramme de Mel), et lier cette entrée à une (ou plusieurs) couches récurrentes, avant de terminer le réseau par une ou plusieurs couches denses.\n", + "\n", + " N.B. 1 : **Attention au format des données en entrée d'un LSTM : [batch, timesteps, feature]**\n", + "\n", + " N.B. 2 : **Attention, le problème est de type *many-to-one*, mais lorsque vous chaînez 2 couches récurrentes, la première doit également retourner une séquence !**\n", + "\n", + "4. Lorsque toutes vos architectures fonctionneront, vous pourrez les tester sur une base de données plus large. Voici le lien pour les récupérer :\n", + "```!git clone https://github.com/axelcarlier/spokenlanguage_large.git```\n", + "\n", + "Attention, les fichiers ne sont plus au format .wav mais au format MP3 (pour gagner de l'espace et tenir sur Github), il vous faudra donc modifier le code de chargement des données. Il y a maintenant 2000 échantillons par classe dans la base de données." + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "x_train_normalized = (x_train - np.mean(x_train))/np.std(x_train)\n", + "x_test_normalized = (x_test - np.mean(x_train))/np.std(x_train)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "from tensorflow.keras.layers import Dense, Flatten, Conv1D, MaxPool1D, Input\n", + "from tensorflow.keras.models import Sequential\n", + "\n", + "def create_model(input_size):\n", + " model = Sequential([\n", + " Input((input_size,1,)),\n", + "\n", + " Conv1D(32, 3, activation='relu'),\n", + " MaxPool1D(),\n", + "\n", + " Conv1D(32, 3, activation='relu'),\n", + " MaxPool1D(),\n", + " \n", + " Conv1D(32, 3, activation='relu'),\n", + " MaxPool1D(),\n", + " \n", + " Conv1D(32, 3, activation='relu'),\n", + " MaxPool1D(),\n", + "\n", + " Conv1D(32, 3, activation='relu'),\n", + " MaxPool1D(),\n", + "\n", + " Flatten(),\n", + " \n", + " Dense(7, activation='softmax'),\n", + " ])\n", + "\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_19\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " conv1d_49 (Conv1D) (None, 79998, 32) 128 \n", + " \n", + " max_pooling1d_42 (MaxPoolin (None, 39999, 32) 0 \n", + " g1D) \n", + " \n", + " conv1d_50 (Conv1D) (None, 39997, 32) 3104 \n", + " \n", + " max_pooling1d_43 (MaxPoolin (None, 19998, 32) 0 \n", + " g1D) \n", + " \n", + " conv1d_51 (Conv1D) (None, 19996, 32) 3104 \n", + " \n", + " max_pooling1d_44 (MaxPoolin (None, 9998, 32) 0 \n", + " g1D) \n", + " \n", + " conv1d_52 (Conv1D) (None, 9996, 32) 3104 \n", + " \n", + " max_pooling1d_45 (MaxPoolin (None, 4998, 32) 0 \n", + " g1D) \n", + " \n", + " conv1d_53 (Conv1D) (None, 4996, 32) 3104 \n", + " \n", + " max_pooling1d_46 (MaxPoolin (None, 2498, 32) 0 \n", + " g1D) \n", + " \n", + " flatten_17 (Flatten) (None, 79936) 0 \n", + " \n", + " dense_26 (Dense) (None, 7) 559559 \n", + " \n", + "=================================================================\n", + "Total params: 572,103\n", + "Trainable params: 572,103\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "Epoch 1/10\n", + " 6/22 [=======>......................] - ETA: 37s - loss: 2.6762" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/home/laurent/Documents/Cours/ENSEEIHT/S9 - IAM/IAM_2022_Classification_Audio_Sujet_totally_not_a_virus.ipynb Cell 10\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m model\u001b[39m.\u001b[39msummary()\n\u001b[1;32m 3\u001b[0m model\u001b[39m.\u001b[39mcompile(optimizer\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mAdam\u001b[39m\u001b[39m'\u001b[39m, loss\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mcategorical_crossentropy\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m----> 5\u001b[0m model\u001b[39m.\u001b[39;49mfit(\n\u001b[1;32m 6\u001b[0m x_train_normalized, y_train,\n\u001b[1;32m 7\u001b[0m epochs\u001b[39m=\u001b[39;49m\u001b[39m10\u001b[39;49m,\n\u001b[1;32m 8\u001b[0m batch_size\u001b[39m=\u001b[39;49m\u001b[39m64\u001b[39;49m,\n\u001b[1;32m 9\u001b[0m shuffle\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m,\n\u001b[1;32m 10\u001b[0m validation_data\u001b[39m=\u001b[39;49m(x_test_normalized, y_test)\n\u001b[1;32m 11\u001b[0m )\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/keras/utils/traceback_utils.py:64\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 62\u001b[0m filtered_tb \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m 63\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m---> 64\u001b[0m \u001b[39mreturn\u001b[39;00m fn(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 65\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e: \u001b[39m# pylint: disable=broad-except\u001b[39;00m\n\u001b[1;32m 66\u001b[0m filtered_tb \u001b[39m=\u001b[39m _process_traceback_frames(e\u001b[39m.\u001b[39m__traceback__)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/keras/engine/training.py:1384\u001b[0m, in \u001b[0;36mModel.fit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m 1377\u001b[0m \u001b[39mwith\u001b[39;00m tf\u001b[39m.\u001b[39mprofiler\u001b[39m.\u001b[39mexperimental\u001b[39m.\u001b[39mTrace(\n\u001b[1;32m 1378\u001b[0m \u001b[39m'\u001b[39m\u001b[39mtrain\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 1379\u001b[0m epoch_num\u001b[39m=\u001b[39mepoch,\n\u001b[1;32m 1380\u001b[0m step_num\u001b[39m=\u001b[39mstep,\n\u001b[1;32m 1381\u001b[0m batch_size\u001b[39m=\u001b[39mbatch_size,\n\u001b[1;32m 1382\u001b[0m _r\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m):\n\u001b[1;32m 1383\u001b[0m callbacks\u001b[39m.\u001b[39mon_train_batch_begin(step)\n\u001b[0;32m-> 1384\u001b[0m tmp_logs \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mtrain_function(iterator)\n\u001b[1;32m 1385\u001b[0m \u001b[39mif\u001b[39;00m data_handler\u001b[39m.\u001b[39mshould_sync:\n\u001b[1;32m 1386\u001b[0m context\u001b[39m.\u001b[39masync_wait()\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/util/traceback_utils.py:150\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 148\u001b[0m filtered_tb \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m 149\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 150\u001b[0m \u001b[39mreturn\u001b[39;00m fn(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 151\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n\u001b[1;32m 152\u001b[0m filtered_tb \u001b[39m=\u001b[39m _process_traceback_frames(e\u001b[39m.\u001b[39m__traceback__)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/def_function.py:915\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 912\u001b[0m compiler \u001b[39m=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mxla\u001b[39m\u001b[39m\"\u001b[39m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_jit_compile \u001b[39melse\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mnonXla\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 914\u001b[0m \u001b[39mwith\u001b[39;00m OptionalXlaContext(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_jit_compile):\n\u001b[0;32m--> 915\u001b[0m result \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_call(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwds)\n\u001b[1;32m 917\u001b[0m new_tracing_count \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mexperimental_get_tracing_count()\n\u001b[1;32m 918\u001b[0m without_tracing \u001b[39m=\u001b[39m (tracing_count \u001b[39m==\u001b[39m new_tracing_count)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/def_function.py:947\u001b[0m, in \u001b[0;36mFunction._call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 944\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock\u001b[39m.\u001b[39mrelease()\n\u001b[1;32m 945\u001b[0m \u001b[39m# In this case we have created variables on the first call, so we run the\u001b[39;00m\n\u001b[1;32m 946\u001b[0m \u001b[39m# defunned version which is guaranteed to never create variables.\u001b[39;00m\n\u001b[0;32m--> 947\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_stateless_fn(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwds) \u001b[39m# pylint: disable=not-callable\u001b[39;00m\n\u001b[1;32m 948\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_stateful_fn \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 949\u001b[0m \u001b[39m# Release the lock early so that multiple threads can perform the call\u001b[39;00m\n\u001b[1;32m 950\u001b[0m \u001b[39m# in parallel.\u001b[39;00m\n\u001b[1;32m 951\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock\u001b[39m.\u001b[39mrelease()\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/function.py:2956\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2953\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock:\n\u001b[1;32m 2954\u001b[0m (graph_function,\n\u001b[1;32m 2955\u001b[0m filtered_flat_args) \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_maybe_define_function(args, kwargs)\n\u001b[0;32m-> 2956\u001b[0m \u001b[39mreturn\u001b[39;00m graph_function\u001b[39m.\u001b[39;49m_call_flat(\n\u001b[1;32m 2957\u001b[0m filtered_flat_args, captured_inputs\u001b[39m=\u001b[39;49mgraph_function\u001b[39m.\u001b[39;49mcaptured_inputs)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/function.py:1853\u001b[0m, in \u001b[0;36mConcreteFunction._call_flat\u001b[0;34m(self, args, captured_inputs, cancellation_manager)\u001b[0m\n\u001b[1;32m 1849\u001b[0m possible_gradient_type \u001b[39m=\u001b[39m gradients_util\u001b[39m.\u001b[39mPossibleTapeGradientTypes(args)\n\u001b[1;32m 1850\u001b[0m \u001b[39mif\u001b[39;00m (possible_gradient_type \u001b[39m==\u001b[39m gradients_util\u001b[39m.\u001b[39mPOSSIBLE_GRADIENT_TYPES_NONE\n\u001b[1;32m 1851\u001b[0m \u001b[39mand\u001b[39;00m executing_eagerly):\n\u001b[1;32m 1852\u001b[0m \u001b[39m# No tape is watching; skip to running the function.\u001b[39;00m\n\u001b[0;32m-> 1853\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_build_call_outputs(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_inference_function\u001b[39m.\u001b[39;49mcall(\n\u001b[1;32m 1854\u001b[0m ctx, args, cancellation_manager\u001b[39m=\u001b[39;49mcancellation_manager))\n\u001b[1;32m 1855\u001b[0m forward_backward \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_select_forward_and_backward_functions(\n\u001b[1;32m 1856\u001b[0m args,\n\u001b[1;32m 1857\u001b[0m possible_gradient_type,\n\u001b[1;32m 1858\u001b[0m executing_eagerly)\n\u001b[1;32m 1859\u001b[0m forward_function, args_with_tangents \u001b[39m=\u001b[39m forward_backward\u001b[39m.\u001b[39mforward()\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/function.py:499\u001b[0m, in \u001b[0;36m_EagerDefinedFunction.call\u001b[0;34m(self, ctx, args, cancellation_manager)\u001b[0m\n\u001b[1;32m 497\u001b[0m \u001b[39mwith\u001b[39;00m _InterpolateFunctionError(\u001b[39mself\u001b[39m):\n\u001b[1;32m 498\u001b[0m \u001b[39mif\u001b[39;00m cancellation_manager \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 499\u001b[0m outputs \u001b[39m=\u001b[39m execute\u001b[39m.\u001b[39;49mexecute(\n\u001b[1;32m 500\u001b[0m \u001b[39mstr\u001b[39;49m(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msignature\u001b[39m.\u001b[39;49mname),\n\u001b[1;32m 501\u001b[0m num_outputs\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_num_outputs,\n\u001b[1;32m 502\u001b[0m inputs\u001b[39m=\u001b[39;49margs,\n\u001b[1;32m 503\u001b[0m attrs\u001b[39m=\u001b[39;49mattrs,\n\u001b[1;32m 504\u001b[0m ctx\u001b[39m=\u001b[39;49mctx)\n\u001b[1;32m 505\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 506\u001b[0m outputs \u001b[39m=\u001b[39m execute\u001b[39m.\u001b[39mexecute_with_cancellation(\n\u001b[1;32m 507\u001b[0m \u001b[39mstr\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39msignature\u001b[39m.\u001b[39mname),\n\u001b[1;32m 508\u001b[0m num_outputs\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_num_outputs,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 511\u001b[0m ctx\u001b[39m=\u001b[39mctx,\n\u001b[1;32m 512\u001b[0m cancellation_manager\u001b[39m=\u001b[39mcancellation_manager)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/execute.py:54\u001b[0m, in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m ctx\u001b[39m.\u001b[39mensure_initialized()\n\u001b[0;32m---> 54\u001b[0m tensors \u001b[39m=\u001b[39m pywrap_tfe\u001b[39m.\u001b[39;49mTFE_Py_Execute(ctx\u001b[39m.\u001b[39;49m_handle, device_name, op_name,\n\u001b[1;32m 55\u001b[0m inputs, attrs, num_outputs)\n\u001b[1;32m 56\u001b[0m \u001b[39mexcept\u001b[39;00m core\u001b[39m.\u001b[39m_NotOkStatusException \u001b[39mas\u001b[39;00m e:\n\u001b[1;32m 57\u001b[0m \u001b[39mif\u001b[39;00m name \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "model = create_model(5*sr)\n", + "model.summary()\n", + "model.compile(optimizer='Adam', loss='categorical_crossentropy')\n", + "\n", + "model.fit(\n", + " x_train_normalized, y_train,\n", + " epochs=10,\n", + " batch_size=64,\n", + " shuffle=True,\n", + " validation_data=(x_test_normalized, y_test)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bMG6ZGR_N-C1" + }, + "source": [ + "## Spectrogramme de Mel" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PWQ2mSzlOA5n" + }, + "source": [ + "Le spectrogramme de Mel est une représentation temps/fréquence, comme le sonagramme que vous avez vu l'an passé, pour laquelle l'échelle des fréquences est adaptée à la perception humaine. C'est une représentation classique en traitement de la parole." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "id": "R0i8tdJfUvf3" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_91783/2389383061.py:5: FutureWarning: Pass y=[ 1868. 1682. 1808. ... -683. -1842. -2194.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " S = librosa.feature.melspectrogram(x_train[0])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApkAAAEYCAYAAAAXq+2yAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9ebylWVbXCf/2mYc7TzFHRk6VWQNVVJFQIAUUijIL2t2i7UD5grTdgPp2o4D6Cq0oqN2K/Yp2IxZjK9iICghCiRSDjFVQc1bOGfNw5+HMw+4/zom7v2vdc25GFpkVkcGzPp/4xHPPM+1nj2v/1lq/FWKMyiSTTDLJJJNMMskkk1dScne7AJlkkkkmmWSSSSaZ3H+SKZmZZJJJJplkkkkmmbzikimZmWSSSSaZZJJJJpm84pIpmZlkkkkmmWSSSSaZvOKSKZmZZJJJJplkkkkmmbzikimZmWSSSSaZZJJJJpm84pIpmZm8pIQQXgwhfMHdLkcmn1wJIXx7COFH7uL73xlCuHK33n+chBB+IITwHXe7HC9XQgh/PYTwfa/Cc6shhP8aQvjSO7w+hhAeeaXLMeVdh98cQrgwfndh/Pd7Qwhf+yq99wtDCP/+9/iMcgjh4yGE1VeoWJlk8kmVTMnM5PeNhBDeFUL41btdjt8PMt6YdEMIK+733x0v8hfuUtF+X0uM8e/FGF8Nper/kvSPYoz/8VV49h3LpI3Jq/jNLyV/V9J3/V4eEGPsSHq3pG95RUqUSSafZMmUzEwygYQQ8q/gswqv1LNeo/KCpD91+48QwqdIqt294nxicjfb8V7pQ2EkU9eLGOOfizH+209mme5lCSF8uqT5GONvvAKP+1eSvjqEUH4FnpVJJp9UyZTMTF6WjM033x1CuDb+992c/EIIfy2EcH187muPM4uFEFZCCD8dQtgJIWyFEH7l9kI2RsK+NYTwsRDCdgjh+0MIFdz7ZSGED4zv/bUQwptx7lwI4SdCCOshhM0Qwj8NIbxe0v8p6bNCCAchhJ3xtT8QQvjnIYSfCSE0JH1+COH1YzPaTgjhoyGEP4pnL4cQfiqEsBdC+O0QwncQHR1/79eHEJ6R9Mz4t38SQrg8vuf9IYTPwfXfHkL4f0IIPxJC2A8hfDiE8Lrxt98a3/dHcP17x+/8tfF3/NS4TP83ynQB1z8eQnjPuH6fCiH8iWPa9sEQwi+Ny/EeSR6F/Mzxe3dCCB8MIbxz2rPG8sOS/hz+/mpJP+SeWQ4h/G8hhEshhJshhP8zhFB9iefevjeGEP5SCOH5EMJGCOEfov/kQgh/M4RwcVyPPxRCmB+fO4J2BbiEjNvkx8dtsifpXXdQlqn98WWW+11hZHb+xyGETUnfflwd3f6WMBp3t8Jo7H1lCOFLQghPj9v9r+PdxgXiuDYd97W/G0L4r5Kakh6a8C2nQwj/NozG2gshhL+Ec/kwMlU/N+5T7w8hnMPtXxBCeGb87u8JIYTxfQ+HEP5LGI3djXHfXnBt9U0hhA+FEHZDCD8WQqiEEOqSflbS6fHYOBiX747cPl6iz9w2s3/1uB02Qgh/45jHfbGkX3LPf2NIY/Hm7XYJIXxGCOHXx/VwPYzmq9Lt+2KMVyRtS/rMl/qGTDK55yTGmP3L/h37T9KLkr5gfPy3Jf2GpDVJq5J+TdLfGZ/7Ikk3JL1RI8TqRyRFSY9Mee53aqT4Fcf/PkdSwDs/IumcpCVJ/1XSd4zPvVXSLUlvl5TXSHl5UVJ5/PcHJf1jSXVJFUnvGN/3Lkm/6srwA5J2JX22RpuuWUnPSvrrkkqS/qCkfUmPja//0fG/mqQ3SLrMZ46/9z3jMlfHv/0ZScuSCpL+l3EdVcbnvl1SW9IXjs//kEYI4N8Y18lfkPQCnv/ecfkeljQv6WOSnpb0Bbj/+8fX1sfl+/Pjc2+VtCHpDVPa49cl/aNxPX7u+Lt/ZHzujKRNSV8yrqc/PP579bg+I+kpSa8ft8sVSQ+M6+jC+Lp/LOknx/U1K+mnJH3n+Nw7JV05pl9GSb84vvf8uB6+dnzu/zOup4ckzUj6CUk/PO25sn382yX1JH3l+FurE979A7qD/vgJlPtdkvqSvnHcZtU7qKO+pL+F/rKuEfo1q9FYbEl6EN92R22qUV+7NH5GQVLRfUdO0vvH7y6N6/p5SV84Pv9XJX1Y0mOSgqS3SFpGHfy0pIVxHaxL+qLxuUfGZSlrNMf8sqTvdm31W5JOj+vkSUl/8Zi25TdfGL+7gG+8kz5z+75/MW6Tt0jqSHr9lDb+fyT9Vfw9K+m6RuO/Mv777eNzn6aRAlkYv+dJSX/FPe8nJf2lu70WZP+yfy/3310vQPbv3v8nuwA/J+lLcO4LJb04Pn63xovf+O9HdLyS+bcl/YdJ58fv/Iv4+0skPTc+/ucaK7Y4/5Skz5P0WeMFqzDhme/SZCXzh/D352ikBObw278eL1R5jZSPx3DuO3RUyfyDL1Gf25LeMj7+dknvwbkvl3QgKT/+e3b8zIXx3++V9Ddw/f8u6Wfd/R8YH3+VpF9x7/6/JH3bhDKd10hZqeO3f6W0OH+zxgsuzv+cpK8+rs9I+psabSa+SCPluzD+ngsaKR4NSQ/jvs/SWKnWnSmZX4S//ydJvzA+/gVJ/xPOPTZuu8Kk5+qokvnLL9GGP6CkZE7tj59Aud8l6RLO3UkdtSb0l7fj+vdL+kp82x216biv/e1j6uDtLOv4t29V2uQ8JekrjqmDd+DvfyPpW6Zc+5WSfte11Z/B3/9A0v85rc/ozpXM4/rM7fvO4vxvSfqTU8r8Htn560/xG16ib/0VSf/O/fZ/S/pbd3J/9i/7dy/9uyf8fTJ5TclpSRfx98Xxb7fPvQ/nLt8+CCGc1wh1kyTFGGck/UONFoCfH1vKvjfG+F2T7nfveUAjH6VvxPnS+PxA0sUYY/9lfBPfc1rS5Rjj0L37jEaoSsFdz+OJv4UQvknS14yfHSXNyZqib+K4JWkjxjjA39IIWdmZcr3/e2Z8/ICkt4exa8BYChqZsb2clrQdY2zgt4saIcm3n/XfhRC+HOeLGiFyx8kPa4REPShnKteoPmuS3j9uf2mkVL0cv9hpfWRSPy1IOvEJPPel5Lj+eCfPZ7n9uTupo80J/WVan/Dlfqk2Pa4eHtDINL2D3/KSfmV8fE6jTek0uYHj5u0yhhBOSPonGm34ZjVCTLdf4t7j6vpO5U76zMQyT5Btjcp+W6bWRQjhdRpZEJ7QqK0LGm0MKLNK4z+TTF4zkvlkZvJy5ZpGi8ttOT/+TRqZg87i3KH/VYzxUoxx5va/8W/7Mcb/Jcb4kKQ/Kul/DiH8oUn3u/dclvR3Y4wL+FeLMf7r8bnzYXLARJzyTfz9mqRzwQY5nJd0VSOEtD/tGyc9L4z8L/+apD8haTHGuKCReT5MuO+VlsuSfsnV00yM8X+ccO11SYtjv7bbct4964fds+puU3BEYowXNTL/f4lG5kfKhkYK0BvxzPnb/eMOZVofmdRP+xopXw0hACmMgr08Rcy0vjJJjuuPL7fc/t2vRB0dV+6XatPj6uGyRogq75+NMX4Jzj/8CZTr743f+ykxxjmN3E3udLy8nHbzclyfebnyIUmvw9+XNcGndSz/XNLHJT06/t6/rqPf+3qN3IAyyeQ1JZmSmcnLlX8t6W+GEFbDiJ7mb2nkeymNTF5/PowCZ2qS/n/HPWgcLPHI2OF/VyMUkgji14cQzoYQljTyUfyx8e//QtJfDCG8PYykHkL40hDCrEYmrOuSvmv8eyWE8Nnj+25KOkun+gnymxohFH8thFAcB0J8uaQfHaNFP6FRMEYthPC4bGDLJJnVaKFal1QIIfwtjZDMT4b8tKTXhRD+7PhbiiGETw+jICgjY2XwfZL+1xBCKYTwDo2++7b8iKQvDyPuv/y4Xt8ZQjjrnzVBvkYjFwKipBqjxf9C0j8OIaxJUgjhTAjhC1/GN/7VEMLiOKDkLyv1kX8t6f8bRsFMMxopLj82RrifllQZ95miRib930vk7nH98eWW28grVEfT5PfSptJorO2HEL45jHgy8yGEN4VRZLUkfZ+kvxNCeHRcL28OISzfwXNnNXIZ2Q0hnNHIt/NO5aak5dsBOy9TjuszL1d+RiP3ndvy05JOhRD+ShgFcs2GEN4+PjcraU/SwXhOMZvAcR0saeQLn0kmrynJlMxMXq58h0bKyIc0cur/nfFvijH+rKT/QyNz27NKk2JnyrMelfSfNVpQfl3SP4sx0lT3ryT9vEbBBM/hPe/TKMDhn2pklnpW4wjgsSL45Rr5g17SKNjkq8bP+y+SPirpRghhY1KBYozd8f1frBGK9M8k/bkY48fHl3yDRgE3NzQyBf/rY75PGvm4/SeNFJuLGgX5vBxT7CcsMcZ9SX9E0p/UCKW5Ienva7pC9d9r5Ge3JenbBPN2jPGypK/QCGVZ1+gb/qruYA6JMT43brNJ8s0a95UwiuT+zxr5wt2p/AeNTIsfkPQfJf3L8e/vVjLVv6BRvX/juDy7GvlBfp9GCHVDo37yCclx/fETKPck+b3W0UT5vbTp+P6BpC+T9Kka1fGGRnV6W8H7RxptPH9eIyXqX2oUNPNS8r9KeptGG8//qKMI+HFl+rhGY/L5cbT2yzGjT+0zL1dijL+jkZL89vHf+xoFM325RuPwGUmfP778mzQae/sabSj8huO/l/SDccSZmUkmrym5HcmbSSavuIwRs49oFGX7stCAEMKLGjnk/+dXo2yvlIQQ/r6kkzHGr77bZfn9JiGEqJGJ8dm7XZaXI6/Vcmfy8iSMqMf+pxjjV/4enlHWyEz+uTHGW69U2TLJ5JMlGZKZySsqIYQ/NjYHLWqEmv3UJ2huuicljHgn3zw2/32GRqbgf3e3y5VJJpncWxJj/Pnfi4I5fkYnxvh4pmBm8lqVTMnM5JWW/0EjzsDnNPKxnBRk8lqWWY3Mdw2NzFr/u0amz0wyySSTTDK5JyWEsBRGyQCeGf+/eAf3vDeE8MT4+MUwShbygfH/X3FH783M5ZlkkkkmmWSSSSavfRkHq74rxvgu9/s/kLQVY/yuEMK3aMR28s0v8az3SvqmGOP7xi5sT8QYN0IIj0n6+RjjA8fdL2VIZiaZZJJJJplkksn9Ll8h6QfHxz+oUZIDI2OWiB8NITwZQvh3mh6oN6ej3LUT5b4kY8+FYsznUgBtBHVaBENOLljO5wBqsuEht7FkebmlgPv4jEHsmeuGwzb+StdZCsZRqQ6vQrnlUGaW6egz+N4erpv+Xv9dtyXnKCZ5X0mVdB32KO1DDujDUqT7Nb2OiikduYZK39cf2uexDYNrt2kSzB7K1iWfV0ip19090lCpvENTX7/3tuEzKnlruZjPpzLlwZjXc03WGqb3tpUYgobD7tQy2PojHZ+rI/NNhanXmW/H83K5on0x6m+I/lF0qcpLCH7vo/5bg11zXQ71bMek7b8c8xxT3obDsisRn6t0ZJ5Nd7aH+4fHQ+d6zDLlTZmCuy79zTFZAmVpzt3TY7/EuBm68WXeg77Ne8YvZoFwz53RU7IPSHZezAeSGdhaH8TJ/TQfXN+ZMpb998Y7pMm80+v4HayLwdC+l2N+6rOjn4M4btJ7yjlPgTqtDezzOFZqiQZWs0U7H5Vz6b4BHnHgPOf3hmk+MWuoWzdqYOoqou/03Pc24t7hsZ117HXspxwbA+/ab8Yy1lA3/tn/WOfdwd5GjNHz435S5Qu/8DPi5ubuS18o6f3vf/qjGjEe3JbvjTF+78t43YkY4/Xx8Q1NTkzxP0pqxhhfH0J4s0bsMZRfDKNGeUgj7ueXlPtSycznylqc+ZTDvzn5dwdp4FSLS/Y+dM52f2fiPZJUKSwcHpfzifJwv3vdXLfffCY9G9flcxVZSYN2oZa4i/0E2uptHR6X8mkB8oO+0UncwaXi3MR7JKk3SIocF+JaccVcx0nvrB5P18W0+D6T+5C5px/TWCiHdP9+3/IarxUSX3FbB4fHN1sfsc8b4HnFRIF3nEJXzKXyRbeo9qGELZdSnReCZfc5GCZ/e/YD/7xmdzO9F/Xsy9dopz4S0b6PzH2Zue4L5xNv8wJYPa83zWX62H5Scj6u3zw83utc1TSpsP6wuPn+1umnZ3Os+G9vddOGNpdLY2i2dMpc1wcDC599svImc92FYfr2GyHV/5P7P2WuKxVS3y4X0kJXL9h1oxtTP+c3+nFD5ZRKzvnwZnPdQGk+eaqTGLdaXcuKxfLVy2uHx34jU8DGsofN1UO5Tz88LkdL7Xorn/pRM6b6P+jdMNex/3Gx7Qz2zXWDYWobbnT9gj1tY8r2lGwfWyw+mO6XvX+7+8LE582VLFVnARsPbvwOBuvmuj7mNPbF4dAqKENN/g7/fez3rIv9jp3r2YZ8Np8XnSLe7Seli33lwcpnm+u4medxX/abdsDn/1Y9cXj8uSdt33mwnupvv5fG/6+uW2X251tpPuHY7Q3tJPS23DsPj09WUj3caFvGpfcNElEI+yXbTLLzJ+u10bPjixv2PgCdmfJJc91iIVl0OzGtMZe2f/ai7rJsbuzqN3/zn9/RtYXiH2rHGJ+Ydj6E8Jsa0dPNSFoKIXxgfOqbY4w/x2tjjHHMcuHlczWiIVSM8UMhhA+5858/Npc/LOkXQgjvjRGVOqncx37Va1SKoaqz+aRkzgyTkpPLpYGUd9nr8hjAvTyQzLydeIqoNt5zrWwVqOtY+FbzjxweV2SVvXxMz6tDcevk7C4/X0rX1bBgtB0acKucJsBKxICNtrkr+fSuGSCKRacYzRbSfedmUp0VUZez27bv9zC5FlBHmzmrsJ/JpzpqDlKdny3bRCFEclj/Q4+q4e8iUIgjvsf4xBCBvkU70Q5iWiB5T98tUs1qmihnYk3TZHc2LSzdkNrtc2cumOv+wEqaQFfLabJu9m0bPrSX6q96PS1OzbLtEyUoTWXUSwcLn+9H+Xy6rooFtuMWy04llZVtXXJoVBN0orcqSQn+lGApHx9cSPed66QFIifrZ17FWKESVpJDwdCkBhHP2bbuQgFlH1sr2U1hF/BPvvyHD497leno8fIwIdVEZyTbHpViOn50Pn2HK6qeRbvf7KZFv5e3PPtUeOqwQvQLtv+2Q1qkOyG1U21o56qyr9vb7ynY8bVUSO8q4Hs7Q/veQSltMDjGSzk7B/H724P0jH7Of8cUIgu3F81P2ZweRKvwzIU0ljkvbpesolVVaeJ1HCstR6fbrKS58EJIitEDM1Yp5NR1BlPLbs92ig9sJWDqU1fS+vDZKxYpOzmb3rvfTtc1B9aasnX90w6PG4NUr65p9NlraRwulFJhLzasBaC2+0WHxwdQEK/n7caIUkS9qvQ6c47rZjmm75h3lpFzVXxjP5Xvh/WzU9/7yZMoDSdveF72k2J8uzTdJ1PSzRDCqRjj9RDCKY0CdD/Rdz0XQrgp6Q0aJWWYKvelkhkV1VOa8HshdWiPCFC8Seq21B26VcAkQqWm6pSL2XyaOOox7ez9bp5/83n5OL15uCDy+yRpZpjeNRPtIkHhd+WwEAydQlbOEw2BOWSYrvN1V85NNmkXXZc76KfJq0c01dU5J+42UImBQ9XyxjRPk6wtD+dJozS5xYfv7R3zvGIsTjw3cMhICZMhEa3Viq0/KpZzpdSXh04JruVTG8wWUhnygztzty4SJTmmzineLMy2Yj84rgQzceHwuOFQpu1O6iN7XWfWhdBkzO6Xj7ZtOKZYvrIr4UA08aZzBz3XxzAGOJ80g93Qz2Icmt/zVlGrF9hfUll3u9NNuq1+KpP9JvtsfofdqDkTKlJw52NSYHNeu4Wwb/dcP+9jbmCX9X2qBl8QPoHfJ0lN4wJE9wJbRxx70zZTklTB/GT67HD6BoDPOMhZ5HYGVteFYuoTpj37tl8S5VytpnZbKNkytLCpqWL67Ltvpzl/tZyePec2nMUixhuUzMbAb7DhzoP6OlOza+jJCgAFjkO3maJiyQ2tR8spdAHy4MwAG4oCN5xu7TldQ/uyTJ9IstBXQ14hJfMO5CclfbWk7xr/P4kV5Zc1Iv//LyGEN0l684RrNM4+9qBGCUaOlftSycwkk0wyySSTTDK5pyXqiK/uqyjfJenfhBC+RiPlcJJP5T+X9P0hhCclPalRVjLKL4YQBpKKkr4lxviSqvp9qmRG6wxPR3Ec144J/CFCNnDV1AOSQzOiR/PaMZkpbgFtnJf1GZkZJuSASFzRPY/mlj2YnYnaesmj7ETbJKkBP5siUNNKzn4vUYm9HlGhJN5szXFTABoyk7O7YO6QGwP42BwJEABqAl+kVrAmKLZBH23ov93ek76k5jIu5qeYvrwTOt/bi5P7nmRR5x7M5TTjSNJGJ9VTb5jKsN6x9Xepie+N05FlUwZTviQeZeIzmi7Q4U7Eo1tE2XJ0YXFF3ekCqcY3laM1W9M3ki4K/jsO0M+JZxXl0W260hBhc4sA/myGZDYdyNZRGaY+om/tgUXV+I09oBocdx4V2oMPJcfDwJmLibTWTQCE/aa8mfsY5OHdUZLswofad7d8TO1bMcEzVnZ6DGBK4i0A08zbDnhUZ0reB98nWM+sC//egzgZMTZm3CPvTefQhDqIjNmQGpjDG73k+9lyiGLBtP10hSQXJo95b/3Iw/pRglvYYtG5hdGfF4O05IxULFEJ7gtzLuCoN6UuF+FKMnpeesYOHrEftsx1RViFuBgtuEC9Ab7fB07efXnlzOWHT4zxvZLeO+H3TUl/6CXubWmUhnjSuQufSHnuUyUzk0wyySSTTDLJ5B6WKKk/xY/4PpH7UsnMKa8Z+EDOwS+RO2JPz1HL05E43VN0UAsdz6vwp5rtWZ+Rei5FaVcjorydXyidy4ko7LudL1EwBjP1nV/iTi5F4a2Hy+mesGyuOxlTxKvxzXP1QiRyEf5CrJbrTbtr3QfyRZ8ijxRQiKB69Gh3gOhXIFBrwfq9TQtkOchZf7nF4cLhsfevpNQQ/EJf1Ybz8Zrm9+frkqgpEexSzqMX6TiPIMD5op2Q6gjKIvLlfdDyBuHF8/KpL+Z9IAz6eSlMrgdJ2id1EgOvnH8ggyPmEfnPOpZsf+M3lQd23ORMxPF0hId+wLP5yQEaktREcEMX9Tfr0HcCRl2wFNDvWpLmEBnLQBZfz6SYafTon52E/s9eGGyVc4h9JaSyz6Cv+MAayno3jbVt2XEzzTpQdsheEc8vTvFhl6TlkrUc3JamQ3v3+qme2YYDTwtEVNggZ1bov8yqZR+QLDpIZH4nZ2MmevAxnulP9vs/ijInZJ7f0XQ6BymH9gGWN/p+/SJdXfqdaKUklSrpBbOIyq7mbV2ymw5QSYvu8+oIjD3GhdfQsvF7/Vx1K4CtAi23MFwz1/Ec/bDLHkHFQOoeM47ujrzySOa9JvelkjlQX7u5RCmzD4oP0uR4LrbiMA2CGpzfSwM7EVIpPFXiM+x1lwbpXCvs4diWtwNlkuZtPynRRNMnj2dwFEbgSCVlSzdnA5OuK0X1VWBuXIRCfPvNh9dhImrDrNMeTnes5+R3pWsd5g8w6KnsdR2dThcmwQKUzH333j045HMSagb33vwOrpuuZM73k2JO82wnZzcADOJZVKLuOXB8lVs51nnaKHScyagHE09rkMp3vW1n+G14C9Ck2nbvZTQ8lS6223DglEf0y53czuFxWdZs7QPZDsvj6nWHbYBXFXt2HC4f4QkciQ9wYxQ06VyovHvZjjvpHmda5TiqgGew6AJ4+LUNLIj9YMfXVSgltT7GlxuHVQTW7fS6+H369NwRN1CpXn1bbEIp3OxPrxeOqQO0054LQCWVUBnfu+QUgDZcPGzA3HTltpKffm6aYundOA7gvtAKKVK86Db2lwfpOs65NRcoOQPTa8/wwdqytkPaaN0aJjepDqL2t8IVc08NWf3yIQUOeRe9DpqUSpzTpYxLxo1WOrnVsuO1dpD6TruTxl7P+R700W4tKN/c2ErSDJgK2O5NpwTvD9J7Odc3o3V5WleitTL0TW69Zl+v5EAX1rPfe3qANfVe0+eiMiUzk0wyySSTTDLJJJNXWqLCMda9+0HuSyUzKCgXaRaffGwch+UIf4FqNLFLlaTqkLB/+r3nOeAQCJAHGuizbfSAyDAjjs80Uo6TTUsh2i3tqs6j7MhI4lCOI1k/xlI4Yi5Px/xeBgFdlCUnXh4kBDCi3LPB7jKnUScdOKJhIi0MIOm4YAsiWoVjqDGIXpIqqujQaINeBoteUrirfl6X0u+Ox4/9gP1jvWXhiw5Q4qUSELG8n5Am00t5pGUGZlOaLGk27br+20JyCbp4eISd/YrIQ8+1DQOdiPz4cbgMOh2iJh3njrKrFAjA7y04BLWFdjuOEoUBdLtwOSk7Swa/nxlh/Phiv2IZZtz3doeTaXIqx1CYtXMJpWuDOsln1OohE9fRLDq8DvMiLCYlh84ysw/nyILrbwxGCujz3jVirkQ3jKnFM+jeLoKFWvKIfSqfDxSj+CCt2zLjOBZnkLXqAM1bdnR1TSX0ktYKtkclWAsR599g3GOmFtvUkTM8GER8HnyVPvBnr5nqZbudjte7PiPc5PWh5X5ugi6NQTa+fAymbTEYL9gHLoTTh8ddoNFtIMReOrBQ+j7RghWhM50R7e5JhmS+9iRqaBQ3+kPWxGwnuSP33RaaV7g4StIuTN87HRAcu1nyxPDc4fFyLi1o2y5jAv0FfRYHCifQCNPh0JnLGYXnv5FycpgGcw1KyJGoYMx6NJF3YHuoH8PHSR+7kuty9Hdt9LlAWPNWE5PNLMy13q+WbWhNqNbk2Yei0MVCnHP1ZfwKTVSxy3AChYX+si2nmO7DvMp2myt5P71UF9VCKuu8s5HNlejKkM4tOZM2fdqomC+i3XOOX24B5tVg+FHtTM06p7uCV8oLaHsmCSCp+uhl6ZC+YH7zQyljQ0Y/RElqqukvl2QVTsm2BxXfObcxYp/bwObKb9rYh+k6MFt07gFlMCzAn6+E9qw6U/J8K/XnNqKUvetMRWnua4lp/RxHKJQhKs4l1zZVtFv/GJaHRaW+Q17QWsH2Mc4NeaNo2fLdaoPwH+fm3UZ8F2O0jTkj7+YdukPx3BHeTTJjYC7wG3ujzGNzMKPkl+9N9pxDuNlbdpy5VIyK8M90hBQ6WZtclzmX2IU+3mSu8D6e5LWkSbs9sAp2KTdZSSo7dw/6YdPNoe/WGzJFkFFlJ2c3Z1zjuzGN8aq8DzVYAXLH7GTuhkQdv7u6D+S+VDIzySSTTDLJJJNM7mmJMYsuf21KMGZJIig0ifVdmi/eY0x7DvFYQlT2ciXtzHtDu0tvNsmTl373EZbc+XJX7VE1ywGZpCeLGDE/qzfRUIg+cGdedWbmWoHHqezb3WOygQDV8WZYSgNoqEdQ7fPSF2/H1B6+jjq5Js4hk8oU85jkXRnuzHTh0eMO0tEVgaR5Fwfin52Y/lp1lr3ZAs3+6V2zLrr8Qi3V83VwZuYdKtkfIiMR2ppp/nzAgemnx3JwIsgLaQg7Dt0iskkTrzdrMjgkdwy6ZYJQUM++/1aGCUFhu+UcGkVkzpjznfmdqFMFqHUnWMR0I5d4iol0l11q0EKHfKSpDAtII+uDPDi+2H870Zah56LDD5/nEEDz7EhztB03g1wqH1FOP25qYIooAVbz1p4GXG7q+EgfgU8z+1bPWpYodKVpA11subZhICYtXcuywVFLlfQdTCe60Fww1+0j2rwA5JvzquczJppP9HKu6Lh10f0erGMe7Np++bvb6RnIKqmiQxprSH+6AiRzsWQRyqViekixR5czK+07zC62O0zt0cH66jPbcX6h60vesVX0sH7TrWOhYOfcB00cIUp/TfeGZD6Zrz3JKW/MIRQuBD4Sk522GBM5ru/cnMhMmsVj82iDusaZ3/ZC8jVhmfziuywbgXxb1p1ykA9nD4+bMJExmlmytA/H0fg0sM6QGJgUN16hqGEBmiveWTfb6YKo3EX+VvA8mkN68tfBnw+TuDdvNWFi9DndKY0wXaGl0FxLc4/fULBfHve8GpTMWinVy9a+nUCbcF+gD5Qn7z5VS312H6vWcRG9PThfcQOw53yU2daMXPfE9l0oe1t4rXeNYNFp6vLK7RxcIIxPoFsFfSrT2+JNqKTkmRtic+aqaBdRsgO4rRQcfRApjaoYyz1nVqfiRSqxE1Uos85Rb7uT+vkQdtM12ShvRlsz7aUnE6cCdKDkj3rcpovja8kpZ1SW82DZqBdd6kI8nilE2y4MmAT2pCbbyVk/PeOCgv4x7xgzWijvNNJ8SZpFk5bLTDVq59LtwWSzOBUo72JzLiYWCm4iPGE4XqslzAX5I2Zw+r4i3axLK1mtIQmEY6ugnKjCbQJKf8GNhxqiy4dmDnLuY8U6rkvHTMIh2eQJZJTw7ihcl+kO1XY+nvtgr/Blv/uSURhlkkkmmWSSSSaZZPJKS+aT+dqUhUJJX7GSgm5ofhjEhPIdF8WHTbWmZOuSJO310smrDdtZzlQSosXgmQdKtto/v3zh8NgSMNt3DQx3It/lnPPxLvZfT0S7gE0sN3g7zrKMDa3mUZcLCFZ5/cJZ3mKIffvgX/N7tiJ2u41+Qnt2HNdZHVVGPjc/Pgu5hYnnPEnwTAH8l8dEbMIbwvSXtotS9ObM29Lo+78nI+yrZU+EjPoDT2a9YB+4Wk5/f8oiItfdd7CeA1D1LupyvW0r6bF5IJT4vj2H4pSmONPvuX40gzas5BPy0Hedoorruji337Pjpl5IHZjt5L+9iWCaXEj133W8gBxv5IP1/IEMzvmU+Njhse8TLNNpWCJ9X2mbwA4gwShD0z37DWjrT80lC8eB62+VfPreeiGhnH5uYZGqhYcOj31d8j4ibH5c85tKx6BHjFRmLQ+itaz0hiSVT3NDIecC+lAQolZl10c7cHPgGQe0Go5KEqE/MGv74rmY6ozzBAOHNjs2nTDN73NATGcL05WO6y0GaNrCnkMfY//tDmxdDmHerpTTR52tOmYCuNisVYiqu+AoIpYo0pqb0/7AGvh50e49Z0na76V5p4X+nM+tmuvYF1nny46EhYiq7893XzIk8zUpw2hzQTN7ijUp2vtyRomYnNnGSxsP9L6HNPl04ftScv5yzcLkF3ilcFpWiJprRQ4q+432PaQM4hrWdQsaTSXBRCama/zYZQTucZO4ySt7zATAhZ5t6OuIEZfTJiHJ9gk+wSsUPMu1sn1EQcF1OOUJiX2O8sPfB9M7WR4+VT5SNGpyvfisIVzsppnmfPYU5lDm9/lvGOYnjxX/PI4p5ov2dZ7PTe6/fnHzSl16nv2b32E3CvZ5VGhJ+9J33+E3Dof3u+cxcppl9QvdtHpmvfjIX/Z7jqF9N4g4xvkEX+dst3DMotw145A0OfY6tvUgP/061mVlyuZYkjpkGUAZCtG3Ifo5zkU397E9+K6yU4jZlbixb/WnX8c5ro++7PsH14c9uLB4VxeO15rJw+2i0M1YTscNl+yg0UiK6kEnaWQHfc+2kqTP8eD9aqHEBtzlc7Bzo9Se4uYj2b7NMZp3SvVgypzrfURZf/eekqlMycwkk0wyySSTTDLJ5BWWGBUGU3bL94ncl0rm1mBfP7L9S4d/k9yVEceeK46BGMVjyKcZQXuqkMxRW30b5f1s7iOHx2UEpBQbFs+fOYCDuqwpkrII8yBRkoOeQ4JqyBWMnVvLIVDrOMkoz82uDeJZq7C8qf64y3zflo1iPVlOJo812NuPmApRtTtd7uxtnXeHk4NQDo5EjaYIRrZT1QWhMFKZ9epRq51+qos9BE603XsZRELex6ILBiFvJiOiK3kb1LUBkuR5pIjc6NjvuNZK7306xXgdCSmatlcmsueRlo9sp7IOgFD4YCbmPydi2jmC7Kc23EBAmg/8ebiaxsPDc9MR3g9uJfPetcHO4XHFBcy1Uee74JD1ucYZdFdD8NZMsHW+h3Sb13MvHh7Py5rzLnROHB5fxvBgej0vDKr6zLlk3q45E+pGO/2900ljxTM0XB2m7yVjxnFE5bxu24Xg9hGUsRweODxeiyvmunKYjMz5hBXkvKyDQ9PnLud9THfq+yIDRRiQ5hkH2IYMWlwEr6gkPVBDBD1edalpxz9Tptbx3gbmo/3ctrmHXKxxP9Vls2otXQaJQzCYJxZ/fj/V0QlEq/vock/Ofvhs9/su2EPW2+kZi2VvnWFCiFRJN1zuit/YTHVURnssl+z4J3tDE9zJPihrAX4Y+zBfXG9as/8bkGy9fi9qPBmS+dqTqKGZDA1dCnISHyEkxjGJXn0WGEaXV+H4U3a+L+1hWkjr8JuqOuJy0vMwcrLmFjcqQFUMRE9IzmjwBhTLna5V3I5S0Yyf7Uh054qTlVaaF1uODuoWaFniMQsaczVz4vcZRNhWu4go9TQ0XDwZQX5DL5rrCqjbXi9N8LVjsqLMoN08NRE3Ioy0Xa3aCbTVT5uI6z1marHvYhaNIihvZgp2ZVkspb8HcMloHeNMzlO1AhWAqbcY8f2G+c+bdB9xGUNIAs8oYE+eDm5yk/nIu0ZwA9BHROm0fi1ZKiHPLkGC/hwWXD++OP6pWHqy7avRKhW3peZ8qNnnGM19gI2fVwC4qK730c/zjpcFw2N2mOYgr9iTUoZlmJf1I2Q/5yYuemUPz8hD4fTXHWADtQs/nZLPUx0nb3J8W/PvolF0PXl66ouk1oou730H/ZkmWc+wwM3kaiHVy8lcGu/XunYebGKjem4mlfWkY5ei338dGb+KTumiqwXdgUp5Ow4LiAbP99lO3hVHODfdlYH3WXcZe90cyNT5PCYjkKQT+P7tbpr7DpwryAz8ErY70+c7MqIUw/Tr7opEZUpmJplkkkkmmWSSSSavtMQsuvy1KEF5lbGDLIKXMo8dp0cySdpOhKzkUCtDio4O0opTIgIkNZRQjaE3XwBDnR2knXTR7b73wSd2sko0deprDdpYzDnHbqAD3AWXHHciiYIZNc5I1vIxqbxo+vLBIDsgj2YO21z0/G08B8TOIQp0h5gFd1oXuZ4lSyRNYuueI97muU6YbuYkutIAir4wtIgM5xOa9mZdRNRiqY9zRHscvyGc/y1x+XQ0b2jaPf3uOeRmkDf8Zi/VszdREvVj+sSVokVuOqiLjyMd48zAIvt03ZhDDmYfzERklK4uHlU3fLXoV54Dks8g/2J+uGSuIyrGvrgNQm5JmokLh8fnwF/Zd++lKwJNrTSTeleG9W7qzwcYA4tDa7YmTyNRyKZz9/DJBQ5/d2XlnMn+6yOE60ghSDP4Qs5eR5S4MiUAUpIa6KgRdXSlY8c/EUqmIe04VJ3fVWIKYce7yzHFNphxucvn83R9gZUJ95cd33JnGn+rqwbOuWRyaLjAGgYSca6vOEaKagXpIjupTDs9O/fRvYrztl9HpknBzUGsF86DDefGtQErGMuw17V9sQNrzwGy5iyUbD2vlCfX3z0hGZL52pSCilpQ8sMk2Taz93jCdk6gXHC6jmjcZNtAJoQDp/AcCbm+fY+bkDvIA3M9f+XweGlgiZWZ9zsYhcI+fwumgx047rRdzukKotznSpN9LSVLC0JL+gwWhZmcVX6YoYP+o97XcjEkBYPm1ZbLjrELfya6P3hZGKY6Y7aIkjNR0tesbDYhdqKdlvudvn2S7UulgNzljp+HPnNUfqoucpqKZRVZfvZ7zrSMSbMOLbHj5i3q9txQUJHxG+qSccnAouWI+0kgTnNo2W1W2A9mu8l0602evI5msD1He8Dc1MbUHaYvglQKZ5zbSgMZYnpQwo5LVEDfzTCc/t4ZjK+ui3693k/jny4yrAcf0euVodvikyL04CvIcVN0G2e2L5XRiqsjKulrWjg89m4hFLrb1J03CpVM0qN5EoYBM+dgY1UvWh/2FxtpgqJi6ecnJgbg5tGPdyqWVLS8L/gQ17WHyHaUm26yf10pbQhIu0OTuCRFfHsN53z0Nudcf45SRtagWfjf+/fmMf7ZFz3d2nwx1TPbbb5oxw03vh2sRZ45gfXUwPzp/XQHhh0FUejBzyec7+4xJVPKlMxMMskkk0wyySSTTF5hiVHKostfezJQXwfaPPx7Rol4m47/XhaARhEpaLlNIZ28y9ip1ocWLSuF6fmBKXSuH8DkXnLNwx33lUY6XnTmgW2kZ2TKriMpDrHzJUedy+hmTEbzRQRs4J7lskupB1TNchN6EyUCOxBJ6CP6iTDQ1F12CCUjY/kMH5RRyiUEajskM2fLpd5cGC6kMkR+k/1elo/InncPYP7ejdzV9N7BCXNdB0Fky/V0z/LQhmxebCQUljXbcWg0zY1EMutI+RldWff7k9GycvABbuizOOf5ZWn6YtDNUsGa1ZcQvcqo1hf7Fj3uoq2rjAZ3pkya1RkMtoN0rpK1XjCAjMF4kk1TSRNoU9MZB9jPPdcpg9z4rjL6aN2ZkhnxvhnWD4+7wbqFGAQafdun1GTwYRUBPX03DhkhfUbJjWDREUySiJ4RvZ4nl5yo9TxRQ3vdPtAuWk1n3ANPVVK77SLQ0c99/Jvj2qPqfvwe/u6QZAYjCm46RKDJwiBJM4iO5ljx44aBNUQNPfcn0fISXLLKJVvWfie9d3M/9TGfnIDR6zRVl1wBZ2FpoQnbZ6ytT8lY4XE85ronn+bOwPbt4iB1LLqgVPJ2PmHQ3D3p/nhPFuqVk3suk2cmmWSSSSaZZJLJ/S9xZC6/k38vQ0IIj4cQfj2E0AkhfJM790UhhKdCCM+GEL7lDp51IYTwkfHxO0MIuyGED4QQPhRC+M8hhLXj7r8vkcycCqor+XzRsXuaj50kNQRewMCAD4seESk5N5OevejS3j2H27pD+BHmls11M6DNoJ/ZXm5f0+TKcOPweKtlkRs65A9JL+F2vgd9+g5NdlaXXDYQ/o5jH5gwhO8haXJaA7urvgYUhgFRBdc1WUdEeDdzm+Y6+p1ZdHG6D1onHvCEkQMEKlSAVDOoSJLilMCJnqfxAfq2GBN66X0yKQXQFp1atejbm4AcvNhEn3fdnL5hRDJrQJya7uPJTUianebQ8tBt5hLCuDpMfbvoEA8TmIQ2XHORa0zBWEC//FjH9p0BEMoqfAxXSxbdXgcQuQEfRR8kQ39GoqTB+W4TBVvPpXFYdQgqeRpP1OhTaBun1E7PbwDNX0KX9ehWBf3S+Fd6ehkgrXPos0R0JantfDmnyTzatwk0b7Nt2/Akvpd90YNZ02ZjnzKRAWoEfnzWJ2ZdOxgyMMw+j23Iub7ngjdJG0dQcy9nUXXr45rqme/Nu0akv/Z6G2i289klbSY5L0s5bxVKF9JXO+98LUsz6RvPKs0nDzVt/73RZhAa5lL33lJuMPFc3c1ptK7Qx7PjrFsbaFRy6/q1m9yklOi4pklb5NOL3nV59QJ/tiT9JUlfyR9DCHlJ3yPpD0u6Ium3Qwg/GWP82Mt49q/EGL9s/LzvlPT1kr5t2sX3pZI5VN9Ec3fAz1Vw5NgU5nSmqbUTbWeeA2HvLiIs1h2JObkYAznbXJQhlUIuvjNDqxiRO+4GTLyb4Yq5rhuTolqHQptzkdNDpuXqpYlxrWLNOgXmF8cEyNzU3gz+6EwqK83q624xKg/AawkFsecCf8qoS5sqz6UQw2RPsu2C+/bNcPPwuBTS5Or7hyV0T/VCE6xkefO2MI/15ZXMtPPg5uds1V53YiY9j2n+2i1bvjZMRhVMoI572i3GqT0Y2bnviDIZiEX3ER9lz8A6BkT0h3bRIuMA3RpKLq6mYqJpsRlwm722Un85YADZwL6XCz0DtHzbGJcK6ANNZ4Jm2TnP+I0GN6NVjAEffNCFFjY0gVOaKs3h5EAnH8zYgEvAATatjbBjrhuirek24Ocqmol3Uf/Vru1ws0VE8eNzfZAiTenzMH175ZP6GZWVhuNOpJK+jyDP4Ph02zlG5+8cHpe9qwWI89nuLceBGpFD/WbOcZWOZUGPmL85ZVpmCHsfFfN6YbILy/jKw6P9/nQwJYcmHZo0oT4aHAGkGPL+2Tfbac7lMza79nn8jo12mj9LLlqdJOsMGus17fjaxRrdR7+ccy4UK2W4guTvQf/HV8FcHmO8JelWCOFL3anPkPRsjPF5SQoh/Kikr5BklMwQwqdJevf4z5+f9I4wmtBnJT17XFkyc3kmmWSSSSaZZJLJJ12iFId39k9aCSG8D/++7hN44RlJl/H3lfFvXr5f0jfGGN8y4dznhBA+IOmSpC9QUkYnyn2JZI6IMejMfQwkADG7dmwuZjXd5eDZbjLXbsN0JknLw7OHx+vh0uGxp+CpgybEcPp5kzG2oOUhAhNydvdNJLMHHkr/HQxg8o7x04RO6Mw44bk1L9SJRqUd6MUD2xY5OHYPHDpI8dQsh892AT1Ek0zwkPs8Bp5s9y4eHtcLNjVgCXx/2+Bf7LnyLA+T6ft8IZmt9/v2m54PFgG5LT7bBoNDItCBwTE0OWyCWzYGxaA/3DgzcCK4gJ6dbvp7R9NdNxgcUgL6vusyTDGIogO6IJ/ulJQmTZzzwSp0iSEdke+LpJfZUUKwV3XOXEfEk+XbhUuHZLOGrcQ0P1cdLZB5Nl1OHGLUhtmUbieXME14gxoDhFj/My5wjWOcSGbFXUfpAI1uOMSO1plTwwuHx3VHV0OXG3rS+KxSjf7kY+9qwT7CYDAil5K0MUjoZQMuAXUX8EmeTGaH67ngrU4OPL4RAWQD66bT6Kc+UiBHaB7uI543ckq2rR1rKDAWo2eQTWinZ/s5M2Kdq6aHFEu2jtrb4E7tTzeD7/cmo+9HkVbMVccgo8MpQVTMWCVJW/3Ul07A9SXn6m8fNHLVmKyLm46/jXROnkbqrkuU1L9jdHUjxvjEq1gaSVIIYUHSQozxl8c//bCkL8YlNJd/s6R/IOkvTnvefalkBgVDwE6+yWWQtDO6WrJ+IpzkjqbRYqQjlJWunbjJ01bUw+mEe17ZEESDK84tLZ3hnXXGEyG9ay2mSW42b01fM7DHkd+w4mcRCC0RjCBdqdi6rMOPkP6G8yVnVmunSbMB89YSUuBJ0jwm7p7op+MiLEHkmTdKsJ/wUp/o5N6QnucmsioUFqMkOfcABmYy1WhvaL+XHKn0kas5v6lqNa0sZRy3Gs6VAQsDS+5NRmUQ6pO6kwpAwfnVnp/BGOqm+vILu+H+hHK8PbDmbSpxp8Fj64VNRSX4QrApDknyPY3oWZLOVJJSeDJ+6uGxV2QYgd8YpLF8EO2G4iCXtD+6ePiI4xOIvj5OSMSfg6JP86LnjbxQTWbxC0hj2nMfzyZt9dN1flNJhgC6grSci0ITfnBz5Jc9hvzf+mR6TkSUAYX130GXCvp7dpz/Yr2TxtRBL7XhMPjvTefWlHxzaWKXpB4US7przBfsWn8yUplMhe1Hvz1Iwo0f68/XEecdbkbrBftsmpZ3EB/QcS5Ks4upPzcxn2x1PUMI3gtFreyU0VmY8PtwS1gpO3YUtNUc8pVvtO3aYVwewHDBPipJ1VxSLAk2+Oh3KvDNY9wI7opEvSLm8hDC10v6C+M/vyTGONlnQ7oqmd312fFvn6j8pKR/e9wF91iNZ5JJJplkkkkmmfx+kFcmujzG+D0xxk8d/5umYErSb0t6NITwYAihJOlPaqQo8lk7knZCCO8Y//Snj3neOyQ9d1zZ7kskM6+8ZoASrebSDp5ImuftMijdHdYM+QyjM93u9tIuuIiItyNp+bCLZYk8grJP53zA/vMuSnYRgUmrJQTCOHRrxiAo6bjqUL8HakxxmMpws13E7/aeTZha+ThvGiW6tYrv8BHClsczNY7PArEIdLZaIDqgqdI+ZndLBIXmH5+1hcgLEZkj6DPqgia7/b7bzTdTX8odEylaycNUCuTB8wzSUmV61ZBor72Hfx9nZiKXHft2dIUg4rlaSihYwSOKACxoAlxwKPg8ILIaTnlggO3GInnAnkhQA+2x44JaCFhu5qwpnUIOXZYpuvHP4Hoi7uTG9N80LbWfb3eiOK3+ZFR+dI4Zv9K4zjnuRJMNKMe51F5nuDHRvpVjWBScMcTI9Ch0+zfrpXZM/e31+L2YV4fWGmX685CIoi3RWiXNs/xej8hSiJzvwfS9ULL3EJnzJmgK2QgCyp1zgWaFGjglW2mNWipZ1x5m7JnGMCJZM3sFkeaLRbseHhTZD9Lvgzi94Q966Xkl585DDmO204mqa5tymvG8ReCekFch8CeEcFLS+yTNSRqGEP6KpDfEGPdCCN8g6eck5SW9O8b40QmP+POS3h1GUac+8Oe2T2aQtCvpa48ry32pZPbVNT6QXUQqVzvwX3Ruflz06cvko0Zn4d9Tw0R7a+Ci0BG1vA2ftpZLSbY8nGxq8bKT20llQlm9L+M+/P6uYPJa6lifTCp4lZAmhE9bsj6eNNEY+hAsQNebfqeFlGRQYDlpSNLJCqPG0+/eZL9nJuTUnk1HlL0Dn8/Xz6UFw/uC/dLB84fHu7pxeExifEk6FdPfrC9G1ko2evXhcjL1V5xLxmI/KdI0N3o6khKU+SKiI13qZ1X3Ee3bm65UszqbyA1MipaGc4ndxwregnvAja799tlc+g7WUc+ZCkkR1oO/Zj7YiOjlMhWAVIYbbTtgP9pOkdPn4ft2Ycaa/ejD9zzuOVWw76WCR5Nd120UuKDNgMHgwJG73xqkjdKpTuoTXbeobIGaiQrPI3OpXl12Un18P7UBzds+1/ipQtpwkj7sFqLiJakEf1LOd2S+kKy7x+WY/BJ7oM+SpDx8N6vY/Bznk+kVZMoByMDJ4lF0yt4+khWsI5c820my8zvF198C5nBmP7yE9UWSrnXS99J068nsKWRl6DXTvHDgNjUkuu9jam671JEkU18EAXvBmdXZ7WvoO7nL5jIzv9Ploe02HqTkKucBrDjl9rn9yf3glhvXTbgotOGi4MGZJtxW5uFe5d87V0zP8wT2d12ibgf1vLKPjfGGRqbwSed+RtLPvMT975fEoJ+/Nv79vSJH1x3IfalkZpJJJplkkkkmmdzbEu/7jD/3pZJZUFlr8cLh30T9yHXGXbkktYEw7uewW3ZRo7OIZM0bU7fdVW8ALThA2jH/3n040xcR4d5whMlELJk+rjm0qEQtpF0dg2R8qkaSRz9QS6jLjOsVFZhoiyYNHAI+jjHTyUQm+gCcdEwLnkd7elN8UpbyFnUlf6A3zVOYNrCI9J9Dx53YhMsC0//5QIJT+QQPPDSXkLiG55RDUxHp82YwmsUri+i/B/a6Jpz16ai/3Z2+Y582p3n0s2ZSGaaTJ4o2Une7T2Q51Rd5RUd/p3FEPs3u0D6vN5wc/LJWtuOwDbJoBvH5VINNuDZ0Oql8uwP7vAHgwhbMHN6S0cHcwAjXbrQWirmwkM6h0psOlrzZt8jw4XtjZeLvkjXXFoCitxzySPRyh+U7BtAhkwOj7CWbxnUOCRJ85O9GO723hgCtgutjrIqyMaHa6wzrBr5936VZZbAkWUW2gWr6cznUX8mlqV3AHMl0sXWHjDLdZt+byMbSkkW6Z5Eoha4g3orDuugb1w973QEsDwsl8NBWXYpejI/iQvr99Izth88dpP5HtwTvukB0kIE/fp6ZK6XrWigSXQ0kaQOWFrprDPzcjKA7MrH0HNK6j6Qj91wQysuLLn9Nyn2pZAYFlaEYUjnoIqMDMz1IUg20HrVhorLxJuzFQlo8V+C8OWjaxfI6Mk4w37bPZkNTVRkLc8UtMlSWaQpqOtNXPS4cHvdIu+PM6lyoypjYfHaRLswhzBtMCg1vUrzVomJKE6qdeVizJHTf79qy0i2BS/QR/1YcX2qmRdWb1ajMkwrHZ22ZRsDuM4jw+zfaMEE7hYJ9kZHs80W7ENTn0yIBa7Tivl+A0t9r5VSGA5d9ah3rHjcK9Pdy6bGNqZp+hJ48mawFXVA2tRyhfg0mVJory45yiH5723jEMx1LG0NFf4Cx6zcopAWaw3VH+gT+zqFeW84lQ1PotJaddYrK2tUmXAWceYz1QmkdZz+GdOEkWnZ+4VxvuQmeB+WLZPs2M1tVnNLFbFt0k/B+tXTDoPI4X7LX8Ta6a/g2rJg+AqWhZ8t3MAR1D8au39hXMR/znN+IkyHEzJcOeOgBeOAGlorQcrT9gzR79N2sFvx4QLmx+fQbdlJ3MUmDt8ZGaIzU0T09Gs3inLbXym6uKgD8wAZxp2fXTbY1/b29CwWjyLnZ67pxV8FcnTOK7vQ14Z6UDMnMJJNMMskkk0wyyeQVlZiZy1+TklfOBFXMFiY7eXfuMGfo/sAiGSTYLsAs2XQ8XrvIq91ArvFKzppaiuD/Y+5cT8aeB+63OkymlkXwvElSB7s/csBVXa7BGUQPMjr3iNkUu+elcqqLIXbsFYdGET3ixnLgBlQdW1pe5/P3Eik8iNh+Dy3ay1zhA8OnafvAPKL9T4TUHj5ql1G4FTrqOySDKMd2B3nvXR9jG1reUpficCbdV1hN1xVbFuGl0/0ukOWmCwpYRMQqEQWmm/SmzDqKRxNUy7Uh2418ph2Xt30ASGUG47Pl0N4Nk8c5Pfx0fsE9D+gq2QeORBynY5I7e75Pjoc+GAyu9uz4J4pVjqcOj/dcqkaaZOcQaevHAL+DKGe7P/n7JDuWaVav+MgwyBo4gj0KNsA3BYN+TkceiRj5cUOEnG3YaHj+y8nBar4NaeVgf5vxJPB9WILAVuEj+smvm0NZj+P7bGMO8nPzOaVkDHQPOOgnxLjrxgMD4fZ6mPcdKkzWA9ayNwt7RPC2RB+RfofX8XmcJxaKfm5O38s85kuOBP5pjCl2Z/+97MMlIMS1vF03d7EuM7i06WKtGmCACZ6k+l6QVyd3+T0jr7qSOU7I/j5JV2OMXxZCeFDSj0palvR+SX82xtgNITygUXqiVY2Su/+ZGOOV8TPOS/o+jUhEo0Zkoy9Oe2dXPV0O1w//nu/BHAoTCvNNS9aE14bPY0lWoaiFNFnTdOgnZOY8p2K5NLQRzMsgU+Yj/CLN/NHMu+x9QadluvFE6GtVmmvS77MFOxBXK2kyrMOsW+ukuqwWnEIcJi+Qw659NnPYtqBgLxW9EpeOK30qe3aA7sHvjNH9+WOc0Lh47MbJplDJuiv4/N30012G8jh0bcM+wkjiA0dhZNa6Yxa+IRaGWUSR1vJ3ZiSi6dxHq5JvnuZLbxrlItEGeXIlZ78pgqqEZs18zpp4uYbRpaDm6ujj3eQyst8CRZhzeWDZyUyw6bIYzXTsfbfF+5YGzAfb2js8jkdWb5oO03vLzv3G+nVD4WFE72D6QlRDJjCOIckq9nzvkQ2AJvuFdR3BPKUusCO4b1qtpDqrY/fizeBUpLsoQtctvJbVArQ2Trk1G1XUha9z++zJSr5kN4I1KLQbjjtpewh/fmz86NY0yNm6pA9vD5mj2i3LepDHPLZbnz6uz8Nba5lz9mnbtjnM+20wcF0+sO5e07w1fHYyJoQgnZFnzGhw04Q5Y99px+ybEW2z7TIDNRGzUINfd39oXShutqe3/T0hUzIh3S/yyXBX+MuSnsTff1/SP44xPiJpW9LXjH//3yT9UIzxzZL+tqTvxD0/JOkfxhhfr1GCd+vFnUkmmWSSSSaZZPJakqjRDupO/r1G5VVFMkMIZyV9qaS/K+l/DiNY4g9K+u/Hl/ygpG+X9M8lvUHS/zz+/Rcl/fvxM94gqRBjfI8kxRgnh2JChurrQMk8XQRSsocIP5/3mqZM5kn20aU3kM/3oJV2UM1gIzGbw53D4wpSYO27/NUt5MtlHvPZYHeWs8hRPi21pSQNsIM/QB7zfHBO/IbklxHgLjhnCk8mg07aLpKb5OxEpnbdWCFId6IIZMSZB5eRFrGK1JGbHfvA3b30veSy89GgRH+ZDtAHOlDKMLnPOLSM5jg68ftd3IV6uo/BVm1HKr9/I/XNGQSeDFrOlAb3heZ+6i/kzPTlY7uXgGR6omwCDGz3XReU1RxODvapDuz4otC9YM6Z3xYBYu/jVZ5AfCEmxGetnPrOqZp9HjlcyQ8ZXOvsMVoVVg0fcDDEfHAqIoFA2fLQbnZS4fO5yWilZJHgAYOUUC+eKP8KQB2ipO04PdiK0nMIJfs20eMdx/05g4hyIqjebL0Mbsd5dAPvBsO2Ya57b3UheJ4HYeWec2XgTEj08gjCC+SW8/583tbXCpjyF/AdSz07/q800nXMn76MAFKfonMXpuUCUH4mKpAsufgKCNMPHHMFo7I5XkPZuTzMwhyNAMN5R8a+ABcPrgHzRTtXrdXT95KTc6dr63IVUeQmn32037E0TNc1YBnJ+6DM4eS+fYzh5x6UmEWX/x7luzUi8bw9My1L2onxcMRfkXTbTvBBSX9c0j+R9MckzYYQliW9TqMURz8h6UFJ/1nSt8Ro7T0hhK+T9HWSVAozWonnD89xMWI0sjehtDDxkhbER6GSAHwaPZIk1UBhMgPfyLKLGveRnofXOXOj8Q8EZUvBjar5/uScvWW3UJHyptGnwuNohowJL91D/xav6NJUSLPfiZotRClHf57ps4OhTjKZbew9p4rp28s90EHJTvCk09kGyb3PP32+kFwtaCb2/nxsm+1u6gcLLuvFEib84/y/9g9Ajo0JudWyz7veSBPv5eYxmYvMhiL9zohy34JUfpYr0/NFc5HIw4RqfU6tmfOybh4eL/XOmOuYbWcOj3jDou07T+2kDcEJKJYPz1hllD5yl24lRdwzE9CflJQ8Hbe4ket5vpgKeFz/bQzSAl539UKFO0xpj5b3M8Piy3rOu7FLkzEVq6ZLCCFG6nJMuU8iObtxb8lN9nuX7BitOVecBYyHOuqy7lYm0mnRD/kF6/Ggza6dg2+Ld2Wgok/2kLmiI0IvTS57cBWzWMKmpJ3GAN/q2T0GJi868om7DecqwstPVkCf1bdl3emlOaNSgBK9aOeM3HJqa545/YytzC24QxFD8Mxwu630vVW4U3mfUW5iOQf5TE8nqnlcl45vOmfL54Yp5mEGmZp8Jq+lEiPy7zFE8DaSeR/Lq2YuDyF8maRbY+b4O5FvkvR5IYTflfR5GiVtH2ikCH/O+PynS3pI0rv8zTHG740xPhFjfKKQm45GZZJJJplkkkkmmdwTkpnLP2H5bEl/NITwJZIqGuXQ/CeSFkIIhTGaeVYjZVLjpO5/XJJCCDOS/psY404I4YqkD8QYnx+f+/eSPlPSv7zTgjDAh0hVywX+lGFOJkFv0UUmb+YTCkOi9gNZHr/WIJnmTuYePDyuRasEE8kg4a9HurjLfmCGhNW2Az6/n57xkXZKmbjYsTvaMszOdMg/fYyO3gA6uIn0Z55A+ASeMV9kFKp9Hgnd69h9e1BoCeTCdC6/3LQo0wacvAvg8Rs49HgfeeXnkefeuzxc7yUT6gPlhDjPukCnGx0EigEZWa3abfpDQNnyMLv67105kfpm9SxMVS2L1NSvEAE5fXi86zjqtpFLnmY15s3uOiiTUcHMZ09kcPQd6Ry7rI8a3W2DmSAQXbDvZTKA180CLXPmPKYkZXrC01VbR7mQ+izJ+28NrOcNgz46QOnazsxJU/oCsCDfhnX0kRLQN2/2J3JFxLMGPl6PkhZyk02FV1z09n4/lZ1m4ZJjRyCyOQOXnYLjlyQCOAP0ctYR4NMVZBqCJUkE2WYxzVbcnJYDArUPq8tDs7Z8tVaqZ3KT1oKd+9jVmfJ3vu+D0IgiIvLfB8kBrd3FvPhiTGuFJ7avgOGCxPaVkrdgpWMSn5MzU5JOgCc3z6AbHzSGvhTx8LZDRpnEgKjkrDOXL8+CjxjnKk27kPA7OObrhemI55kquJPnbPnmtpIFZA9RY74vPjaX2ne5btvgrsvvAwqjVw3JjDF+a4zxbIzxgqQ/Kem/xBj/tEb+lv/t+LKvlvQfJCmEsBLCobb1rRpFmkvSb2ukmN52bvmDkj72apU7k0wyySSTTDLJ5JMhcRjv6N9rVe4GT+Y3S/rREMJ3SPpdJUTynZK+M4QQJf2ypK+XpBjjIITwTZJ+YRw49H5J/+K4Fww1NCkie/R3QdBO3n0+kUgG+xQchdHZwcOHx0RGBvADlaTr4MkMQEZ3w565bg0ZZwphOpL5lqV07onFhMKU83Zn+cEKfFBvJbqkWQcjcmfJnSD9YCSpP2SZgPZgd+vRKKY/C0Ah1soWjTpfT+1UBpK551BXIhnH0WQwYGCIOm87CMX4u+IRhTh93+WzFVEYLHF+JqGmr5uz95wDykakoOuybXQQSFDpAJlzoEQPCCWzBvk5ab2DNHpEG+mj5NAy/rkN6imPFJAjkRmO9nuOggtu1DPwk/YcqyeAGD06m1CIvEO3brXBH4oiLTrEk8EmzKYy4zhWp9HcRBcgWAoMkkm/e2onjre28Xm2jbgMp7QbAFqIXtadLyN9FkuGX9JaXVr7ae6iD6UPZtrNpUDJbaBvNdmAOaK49Gn1gUnnaukb54tI1zmY3sdWSui/9nGmDYMmt9P4iYdHeXCx7jmYnn9tgKPSBzCdq6U+y7FbcH2RPKj9IfplI82/vt05V9VNX7HPBu2uQRS9BYsBOUQUo3te7AD2x0Th/RWnuRgX3XUltFt1No295T1rAegBrc0DrXzjnB2vS3ge3zTjkNYryLbXRf/Y7vj6g4/ncMpH3U25zymMPilKZozxvZLeOz5+XiMaIn/Nj0v68Sn3v0fSm+/0fUMN1EQU+eIQRLkhdfRmsI7OFZiJmHas4czqNBkx5+yMU+JODRJRM6OlX9i3g28DXHvzSHv3cNWagj9tMSlkDy3vHB7vNu1iyYjhBaxAfuJm3+Y3NV2wGx3AjZkJRPQ3nRm3ytSb0NEXS9Z5m4pltZgmm6VZG5hQBLFvs5me3XPKGfn5agUqP3YgryNKuwkFYN9dR2LgNSgDflGNB+m9ywhmeHzWmmdO1NJ3bcJh/pkDa1q6ssHF3Ub4UtZ3wUZQRL7inG3EW5208LHduJD49HM7mKxvgc+UecIlu0CSt9AvqoYjNEfWA/temh47zGPuejCV9GNiboyJkUkCDKm/pKEY/Qo3DhehvVBigAryWbvZ9GSVwVbpuo9tO25XKEC9ITdQqayrZXvPyUpqDypg211n7oXiTHcA7wJ0YnAuPQMKp4/AZ/DK2Xp610nnYtNDG1J5WSzZ72DZ+9P3O2YDxf7RGkxXOGmGDT7IE5uhmS5SQrrHsW8ugMmh4BhHyHM7x8h4LB1V52bCYCYGGB24b7+FbnqpmfqiT+9IiVCm+pvuuvW03rTW0Xfadh1h9Pp6Jx2fq9lxU8AmIgfXqHJhevmWkBzilHNvIYiw3U39lMkmJEu6TpeTRReoe7WVOmf7mP5yVyRK6vuV+f6S+zLjTyaZZJJJJplkksk9Lb8PfDLvSyUzKCgPk1YH9DU0nRed8zud3PtTMmBIUgPBIUEpGMRTMRQNN16S2aJFEWa1jHPpys9esWWYQ/BLGbvY1ZINYHgICNkHttMuvWI3eAbJrICLbblkOz1TSZrywETkTZ58dhe76t2e7XIMjuAOtud2dwfYwa8j2OdW2yI3u0DpbrQmp+iTXEpCoG9HMn6gDRnM5BGPAwTaMIXjTNGagijcVXecGWeaWWfoft/ppHo5P58QiqJzzt8CwvUMTKhbXaJt9l112KAXYQI8cGZwZuwg32fZZWN5qJ764o0WAsg6FvEYxsnTUusIZUt6fhmoX9NlBmoCkVkwnIE2swppuEhn5qnEFgBjz2Aon3EJg5iBiUiQp6gxdDo5opLpmofqtnHoEkA0//FZW+fbsEJcQlBQa2jrklnCyuCKrbjsKczyc4B23+naOpoDosW+XXPBKj2gnH2gvQWHWm9NQbR23fBqoRPTIuM8PNTHuGZQ0FzJXjgDS0sNyNxM2bobsOz1AwZspd8fmrN19AaYiUu5dPx8w85pNwEcGleX3HQE7AY4c5d3XGa7uclKjbfalk02sPS7R4877dSXCkDcc86sTvP+iUqqS291oeWBqHXTUadtoFD7CJjrOZcRIrJD5/pyT0imZL72JCgYBZK+l/SN7LpI4gFMQS2YKHPOtLQcHzk87qODkGtSsr5SNK96rz+SKT8wkyZ1H8VHv5MGJiLylEnSB3ZAEO9JzSA0Ba1AA/Wp32iyoE8QJ6Weu4e+ans9KpnOZJSnKR5uCL6smFDJz1k+EoWajjtYcDwn4hJ2BKyHHacEn0RS9wfr8Hly791H1P2D9dSey1XbxwpYZAtQlv13zECxz0NZGbrFnL6c2zALLbm+fWE2bUReD1/GDSg/3egV3ck8qJ4TtQelqW/q2SmFWJeZVnIp5yL/MY62DVefLd8BruMyutGx43Wjm77xcjPVS8+lVmQf6YBUfndoN3FvLCf3G/oeVpwCVc1PnhtWynahY95qct4uGI5G++xKHgkE0CVWynZ2OQVe2qtNLN7BKvbMu16E2wBT90lSD9yOJTA5LJdtGzLoewdj3pOxn4DZn2d6rq3JPGETQtjn8fmb3Ki6CGaeYp/1rhunq0nDozvPloucPsD438d8twXezpWeraOLTfhkwud2w2W2neaTedVx5tInswqXltae5zBFnaOdvE8m/WdbKIPf/hpAoYXUsR0L4rDsC6jLc4s2RoEb5HArxSs8e2C/l+5LgyGJ4235yARwHDfx3ZLXclDPnch9qWRmkkkmmWSSSSaZ3NPy+4CM/b5UMnPKqYogHjq5M4gn53bBJZiJOkj16CMsZ5CmcgZwpTeXt4AiHsCs481lTJO4hWALbzah6YAmMu/MTDMRd+xM2yZJD4KYrpqf3tGJltH0SBOKNzMzmJOR3Y2+Rx5S2dfyCWXymXxuHRCdTfV1vW136YwsJELkszatVibvaK81bF0ykvoCIuFnXQRzf5jcJjrYOXdd2xgkE8ED3pzXBHrcaqbjpnMPYMDBKbAMBIeMtoDQ3mhPDpjx/ufbHZpD0/c2ooVaOmGyO8UsMl5JLn0i3FF8Ss0axsMcEI/WwE5XnJvJk7np0N5bNk4hvcdlqdkdpv5HBM9ngcqFhGQ+UEt1MVOcHuhQgEl2d862IaPkaXnoTPfYMZlVKCUXRc2+yCDFfG/BXFfrp7mPKSeLbomgab8MtMwDRORfnQcKG47JuGJYI9y5NuYguknQ3UNyWdGAXnrrEeK1tFpKiNuDdW+hSB9SBTJH5FKybkA02TMj1JsXbNvMoF6eP8Cc1rTXMU0qI6+9+Xi9k56xCktI3825JmXVYDqyR+sK6X49ytzCnNRAQOUNh/Z2jdUvlbXTtX1sHab+/3IrubTsuGlmpzvZutJ3ShutTjHee0hmpmS+JiWYqEgqljSR16L1ySIhbiHAV9CZy0vwP2SWxOOQeJP7eWAX6bViGowkvd5z+af3YXYqYtHyitZVBGYz4J1KpSQ9MpsKtQIi342OXaT5Xi4SnAq9Esco3gVoUDWnzNbh58QJoNXzCkU6R5P2nptAOZGRMH3JOaQuI8p1B/XcHNjFm769m1hkvL8RF60qlL3Zqst7je9gWjhvquImgpOwfy99xvpYdKLz3aT5/SwIji8iFeWBc63YAWH9ACZFH21dwvigCXq1YttwFW1QaiSlfMdtfmZhOiQ9V8P7ZHYnT85H/FtxWTPSJ3v69Mcc3d5kvNFOD1yHaf44HzT67B04/fAmbJGMVmcSA78ODUgrdoxvHvulJ8en0FWAimTejeuCJpsefdrL9TY2WtiIzzkqJj59F9REXhnosQ2hGPnNKBUM0rKxXiXrR8zEDDdchPUq3A+2qWT2p8+ReLQWy3TLsbsGmqM3oUD5xBY+heU0Yb1w8z67ZOeg8gnMQc9BeXfMBHTXol/ypnNH2Ya7FseA97/nRpAbiuUV645y7lQyn1+4tnV4/J+efMBc9wJ80PZ6NJfb+jIsF8eAKXdFYjxKln+fyatGxp5JJplkkkkmmWSSyWSJGlHH3cm/lyMhhD8dQvhQCOHDIYRfCyG8Bee+KITwVAjh2RDCt9zBsy6EED4yPn5nCGE3hPCB8fP/cwhh7bj770skMyqqBxNeHaZzHldcqkGmj5uPCWnxQSOMZNvDbm3G2TynoeAMKpCkDSBpM8VUvoedvzaJxxlA49MB0vf/oEfk0ZFFw1xTwbPzjlOOQQcMuukiQrUztLt0S+ie3rvsyNjLMB+TbNtHUV9rEUVMv/v0c6zzm93Unj6fPc1su2gOH/nvSbAP73dO7dcRYXm6AjcJZ96mmZNp4Z5y6PEqgkOWGHzg6o99gqZ4H52+haAgotGzPiYAcqoKEy9QobJjEmC0eRGuJG9asM+bJepqiPJ9ZDJSSdaS5aHgELtKHmlg8bmzrs1aCKBZzKVgK4947AMJ6gOnfzh30lxHtPyje6nsNZdq9GQltVsdiGzPRXZXUZ/G4oF5wfPL1sA0QfSo5rgJTZAcELKii/yfQ5pKVkvXjWsTJINK94F/uSlmnYYzz7bBg5rDs30b8q4FILxt51JAdyNyYZZy3tJCtxWk9XWwC12Feib4zV54rc3r0u90f/j4nkuBiW88Dqu8fMCUiSDDd1PTQmnyXLW3aeeqOgJNDw4Q5OXGoQ/SOrzHtSEtPLMYuz44knW7CMtKZdER5WM+bsNV6ETFrpsXYY6vmL7t1gQTra57S149n8wXJH1ejHE7hPDFkr5X0tvDiDD2eyT9YUlXJP12COEnY4wvJ4vir8QYv0ySQgjfqVHinG+bdvF9qWQGWToiKpNU8DZy6+a+SkwLUEvJxJBzgG/EtmITpuq2M6EwQ0yrT7LYurluvjh5pWeOaUlaBf0KI1mbbW+6mdxpZ1yE5TTrmTfd3oICZKlioHC6SF1aANpDLkY+anQyxc9+19YJaS0YfbzjXApoGomRZbXlY35h1pf3D6SZiCaejltkaAqiQuDN5TR934QC6v0hmVGkBOWsUnXZMSrp+TSbViv2upVBUtZI+8T2zFdtu6+WU1kvIRL2asMWln5wpyqp3VbL3gyevmOrlxamqw3bhjRBX9lLZusNlwWK/reL5eOW6cniN4/M2lTG1DjnmPdLRrlKv3vTLRffF5BAoOFMy+ybLAMpkTwV1uxMandDReaYJkh6vcmc9Ucoxyab5nNukmgOU+G3euh7zoVio82FHd9UnQ7JcJ646eY+v5FOv3tzOf0/0+8tZ5I8GKb6ZA72I4pbkVH8qZ2uu80j2QM4HiL62JGc9SYLFK+zZWBT8ZyPATDPJsm9Ux57mM85H/n+y7nazOHON3K7iLkULi233Ma5gXmWVbF7zfadFujNNhppEGx1p7uFcdPgaageAivIUmnyenNX5VVQMmOMv4Y/f0PS2fHxZ0h6dpwURyGEH5X0FXKpukMIn6aU2vvnJ71jnIFxVtKzx5UlM5dnkkkmmWSSSSaZ3AV5GebylRDC+/Dv6+7wFV8j6WfHx2ckXca5K+PfvHy/pG+MMb5lwrnPCSF8QNIlSV+gpIxOlPsSyRxqqBaCfXzgzm3xucs7MJdHmMv8/R1Exg6xtexFa5Kdww6vjpRiR5CMwWRT5LwzfzCghKAkzUeS3cm9sJ9edq1pd3gP1IlspN89wkmTNJEDOvv3XAQuUVzef6pqQ31pPmYkts/HzmhJmkOKwSI3L8BsUs9PRyj2iF4Cka271G8VOIrTFJR3qDV99ffgyrDTsH2ib3Iww6zuOFZ5Lp8nOuP6BBCuKsxJJYciHmzT7JQQKEbJexN7LZ9QhCLQnoZL78ZzDJz2eeWJrlwHjWfLwbgMNiF6NO8iqlcqCQGhKS4f/PPSd9FsmncdnUjT/jD10xste91MYTLKSZcJSVoq0kSefvffW0OfY+AK0R6fxpARwzmMh3LRB66lY6Jg0aG4Pu/6bWk7WI0t34H1wrseEGVj26w7hJKpOPkmj1wSZdtDwNeOu5DzDseyD6Yhsf/+II2bRt8ilIyk5kzjrT10oTDcyWj4DVdHa5gajmN5eMNCqsC3L6V1zQfCXYNVjeZ8H13OOYTWDz9e9yP7Zfq95LQGWpkWkNq24p73QinVLd2NLtjHafkE1u6t1MeutexcSh7Zm63pSHDPWNLuMVzt5ZnLN2KMT7ycx4cQPl8jJfMdL+OeBUkLMcZfHv/0w5K+GJfQXP7Nkv6BpL847Xn3pZJZUFFrw5P4O3WsPSqfx7D/16EwlsJ0xzWaU4fOHHKjw/zMiEjP2WpnFDQn/003IT+W0pqbCcFPyPRTOlNLZXcWsiP+TLdl3pHAb4Aag0omrfLMmiHZqErSmQydSaZGxQiTYcNFJnKR2YE59WbHmf1Qfw34zlZcndNURcWjdYzTDpWXkluU+efMlHzskrQ/SJMrFwK/oaDZqQulteZ0AfphtlEveRdFyRzxO134t6IRvRsd3QNY/5+14il90vENKFqN/nR7HvMOe/orPmMe5jLvB8eFnc3mzX7ssyarj2MSaMfUF2sw/84Upk+T3KB40y2plK7AtLfZsX1ie5hOniikQU7zYMeZPKlYDkiZ5eqcDBXr2BUG19g0l9MM7q8zFEZg4Cg7JY5/U0HxcxUj7fkEr/NyU033Fk+8fQK7ZfYJZieSpL1h+salQlIffSavG1Dces4MS5lhunLU+RomP6+wU7dg4o6Kc2uiXzh9bn0/DwBDWH+e9cD43KJfefWLvvgziM533iMG/OCm0M/1FCrpbceOcmMrucjchGK57xJ5sB/sGL4ve90WNsW1wr2mZEbFYxKm3KmEEL5e0l8Y//klMcZrIYQ3S/o+SV8cY9wcn7sq6RxuPTv+7ROVn5T0b4+74B6r8UwyySSTTDLJJJPfJzK8w3/HSIzxe2KMnzr+dy2EcF7ST0j6szHGp3Hpb0t6NITwYAihJOlPaqQo8lk7knZCCLfRzz99zKvfIem548p2XyKZXbX1Yu7Jw79X4vnD4zLSTXaCDcpohN2Jx55PswKUsxyAtLjglw7Sd7WVUM32wCY5XiilSPYqdloFhyJswUmbgT8Vh1rVsBPmTr/uWpvnmI/2wJlXNrtEgogAMjpyuhns9bPp2x8+sWWuy6HsTQRHzFdcwAzKR3O5dy4nslRClLzn8YwG+ZqOjPBP7sz7cfr+jLv0csmjfuncSezSd/vW7E/TcAnIcseZZHcRdf/A2e3D42LNzkrb+yDbRhsSrfRIJr9jtjB9liOq/hBSanqyaCKURJYWSxbJYLAKg6i84z/BKWKD+871gAFqRLA2c5vmuuW4rEmy37fII90w6Opyo+WSO0yJvh445HYtn9DLGgjOH0Ab+gh8oj01uDwUXWrLGbjS0CTORAXS0fFxW6KzzpAv1VsHKESZF2Dk8FHn0yyFPrXtLlCrY+g+TQIMip+fiF7yE30aXgavFTEerjqXEeaZH0wJoqo7hNLyRqZjPwdtY/5lMFnLja/FUuqLy2Af8OO6iSQfHP+na01zHVPlNvtpzWo7xJ4sGbxn3fFp7nbZF+Ga0raBPx6hPbzOrUurmDIPDE+pi2rH47ybwz0hr06R/pakZUn/bGyN6McYn4gx9kMI3yDp5zSCfN8dY/zohPv/vKR3h5FvhQ/8ue2TGSTtSvra4wpyXyqZBZWMYllFdPleLhG9buuauc/6YaZFeeh8S2pQEmlq9TnO92IyzfeRK/h00Sqt5+qTTTwe2ff0P7flZsc2I32WqpjYztdsbz5dpTk5feOS8yIYQDHfQRE42TejLduFerrnLPJmD9zE2MdESwWs48zlFZp7oVi6eVsrVZjcYTr0kcSMQl+B76yf4Nge9IHaP0IMDjMiJt2icz0gifYJ5DVfKlulmpM1fapaPi93O/XT60+nfll1Pq03MJF7svJp93ifr9uy5iLX+3heY0A/ODtuuCmh6TDn2oa5rk02HNd32P/Y5zedC8VGG0wMSMbQ0La5rgSXj5qW0nUuw1ELnZYm40bftk2uOHn18MoZN5YNRJrTVLvgHOHYX5i4oOXajFHP9BX0LgptRI0zExKzIEl2HNXhRuTp26hQ0b/YK4hMzkDlxUdOc+NMN589F+lMczffdb1p+zbrgr6bj87aeuFmj99Bf/uR0D0ovZgUct5dib0FybWO+BQyaxN9CqOmK+x0LfFKXNnRXB3e755HheyxuTSHV9w8wQxsnDOaA/+8dLwNwGTNuloagIGb+ZqL6GdaqOt4+JWGnZ+2QDJfOmZjdFckvjq5y2OMX6spyl+M8Wck/cxL3P9+SQz6+Wvj398ruRSILyH3WI1nkkkmmWSSSSaZ/D6R+zvhz+8PJbMZkhlgdZhMYotaNNfRfEaUYyi7c+uFtFMqA8ksu51qs592f0xz2XKcjQNwei6VgUJ6M7ghdE7PqzvEaB5e5HS09zlnaTZl2a+07I7R8lxq4jHJnCVr/tkgaa7bRRdghiVxuY+ifg75bLe66eHMwy1JNxFRwvSdHslkMJgQ8D5TdHmvO0Tm0jeWHeEvnfMvNRJyXt20mz4GApH/cr9lUTAiAg3sxH26TaZuY9S4Jy6v413zNNkDTfVIBl0oNlCG3tCROxdsf74tPh87kcyF0mTzrCSdrsCEB55Rby5vD1KZCAb0vYkXf5/NpzFfdpHELbBL0Cw874j8aXamefuM9YIxqDiDApdduk0GxjCHAQPmPDE2AyJWQPpezHkkDlHPKIMPPmTKSX5f01lJFgqTkyJ0XRcAJ78lOHeoDU25ZKHwVpwyvusmxrx3FeLX28AaFwyGF8+ggEU376xgfJDztuDG/0d3k8sD51y+1/d4BtCswfTbcUoH38Q5PLg5jWOFbkneXN5FQBqDBU8u7JvrWkDSr+2n72sPbJ/gOsJ0mx61nkfgFIMjfcT3i1tpjN7q3JmViVLxkDHLei9ayzMlM5NMMskkk0wyySSTV1JilOJk74X7Ru5LJXOgnnZytw7/nh+uHB4fANX06FYfWX7Kgt+l47/sA9nch39WziFBYUrw/lLZZ7NB8As63KxrHe7kSGVxxvm0bPfStpg+WSsuCOUsUvZV8byFknV0+gh26cx+1AJ64XfLRCXq5MJ0PmMH9K8EUrvZtoEw9BdcQPX53e1TgC/2QkKSfdamC4Xkc0eeQqZIlKQe0t7R8fyqc499ejdtRy8A0XKgmvZcOsppwiCvM0AU58q2bUqopyf36CvskFtUE7OYEDGuOpR5DqhEPQ9/RRcExDYg4hbddSwRGUc8bQzT1hG9ZJ1Ilm9yH+2WC/Y6nqMv3lLeQo/NIdJoKvWdU2HBXOezQt2WuoPfyJNJxL3lApNWK+nvXfj28n7v32rLk77Xc4ROvWdo25p+uj3ggZ7CiNyi/F7/Vlo5lhHINXRRLXsYRzzj2YLYxxj4d8qhx5w/rzURpOTeW8zRJzB9x1LJ+t/OYLwxiM+jiETtelOaYMVOaXqgRp5RrAEOtSYi+9AM/Nvd3MdnMKCyWLb9tYAAoY29ZCHy1iOm+X1weefwuO38wreRZYqWuJmCneuuNFNjseQeyWQ5OG+13LDj2na1mdqp7VKhVvKprb115a5LVGYuf21KMAoeydQDHIk7uYa5q42FpQ5Tem1o00AuIKL8JPI7r7et5rExfP7weC08kn7vWEWhXkyD8XVwPD/lcrWeqicFmfxmzx7YmZbpthYxwfvIOjpsl7CIeU4+RlXTPDUtClCyi9YO0gF6wm9OZFQsfVmZI/4Konj3nLLHjQMDvvyGgoolyeu3HZFfA9GmO2gO73S/WkllYjT+TUcgvAyTdjmXJkNfL5xou2bRsRM8FS/W+WkXnLMKk2oJCvsjr7MR1pT5m6n+rmEh2XTKHiPPZ6EYeXJnBjDQPLvn6nwNC9Xji4nl4cCllXyxsXB4vNGhCdV+Rx5KJxWAvjPdMnatCt92b35jasW3Laf2OFt1BPj9yUqY5xk0ZmeU6RrSxZa79qZVKA4mBanb1zLyd61KQn37vO1u+vgcxvVs3vY3mn8Z7OMjpyk0l3su4SqUPz5i1SlGLfSdacTxkrSPqG9uXnzUODeT++C1nBYUJ0mVeqqjEzN27Xh8Nq0Rl1s0v6dr6i4fO91MaKb37B7na2nOOHti5/C47VxstrEODPCMvNvslZBmcWUO5O4tqxTSq4tjz/NuMkiRsutce3gX146+UzLni5MDXDe6tnybmI8J8FRytm8zKHMaN/TdFA9E3G9ynyqZmWSSSSaZZJJJJve2ZD6Zr0HJKa9aTNyTPbDodXNp+1Nwn58HJQdRzWLOIigdBD70pqSBk6TFkIj1y0DVDqJFKIsImqEps+7Ml3TqpxP65zj6m9OVhMK0sUs863jQlmAubwPVfArm8dEz6LxO1IQIp8s00ufukRyXdkRtgBuTdBV+N78EU9W5GoJ73G6ZaeGu7ad2rzmXB2Z+6QAp9OnxiAzV8KqBQ8H2cEw0xCOyRHX3UOf+e2eAPpAapzOw9Uf0h9ldLrvgLaIPb1xL6GUe1eKszKrBBDUL1GXWBfoQSSN336zrv0TVzs+kF19p2G+v5FK7nTqZajbngjw+HwjKz1xPKM6ss4nNoJL4BNIeSdbUT4qfgRvY5eCgyLF4Ciimgrzh6VcgO4Y/MJX1kRnwX7p+NA1x8/QyDFAjwrvVtv2I38vW8KbHKs4y8GLX1eVSeXL5fLAGy3eiMh0FZ8a04pBzi+07zNjF9vVtaPhNMS16CwUtDN0WMrM5K85DM+kh19pp/mSgiee/3GUmr2PcIWhJIkI5cAgg3Y2YRcdn1KnCktZEv8znppeByONzu3PmHNeYpRKDYl2Q15R78m4Of7GZ1kMC0D5b1NO76TtejDcOjx8Kp8x1RJC9leOuS2Yuf21KXnktDJOixbSQPUyaBe8ziT/7yMXdk1UKOeFZ85HtwdVuMqHkETZadIsUIzM5yZ1yJpmZelImS5VUvsa+NSPMwtxwAgv9rCM4n5lF+rikU+tTlnbNdb+5nlwHGgMuMlAuXMR8E/58NOnu9LxiD+4+TOhekeFiwvqrusl5EaZvukbM520dnQE3KSe/va7tEzTr0g/ruExgNMn47+UkzIXUK7d7MPv1hqWJ90jWT7QNk+Kb5g/Mdedhdq6j3el03tuzZWg30rgh9+d1p8CerydT/Kl66rOej68FpXD1ANy1PftefuH+Trou576dXIAcQ0M3q3WwIdjugIvVp/lD+5Kc3Eers60+tJW+0fugLRRTeWmm3+nY59FUfaqW6pbctd5EebE5OcrbK5n05aSS4wmrt5Uii2diUthz0dd5qlyOlDmnVJaxITjAhtNHg9PVgkr6kRSCJmp5MremJHEP1sSc1BlOX8nZnttu/JNjkkkRNp0bzJVm6qdMWXulkd577oT9drpDMSq76JQzfvtBY7pPNxXfzUYqn/eXr2JOIvPHTteOa/rm069+2YEaJIjnd+w4txrWxSMzJE/3G3uMUcxv1y1GYjZAcwCV/GY5Tjm+VyRDMjPJJJNMMskkk0wyeWUlStGR1t9vcl8qmUMN1UBmjz62CuS49NHgefBVMkOP58ksiihT+p3RrqPrEnLTRQrLmZw1N1iEAaYRZw6h43m+nN7V2vDp9mCKwK7QB05s3Ui7WAYBHUlhh8jYXfhkb7aJ7Nlvp1mCSIvfpW93J+/g8253ewK7fqKfF5s2ZHMLKFEZKSE63uyHaOnziPJcdfaU64hQZXq8hZL9DqJqC6VUFydc8BbNTuvggNvteXN5ev4ckOnFknWK53ufWEznyO8nWRSw3QRCOY96cW1DMxuBr9fPWz49mvNvIYL09IxFUxmsxmwgPmiEWVZmF8Bd6eqIUscQOHBkeHv4u2CQaSsMQOB1RRdokjf9ebprRMeYdSdHR0vSSROQk9rpqYOEEC2XbP99w1xq3wVEQHt3lF1E5xPFvTWwbVNVehcRXT9HUk4AzPMIJdFLfm/fjevLzenZuygM/OljDG1YUM0GWIHDeLtvx2ETWZxKw2Te/uC2Hf+nqy58/XYZ3Nxczk/GyJipqJSzbUgzOC1YvpczcxnHkL+ui+sYyLnlMv7QZYfzR9t90y4sD0RqbznuVLY9WUW8SwfJF5j69WTFWjweQ9/mWpQPNlPeTQQ+VcAC4t3WeiaT1L2FZUZlSOZrUqKiBlASN3Lbh8dUJKNzhhjCh2p/mCiQluBbKUlFTF6kH/K0IPQFpdK6NbC4/xtKC4fHjDj0fa+5nyaH2WKaJM88aM3bc+tpYb66mRRavwjSJ7MCU8mNpjUFzWIB5wS/jectlawC6/1nbkvL7droi8SJ+jNO3TLX1eEq0IIf58m6fW8PZPs3EBHt08B5JfG2eL8pRtAuwlzmfaimLZDrTrHn9zP94bpbLJdhflwt0yRuF0FDPQPz1DPObyqHv9+wkoia928i3aQzb22hH2yif/iUmiRW5kLqfbzqUJapNPlvMjRIeER51o6vtWrq53Xkoj7pqGLWO5NdPLZdnTOlI/uL7xMUEkx75XEFea8jptoD5x6wiLa+hY3bVif9frbqTK1wpZmrpXroOfcMHSSXHSrzzJcuWZMx/ZX95rEByrZbjH53vm77UOzJyrDoXFNPVia7oHjmCpcVEvfbv0lkznmaqXEl6RpcFNgnVir2vTTbP3+Q6mzDp/KF0nSzRX/qdPxcw95zqZn+XjiGBYTzxAsYx0fSO2IcMZHCnHNb4X2WSsh+ex+KG1kjuk4ZJQjBjfhuzw+c9F3naqn+FxwtGxk5ZrDh9IwZ86W0MEWk9TziBsN+dc8pdOGIf+/9JvelkplJJplkkkkmmWRyT0vMkMzXpBRU0EpMZNttmEOYOq7uIo5bMGnPKyFiHeYdlHU4bsExeV0WUezgXYwuL7pqZ/rIJThbL85ak2cR6E/APe1dh0CBlJsmmYPedLM6zWwPzFlzKHfIPujjtpCUXrLIASOn54veZJSOzyH63Qc63NhIO3imVvTmQSKKTPnnORFpvmQgFznVJGkJCMOZamobT47dRSrJ5XLacb8JqKEkdVD231xPfbQztFDQo4gsZpT2tkMbuWknSXr5SHQuEDIglCcRte/rnMLq86ToRHUYUerbhn8PDPeqfRcDQBjUNti1CMp6y8FYY9l1NHs0E293plsKfIDEbfG10gbk9uhset6DdTtPMPiNAS5rVRcgyCAZlH0FfKE+4It1yXLXahYVOglrBZkXPG9sHWOFkeaNoYV7a3BBIffksgv8OQsrs0fmzPMwjviFXYeqLSA9Js95hJPjugE0tV60faeIPkzz6lzRlnUN6NkMU8K6NLqXNlNfvN5KdbZQLOLYPpumW1okOg4ppOsBx14v2vl8E0FLHK8PWppng0RuuwAryo12etc8+rIPtuRf7WP8CxlsxnVu1iX/uNyw6/Jt8dajBfQ5BtOVnemB3i7Ve1DjyZTM16D01NWVcPnw70JIEwJN5DSpS1IZilFfU+wzkjoIyaWpbxkEzpI0GCYfkgoyTJxxJl7Of3ze+o41adEsNsSkdPWWfe+zyDNLU2bL0X2QMogLwTP71vflBZh5wApkyOc91Qkna5oNvZzBIsjJ5oajUWKmmxKi5K8f2BmURO30pfWZfPZ6qQ3W4N9adOay9c7kyZ/k5pK0DHshFShPss75hNd5kywXAm4GPA81TVykv/KmND6jlJ/etyksu1EKncJDfzIqiD47EQnmSclTd35SZ7HJWX0cvtV2D6ferbQRZP05Hc6YQKsg4ff5tm+2JlPe0LdPkhbr6XlDrBDe5+7UPIiuscHb6C6Y6+pYPBsl9t8kbo9kMkfR17rpXBkuYsHewwd7X8s27Ig855XR1pQceF65YP2x9nw/56aT3+v9DdnvuWn1BOcXG1CGUBVDl2VpL6S2WS2kfvTIjO2za/BtZlKEdZf1hu2zjIxuzIq04DbYdK8Y9uhTaL/J5JI3FGH2eY/NpLbhpsQzXFyETzbbY8UR4FMpfu4gXbjrIvBnUBV57Psars7JxML5qNG1dXkabjBdbL633HXLWEZZz8/uemYSbDK705XguyFRR+mw7je5L5XMTDLJJJNMMskkk3taojTMostfixKUR2R3PSa0qwgTg9+lbyHf+YESYfWJ+JC5bq2Y0IGVCjggHTRyq5N2ZItwUvZp0bibJMdl4RjEqYBd8cMP2dSAM1fTbvzj2wuHx54cl+afBna73jRHtIDpE1uIKvb8ktzZEyV9fMHCUYvzyUS+s5fq1aNgszBF9mC6qTmn9hOVVPYryN/n0SiWj47r3kxHoVl4GG3UKbnsiNLtuhzsq7MJQfn0lRSQ9p+uLZvr1pHTnZHYFR8BjvJ+bL8y9boa0MKTTE8K8xujUyWpjkh2BqS92LBIPHntGLyx6czZi0CgV+BS8KFdex2RufZNBD0d2OmKLcr0omdckAzH17XG9DFFc97GIPW3uZJFyxkkcwLm1LW6DegrYowyCMojWgx04tRg69X2X6LMBEJ8wAwjhnfxTVVHJlhC6sytbrrOW3RqsAqdrqV71irOnI9i0A1j1Vk1yMXI9IQLJXsd08qSPCC68crc2Q08wqPWdh1I4oNfiF4SfaPVQLLtQ8SOKUSf2rd1Tv5WuhfU89NdXRhQ6duadxHx9K49RP3Ix+vn/RoGzuNzRCG9tScdE4TdcQT9LaboRVuXXfls8CCsCy6Ikm4i5DAuHclTf28rcRmS+RqUgXraVcoAEOBzV1Za0Ly5nNHljEL3UpgyiXhF5kw1KU2PzsE84MwI07I9+M5XxsSLT9L+lvUPogmZJWo6c/kQ1BYrINg96RbLQUzm+Isg6PaUTRT6G9Fk7yOO96AYlXBdcErS9e1kwi8XpisKnF9oHjyayYc5jtO79hz9DX3kTsLs6jODkBSdUZBrc5YqJofvognVmxH30TXr6Io1l4e4gvdyAX9k1r53HiaoPRJMo09VXPQm3TWoCK05RYGKDF0yvE8m257XlW231ByU0dI8fPaO+P3STK+pQlMufYc940AdpvTT9fTtr7OB+oa2jJRSyyu2zpmd5eKNxcNj77ZyreUqYCwPIGe1z/hD4myuod6k+CLMxzW47Hj3loNuUvY6YMWIwbbhMlgkaO71Cs9Z+C+TkmqxbN1MulOygfWcX6IhfscnthwzATePz2JTsuzcYB7spDmtWmD/cBHWUB5X4NozdN+7UsbGCM9YwdR8uurN0Uio0eem0vmP4lUPICr7uIQQBBS8Esf5mOTpTZd1rGncA1IhPJOGX89uS9f5eHAK5rs2nPJ4E9Rp3MR55ZbCMb7TtfNYvQCqo3tQ4/EbpftN7sEqzySTTDLJJJNMMrm/JcajvJ73m9yXSmZBJS3p7OHfXSHCMiQTZStum/sqCNwpg/h1U1fNdY1+igrOI8VhwQESbQAv5EesOWd1OlyfXky5mo+D0UlMfXXLQi0f20tI5hIi0j3wuFiajBw8v2cDf8gVNy01nc8NfKkB/sBQwT32mx5d3EnXYWffcrmeZ4AYtbH7JhG4ZBFFi4zY8nGXjYDjI4hnD5yBL+KbBg7p5m5+L5/OXd2xbcMyXWtOjo6WpFWY/YiM+kjdHMye3ixGIWJ5qp5Qpj7qq3dMpCnb7QM79rrzsCafArFyyZWnBhP5CtwhrrncyjQzF0/BzWTeIkEP3kgBQpX8ZNJsSaoj3eNCKR17BGajzT6Rjn2fJUr/JJgcTm5as/rJB1P5Hqkkl5YN50KRD0DBME8QpWs71x72A0b7+gAhoq5Ebrsdh2SGZL0YwvBajbasCzDdEGE/5Qi1ORWyTA3HcEEEdA1IoUcyiSLSneKK4/TdQ+ATOX2DpqNqdUCFJ5ybzpmFNB/TCrG/Y4MtOb+frQNFxGc8ULMo7hKsR9eQxOCmSxM8zQzurcCz+clBWf7blxG0uILf56uWSWAH89MvI7XwVZfekYGrPPasEWR52MJcs+8Q1I/vcZ6dbu1h3+a5St4+jwwcfnzcfcl4Ml+TEiQVoAQsxJMTr7uce978fTBcT3+gnzI63QsHladOuNVKi+oVpCH3hLDnqlzoJ1NrSHbxpTn5gbUdcx0j8n5jM5n9lkr2xR1MWKRb6blOv4tJgNHlVCz3B3ZyLuXSQlCDb+lD83vmOroA7GFSW563Mxm/d3d3MsWFJNXzkxU3T2HUmBLwvutY5Onfw0XVZ7PYQb1cqIOuBrm8JakOBY/k5Ftd65PJCFr6e3pFkgoGTW67Lg9xYzMtEmcQvU3F3pOx07xNl4I1V8Uk295E1G1vaDcrj6LOGlAGNju2Li9tpQV85WZye8lV7XXzWLSvwEXEU8BwEeOYajnS5lutVBdV7Bi5YZKkOQz6z11N/bTvTLcbl+G2AqWw4a5jtqcWdL+OT8IOoY8tlY0NV5ckBr/aTmVdz22Y6/pKCkZH6bpT8YK5jpG6NXzGbGHKgJL1M/fKIzdde53SxN8lqYO+TWYIb6Ynafjjs+kZl1t+U4jNN7J67bqNVqWayl5dADH4np2fZvbSoKA5mSbt5xt24Dx7ANJxuMGcqtgNwE34Z9Ov80TF9t8ziIQ3+d0H9ttbGHtVtNvSmp2rZttpfJ0C40g84krG+kO5Hb/Ufq+H4/RNS44V79OWkMOem2DvL0sqK1S0Bwr4p88Gdi/I8D43l0/P0/Z7lBDCuRDCL4YQPhZC+GgI4S+Pf18KIbwnhPDM+P9Fd9+nhxD6IYT/Fr/9g/Ezngwh/B8hTGO0yySTTDLJJJNMMrn3JcaRknkn/16OhBC+IoTwoRDCB0II7wshvAPnvnqsfz0TQvjqO3jWO0MIPz0+flcIYX383I+GEH48hDDdjKRXF8nsS/pfYoy/E0KYlfT+EMJ7JL1L0i/EGL8rhPAtkr5F0jePPyAv6e9L+vnbDwkh/AFJny3pzeOfflXS50l677QX51XQkhYO/2bqxyIiZlbiGXNfL5d2gkQvVwanzHV1cCISsm+4XRJTsjEn8f6g565L79oEr53f9Z8CelGEid0jnttw/icy8uSeI7Mup/d+3lpCGE+73NSnd9Iu9jduJXSGaM9M0aKLDAog+rbr8uiSWP3UcnpvweVqfvpyMuxcbKQ+7ZG9HaBC5DA8bl9SOyZp8rUGCc6nm6r2gOYxcnp2zprIGAzyAtwS9pzJiIEeO9j1F9x1LPppIBlve/N1c11pDaj1i+n3XDF9X71j0egXLye3EJrcVsu2zmm6JXff44uWSYDm8sYWokvdVpeMAe3NySkmJakJl4qnDxJK5MfDVeQ0oJXYp59jFGoFCLZ/Xh8/MFFBpWzHNZHg7YPUZ30QD60hzMV9rsr0jrYMG0g1SD7IozyqnPtSWU/GNXNdGeduwI2oF+w3zSGNJjlR/Vy1DFMwmSK8uZzR2xX0Hc8vS9cL9jcfJNMy0eDp932X4pBtyqnB5+/ugJC82AYnqmP+OFtNfZZoI41bZdc4oEQ17A3eJWYbc9oypk8mh5CkZQT3kZnk8p512eH8uYq2WdiwugL7L5HqoVMbyHPLebbszNZFtA0RT4/I8i4GMHmz/wAV2DWmcx9dno6PiVW9a/Iqmct/QdJPxhhjCOHNkv6NpMdDCEuSvk3SExpB0O8PIfxkjM538Hj5sRjjN0hSCOFfSfoqSd8/7eJXDcmMMV6PMf7O+Hhf0pOSzkj6Ckk/OL7sByV9JW77Rkn/VhITV0dJFUklSWVJRUk3X61yZ5JJJplkkkkmmXwyZBjDHf17ORJjPIiJ1b+u5NPwhZLeE2PcGiuW75H0Rf7+EMIXhRA+HkL4HUl/fNI7QgiF8bOPVVA/KT6ZIYQLkt4q6TclnYgx3oZZbkg6Mb7mjKQ/JunzJX367XtjjL8eQvhFSdc1crf8pzHGJye84+skfZ00CtrpRSB9cJ0m2FiTRd+WQgoWKg4TSlKWdRqhfx93yz74pYf3dhFAQtRAki41098r5bSb9KkBZ1qTfUOvuOCSD+5Mvm7R+b68ZR5pL8FNNnDoAP123riYyvrs3nT/lg0AeNdKRK1snb8OvJk97Ngvr1vH+qf2km8paXx2nB8hMzpsdBKaUs3b6wZxMhrtUc0K/m4YOGm63w/FZ2MaxMn7up7bYdcA+JxE4E/XIS234K/18Goa65VHrf9XmE19ol5Kvlet59I3eaRweTb5nTHAqrFvEQ/6RrF8zEojSfPgOiWVzUHfBswQFcsDNR10HGo1xX/5ms3GqgZQk+OADCLzBDm97+ZnLKennAR61HRZYE6sJmS+hkwyPh1mD3MNXYdZVj/SOjgJVzfdct9OmrFmTOOhLFvWNjL5LIY0n5D2SJLaAPBsalCL7JHia6OVxnzV+W7W4RNMVNP7Ee7COkN/wxlH6UUfvqstUBM5K9N8CalQMR37wJ9qHUF38GnvOr9a+gvSd5tI3BNL1kL00Ik0Xjvg4H0O/tOStEhrAxDPC46mbAY+ypyPSge2bTpTxuv2QdVdxzlyMkIsSZhKzThccqlGm/3Jz7jctHW5iQChR+HW7dF8ptukT6b3v6eC5uLd7r7E8HIojFZCCO/D398bY/zeaReHEP6YpO+UtCbpS8c/n5F0GZddGf/G+yqS/oWkPyjpWUk/5h79VWPz+ylJT0v6qeMK/aormSGEGY3Qyb8SY9wjnD6Gcm/3iO+W9M0xxiGvCSE8Iun10mG4+HtCCJ8TY/wVvmdc2d8rSYuF03ERASC7gzS53soRJLXSRO7xh/XY4XE55xz1+5h4WlRCbA+ez6fFgwuY55ekMz0dz8mJJkmziP6jKWO+bKMC37KQJuTfQE7dU1X7Xi4MDBQpeDJgTJTM5e2j6Sk0qzFNmjcFHWDxuIVI0TmXz/bTV1MO8G1E5zYdgfjBgN+bjvccGzPzT2+gfE6fMObGVUQ6+HR217G4s0wVx+k5i0AgBv680LAKGQnYLzZT2/j64yL2wgYWp1+2m8tqHZHYi6l9C9AXu26yz6GP9TERetLm/W66bxOLZcUFYRV3sDlAkIfn07sGpeR12HgUHOE3+ynzfzMXvSQVTD719PuBHV5mXDLgq+TMflRkKojo9cPhxq2krFXR1m2noDy1O7n/bVUmK72SdAubOH6T3+wsQoOq5FN59h3nKE2M7cEA99iyzkI3ZR/d7XllNN1nCPq7doNyDibfBSh4++55nKuo3NacclsE2wI3F77+Ooi+nC0iCMXNpaU6mA4wvJZmbZBMERv9WcwNdB/xCjYVS7I/+LlvA5sXmq37DgyYWUj30Q2mtmPfa1K64nmnV2xQ5v5BmpM+hjS/PsqbQuaFoduIL1U4N6Tf/SbuSiN9x3mkYPZuNVxGuVFou8jaGDmO7q3An6iXRWG0EWN84o6fHeO/k/TvQgifK+nvSPqCO7z1cUkvxBifkaQQwo9oDOCN5cdijN8wjo35Hkl/VdJ3TXvYq2YuHxeuqJGC+X/HGH9i/PPNEMKp8flTSqbxJyT9aAjhRUn/raR/FkL4So3Qzd8Yw78Hkn5W0me9muXOJJNMMskkk0wyebXllTCXhxC+fhyM84EQwmmeizH+sqSHQggrkq5KOofTZ8e/vWwZm+N/StLnHnfdq4ZkjrXcfynpyRjjP8Kpn5T01Rppvl8t6T9IUozxQdz7A5J+Osb470MIXyXpL4QQvlMjG+XnaYR6TpWoaHYsTB85ExP+ztRiklQE7c6ukiliGfdI0lIxXXd2Jm2htp05b6uDXSdN7M4uSWfuU5W0izsuY8rMPFL0PWRtZCuX0i77Wiv1p/YxsPwbzyWEt+CojjZupV0sOT2XyuDd87RMtfQDM5d4xKMJ6pm3riYuwZm6RRQurS8cHm8BBVur2sCa+QIzoUzfwRKFXanQjGOve3YPFEtA1Wpu5PDvVfDQLToqphY4IZ/ZTejHZnd62zDDid/1MtDpCiig5p1JmzyGEf2v/DCoV5YtgtL63VQmZpLxJnsi7kQ533jC0uSwz968kb79dNWl6ASaf+lygo8WZ2xd0mR5tTW9rYmakLqKlEWSnSfqRaY4NJeZtnoaQRWf96Cdq+cfSvU5APB1fX/GXPdWcLjsIECFrh/+m4jqGLO66x8MYNqDjbLrMv5wTqrn07dXHYq7jLqYAWrlU9YuAZWsF1L/mHcuFEQ8tzGuj6ZCpMsIOBbdfEKreB3jZt+h1ha5TTfddBymD23DGhXTN7WdawTN2EwJewNoZXtrwdwz2Ex/vxX8yM2+R4Unc//SnUWSOo10XxPWjy1X54w/Yv37vlNiWlSgn6TPkqQCzjEgzSOeWySOhuqx4szqX3YWaDRu8a4unMPXwXHr00oyMG6OKfrugciOKGkw/L1jfTHG79EIVZR0aAF+bmwtfptG8Sybkn5O0t8Dq88fkfSt7nEfl3QhhPBwjPE5SX/qmFe/Q9Jzx5Xt1TSXf7akPyvpwyGED4x/++saKZf/JoTwNZIuSvoTL/GcH9fIN+DDGrXJf4oxHusDMFRUc9ibeI65eIc+yjOmgdkJSVHY9BP3IC18XBB95NpqhaYb8uTZsu310iQwB9Jxn5eb0bQF+CL1nSl4ez+ZG6n85Zxn11seThyEM29I3zF0vpYzjaQcFDbTA1cxH69bXU8322mgD+NkH1FJevtKclGowvdwa88qHr/lCOdvi+f03ITpltGb3uQ5AwJmmnhm3YhYhiLNaORbLfteLlQbmNSHN5bMdRfBHnAVkask4R6VIz1vBZH23lR9A894I6K5X//F1pyXe0PyN1YTymQDDXcMU/EpKPPVvNW6GGF9AB/ZjT3ra1mfTf2Ikdh1nyoTCkYZY2CnYX3GLiNKlia3koviJQk0lTX65UnSbhc8mVioTjpe0DPgTnwAKVgbLqf7IiKO6Yp8yvnSMWf3MzBRblud3whN0IMpx1649nofZQ1SWZle0/u3kb+VnJR1N1cxEpjuNgvO59HPSYfFceOa0eUl+Nt714Np4pfxzW7qi59Sn867S5M24283mnZ+oiLIsjepJDl/bM7NJGP3Y5xMHSSs53iSpID1rAJAgfdI1r9yHwotN/Je6PvadWAFNxgr8KHOuzTL1xqcc9Pvb120feIkNukcGzdcgg7mVu+Y+rdlJ4gzLYXzXZP4qkWX/zeS/lwIoSepJemrxsjjVgjh70j67fF1fzvGuMUbY4ztcYzLfwwhNCX9iiQibbd9MnMa+XS+67iCvGpKZozxV+WjI5L8oZe49104Hkj6H165kmWSSSaZZJJJJpncfXk11N4Y49/XiA5y0rl3S3r3S9z/nzTyzfS//4CkH3g5ZbkvM/5I1vTVU9pOFoQUiS5zQSeknSFRzYEcojik6XFylKIkFYCoMFWb52xcZDBNgEN6xe5UmzBZfvxG4o30wS9M08dUiJ8y78zvRbgUwCzcthSLJvUgs88wQtDjEYywpHnlIWfyXMIuewfRjZecSfGzV3YOj0swTd1yiMJT+5PTkM0W7a6aSBUd4W85RJbmxnkEM3UcwkNzHCNNPdJyAu4QPG44E9nzQMWYsu64bBYzQIkGmw4xYjDMBfC+Xkpodv+jZkOr2UVwynZSOy26fslMLUQeSi7oaQ+Zml5EVp/jpI5gt6ozK3WR2q+Aiig5060JUEPbRDe9d2BC3jQ8lLYNzwD4OjmfUMm8Q0muvT9dWIf7x4EzX3o0/rbQNO0Dej6wmcrKecYjj7sIPc/hIbmp+3/poJee3Yp27qsiKGu7jqAih755JPK2zJasFcebhlP57HfcwntbU1BDyfLGrqCaPbp1OaRJrrd14vD40136Gc59oBXWrAvOaQK1b9tufyirZXuCPJf8pmsOsWPwEGs558zWZQT0VYboby6okBYyur74uYp+gMv43oGzTFm+1HTPdfcdnLsWSkR77bh+EnXJ9mw6aw8R1T1YCtsuDH2nS5OW7jHJ0kq+JiVKGsAszgm1pjqucxNZ7irugflYdnJ4fSGlqTxdY0e35bBmuvT7RrCL+c12UpQOsEiv5KxC1sNERB85P8H3TPq+9PuyI4veuJ7qonUJ6QBd1CJpdxomxSQioJ3T0xk4wpByyJNFP7+dFAWabkht5KULRXe26AiJS2kxehqP8BsAmk25gDurulkwDjB5+YVkFub3PurLR6uSFuQWqGy2XTq7RZjIuch43zealn/1WiLYnl+3BfyMp68cHq9+fnJGCojezM/b6SC3kZ5xBWnl8sH2N5oymULwzBnbhlwE88+n499wOb+pOFzbTm4SPlKf/ZyuDPPWXc6Y5n4X6QAPojUjnkT09aka3S5sp33/dnrBEydSW594k+MPQlMdXILSWrRjZRGKF7+J9bDvNpKPLaS22ummF3mz8CnMY9eR5m+nZ8dNByboCmiLZnO2MvOoCyZ68MreYMAxCp9dFw3egE8l/SF91DhNvExd6lEg73ZyW/yvi8PkxkIQ4sO7dnP72HxSqMrldJ3/DiqM+/30HWtQLJn2UZJ2wOjBdvMMEvz7FlxEZnZsGw7QpvSv9HRLfkN7W07U7XpzgPJdxXsLbvyTRm4d7krbduozdHB76LPPOTXkxX24ZCGVrB+H9J/fak/v25+CNWG5dG+Zy6P0sjkwX2tyXyqZmWSSSSaZZJJJJve6ZEjma1KiMZdPE2+2Xh4ms8mtkJCfYrCe/yRWp4nhwLHUvthMwRcdpd18M29Jedfw+DecXT88LtesqWoTqekeB9K3NGd3oCcRJPP0/sLh8bWWtRWchgnqLAJwgkPLrq2n582Df62HXeaBi/LcQmRsZ5jOXWlZpGAZiN3blnc0TT6ylYKtLjXT8xaKts4ZZXyzneplrmi/3UbGw23AdRt2kTp24jsd+96bCBq5iWCcfLDfu42d/nMH6ZjR+KN3gYQ8Et2y5bvcTKjOCwfpus9ds0jLja2ERC5eT0h68XMTKp8/aUmgq8OLh8cPXE/949ntBXMdd+LkpLxxzQZrLRyk9thE9PuOswDQReF96MsrztzIdHu0kPnnbcGiQPRywaXcrQDGZhlmHCfqFoCSj2wkRGz5pg22qj6Ynlc/ncq+vWWfd6mRJoAGrAirQM58wMJMgWbO9HvTThkmuIR9mcilZBNE0KxZdOjRIsyc52qpInywCs2wDITzXJFEwem2cgQZJTcmxoY3tfIbOSN5K9NBLrk5vK5g0wZT2kCQt9BnmRJWsgTnt9pItwuT9rpzk6BLTAXjxkdvV1FHtPZsOfJ0/s1mKxyDCt9CYNOZrp0jmdrzSivNM758jOjn/Fl2Ud77QNLnikTYbd/5eDuxUsyVVg+P11z6SVrSyI15omLXa6KXnrz/bkuMR1Oo3m9yXyqZeeW0lE8TAk0HzCd+OdzgbVodJj/H8/GRw+Oe88lsRyoAJLa1neVCDeZohJ7P9OwgOInFM49B4Hc47Ixc2Hf37WTDiXFlemC3Hn0kKbTVB6F0XbPfW9lO5ZsW1XrCBWjmzIKRfq85U9Aj8NHsoNxP7i6Y6z68O3kRvNm2iwwze9CfLLjcxXmQNvNMwy3SsJqatvaUMiT8bw/ThLzesUOM+5BHZ1O9+ohNLrg0l/kpklHon7GcnvcHHrxmrlt4I3yC4WMYL6Y+EBas0pU7mRTkufmkQJV2bSnousFI2Dc9bDlCClCk+xup3XwmqpOgW1pARpgtl93p+X0qQ+n3Zdfnm8gMUlU6WTmSzYabx/QdZ6q2rbkhYNaV61esUl3fTH2iNjN900ul6Ro2KM8j0ty5FBsTOU2PTZcQgvmj6WvJTa8ktZANqK7kwuJ9gOmWwCQBJ8p24JDShwrix3dtHTH5xCmwS3glkwoZN6bF3PR6ZeanA8exVoZfYQ+ggU+yQBeNConQ3WsbmLs43xmKMbfJ/+2NpKS/DQ64D9ScEscMWJgL5qvWHs0MWMy2FY8AAIgjQP3RJC7ZvPDcvJ90SRHmsNGncttxO+I9mLFPxLRgeGX0j6wktx8qtCfdJjOIdY64BjdWbrS5eXxVqcE/IfGk9feb3JdKZiaZZJJJJplkksm9LvdYEqJXXO5LJTPK7k63Y0JhBiHthmaG1uTBYKFaSDvL6MjTiYYyNV3b7dxICsv0btzFSVID9714LZnfKs60xMhdEuw2nGM3OdsYLf3nHrPoVu1xQD506N80l6mB9/YMmpquOXAIYMDu7ATMHG+at87vJBd+AcTsHYfsfcmp1IaMjrzRsnX5oV1EZSMntidZZzSijbq115kc0TieK/kdcUIB6oymr9tw9QVEae71Ulk/ume/g4EeRAe8OZ/1RERhfcua6ReUyJ5za6lehhsJSc6X7XQQQFxMFwrP30oTOUmzKyfsuMmBQXweEepHU3kiChUR8z4/dq3gInxu31O01w2q6b2XD6ZD+wTtiA5uOaL8IcI0mOq17hIIPH01WUZyMJH7/PVEp1gV7KMeydzuTEaPTlRtGzK96yXQczZd5G8fGPkLg5SYYQWcwJJ0GpySRMF2XOAa+VspRCElaQUIaM/wS05PDXq5RVOrfT4/fwME3XRxkqRZBICu99PcstlZMNcxz/wa2um8C5J5FmwYnH93sT5UXPDhF59J/bcPTcO7HvhAoMPfnQvFbCH1vznkMfd8tUTOGcTj51ySypNLuNH34wFBsrRaOctez1gA0++ftmS/YxUBqkSILzZtn7pJpHoIlFR2Xlgpg2nm3rKWK+qls/m81uW+VDKHimrG1FFJW1SFmYR+SJK0jSw/DYH0VlYBeHi2guP0+1bXToz0NbnWSMfzLtSZppd5ENGWS3Yxb8AsuQkl86ab0Gl63WojotdNSkNEhHdvpXPPXjthruNOaw2LAnO6P7Vrv30OaxgjpT3d0rMHqS45yb1uxnEJQahse2HVcsLzvmW8jhOPn4MGmA3riCBv9+zEv1CabNLyCwYjSj8ISp8bLjD505ew4UG73XTmd2Zx+theevbzjRVz3a2fS0rw29+WWBSKp9LzhtuuEHDxGGDR7zkqIWZgYuT57vNWkWE/egFm07qbhahE5EId17k88KDg2u/d2URNs1rfbR7P1NKYOlufTBwtSQd41429pFyccW1NZZxk294UzLvYZx+0+wQjjNzlPT4P9B7mHZq+vQtQF3/nsSxUcvbjaXUmpYzfcnHTuVqerCRJ0rUW8nfjIV6x6g8nt8cDro6Q7EzbyLhGdxZJKmLunwdT/qoj3qcrCNttoeQpwiYfn6mmCjtfs2Xg86a5nEiW6J5uSH6jQDJ2ZoerO9qo00is0DRMHfa6GWRPY/50Xz6jVGOeOHA+BXRPWa3Ax9atSzdBwefZSOx70/Hpchpf/p71Dnzpj0lwcLckM5dnkkkmmWSSSSaZZPKKS2Yufw1KKeR0qpR2Ns0BAywY4WZ3gsth+fCYQQBebArBtHPzfYU5sckvt92xiEwBRNklZ+qbJsyPfXbGRrW+CNPNiyDifW7dmr5av5mQW6ZJazhHcUY0cpe5B7NJLvjdN6ItYXb5+J59Nk3pb5hLSJpHyz4CczJ3sGtl204AGw0xddV5g5PoGkGP6jok6KFZRE7j2Qfeu9xIesaHd60z/XOIAN/pTEZJJWkLUeg9vHjJmRsrQAu24dDv2+M6gg6aG4jOfwgBUA4CiKi/+YcSmnJiz/a358F60B6m4xMNe10JyDxRHM/9yXgcmuyutz3fHxkMIo7tdxBQOQ1e0IazndG9hfnKffmIsnWB4ryAXNSj8pFlYHr5KETpaPb3QYAzsJ8zj/maQ+J2EXhCy0onWEjnRC4F+8wVU7lP1Ww/J1chU8n23UrJZAcwphyxKJCgnH1+r+9dCtLxHpBkn8q3g3mbqWRPF3wayHQd81nPusCfCJTpaVhdBs7labZAxDj9Pl+cHqT0/H56HoNT3r7k+Fthmmdwz3bbun7QwkN+3pkjBPjpe5kS9oxbR+jK9CTK6l12yL7AIeU9ihZLTJSR7tl1rhacI2dhtPKjZgfplHe66RsfmrNts4jo8nCPoYZRR91n7je5L5XMQYza76cFjf4a+yHRB13s20FVhll8fjg/8R5JajSTsjYHolfvW0Y/qpVywLGt9koOmUZAk+EzMLQH6b7Fcprhj+PZ8pG7lCZMt2eR97rv3svsLE/tT85Es1S2ZfBZVw7L6lTxh+qT7RcvNG3Bn9xB1Di0hp26HaCMDudC4jOmUHmhudb7vpHcme272/WKRzq+UIdy60ytD87gQhw7LnsjN1HW+eMUFNT5l5+zkd2rJ9OGooWsSM2PIKPOg/bjwyzM4CdTGWac7yEXjIcRbX3yYZujG/s75W9Ojp6XpCEai1RO653pkzGVGu9X28f4uNXq4jpblw1EZp+spjp6dMYp9jDvrSBjFTNySdKzUL6pqPpFOj+FiYHj2m952d+oRJ+r2bI+hPfmQirfx9q2EL8T33d4vNA9fXjcHZ4z11mS+vS7/yZuxDkmT7nIZPoE1qAU+ixIHB9kkCDBvGR93+vYCF5uOV9wGPi70IJvOhM0AYAVbPC8YsSeSfor+qZ6P9UPbqfjPnxGP3XB9nMqllwTfLakXVzHTdxO1yqjB1Ayqfi+6GiZyswXj+ue3rNts0bTN4rkVwDWC7PcOc8jXT5I9XxhNj1wvmgvZPuuw4/jmqNEonvLTnfyunTXJB4dO/eb3JdKZiaZZJJJJplkksm9LFFZxp/XpPQ00K2YkDlGD8/EFEiQP+bzt3Npm1kb2ui8HnCFFnbpPoKZJlCaWn2Kw32Y/d4H1HDeEY0zfWRvmBBUOmVL0hZ22TS/+bRhp86nOirCgX7zBWtzi1NMDOeBmuz17O6b0aAkJH64bgMO+IXPg5R6x0X0vvNEetcSzD8vuLy8v76e3kVONJ+7nFY7crFVXUQkreJdQEb7ztRKrjcivBccUjsLJ366IXxwx37Hh3bSM4hanaq6esa5N84DlazY99bOp+OZWZhuLwJRcKko8+2ElneAPL64bgPDSOj8GH7v7rv0pEAUGBDlaPK0BJ7Mh2YSGrrryKL/y63UaRkEVHeEy/UpqQYX3ECkKZgoHbk6JcsfeAWuKXUXdc90oEQr2y5t6zMHqf42YILu1ojs2bJfAzzI7yBCL9lxeLOFiHQ3ptfihcPjMyEFjVVc47DknPvqLhaP/Lzso0xGIElRNFUPJx5L0j7mF1pnYnT5tnG8DUvGvqzVqhLTXLOSx1zq4g3fNJ/a8FwtzZ/rbTtHXoY7Cr2hNhEM6q07ZEBZhs+D54Ot5dO7lsHKUC3YwtbRTxl0tunKyrS3yCFxJGCGLjfkQd2r2sZeBipJFyrnFWb6EnmA2846QwtUA3Ou57816yv6817XvrgzuJfN0WHq+nq/yB3Vfgjhc0KwodghhLe9OkXKJJNMMskkk0wyuf9lGO/s32tV7hTJ/DlJvx1C+O9ijLdJ1L5P0j2paAYFFSPSYAWkNUNUQS2Wjtx3W24iW8ycSz/3GByLP3WRuy67I3kOLmkv7iP7jNu4vG0ZHJqVtAtrOQSmN0zXkUfxpkMv6Bi/gsCYc6/bNdeVzqU66lxK6OBTt5bNdddaqf4enSHPY6rLj+7YUfAwAmbmp6RIlKTLSFdG363PcM7va9X0N3fcR9PZpbZ6chdoqgusOQPf8B3Ul08NegrXIY5LG21HQ4PPPy6wYxNo3FPwjfQ8o0SgydnoUTD68BENvdE+Y677w4OU3erE6xKqkwM6EJ177GAfiOc+s4RYpIAIDQNh9rct9GBTSYLz1VF/5aekF5x1AQwX6nD8B9LVcEEjTLXI+BQf+EOH3Jst0Ms47kmmTOQYeNuy7bNvhr/mFvgWbzpkiYE7pzDVkCLIF7VeJEKGIBsfN4hn0F/u8YqluLoO1LqKjFBrDjnnu+gM6v3RaYlgUNCcG4dM91jNT+aGHT0vHROo8ghvnBKquyjLddQBJzL5GxuOducZjNFKbjLdmv+bADn9pI+LFTSpQd28z7HCelksW9/oSj519BI4ZUtuvJ5E0CiDhbwfPOe0eaCkpx2nF7+dJW+6uuS5ZxHc4zPlfenZ9HxScjFtriRtwpe2Dw/Qqz0bQ/EggtrOztx7qOb9jmTeqZL5lKR/KOmXQghfE2P8NR0N9rpnJKecUSwHmESuKeVtnot24qkg1SDN6gPnds+BboMW3OTQoXKQnrHoAn8Y0bgArrLgmmcG5jeayPccRyAXJJ47uGXNHLVBetf15xNvoXd+Zz5lKrTXsabu9exERuCbCsBmw5FFw8z52Gwqj1ceP7yNQCwoEasunR10eT3fSAX8lHm7UaBJtQfzkXd5oKsFM5J5s/oWVolrzfTtt1wEKMn7N9qpsOdmbL1w4qWl3y++5KJroQkuHvhFMOVn/mOFK4fHK29MC1WYnz4Bz8D8NuPI5phTnBuo4wLS+KZVly6OZOy/sZnafcblTKZyeoAN3qZTADYxDpvD9B3XhzYw6ewwBfSdgEmwPZyu2NOs+/y+nU8uwNRPInlfywyC2IZytnRMcMRze5NTYJ6uWQWA3YqR2LtdO27y3GB3k1n4bLTBICTlpq7hA9duwDRPxdQro+zn29hM+YDFVQwj1oXnPeT44rvWKnYc0qT6MT17ePyZ8TFzHV0jfn0zKZlela0asnLM59XJ10jSCSjwJI73YAUyoZrI8HyYrhQW3fxJoWLJvv3EklXOtsF/yzWhkvfPBtMB+mzNadXP7KX5OCrVJV0SJOkUXH0Y6LTb81Gs6fmdQTo3G+06R3YZDw7cbYmyHLD3o9ypkhljjD8dQnhK0o+FEN6to+Msk0wyySSTTDLJJJM7lPtdkbpTJTNIUozxmRDC50p6t6Q3v2ql+j1KkKWoIG0OEUov+zGZEYiE3go2z2J7kJ7BdGoNZ/IsY+f6qctpdzXvnOTL2HUyGMSnaiNq+shsMnm+bcVu5y8BUfnoXtox/vjHHjDXEYE6ADro0QZaPZ6CCXoTGTXaA7sbzQHJZEaDdUedcr5GxANZhw4s19nvbKXy0QzzuKvMJlAAOvv3hp4nD+jKMTx+jSmO7N7Uyt1yCWY/70vDzf1KJbW17zucesjZ6M2mNB3y1Aln5jyB9IxbMFvPXE1IZqFu27DfQB0Bjd7rWFTofVvI5AGUvuUC0rY7qS9+EOk/t63VT6AtNAhPIWe/iXyze730fbMu3WQBbboXE0pXdOnnmA2I6KA3XzKjFpHMHRew8ZsbCRk9VUkQ24a7jshQARl2mF3Lu5mQ23ETiPiSIyck12YTXF0vOP+MPcx9i7nUP3x/47hhiXzw1jz67Nz0BF2qw4qzdkxmIBMcgm666oJBmNWojHG427Ufwvp7S//Rw+NH52z9nYT7Ekt3rWWvI+rMwJoC5jT/ddtA2A1Hq6PqWShO5jfbcpRZGwjAY9COD6LiFEeXrDlnfq/jvR/aTWN3w1GJ0aWIaUMftiC4mv30DPIPeyEn8gKCX2tOW/n4Tjq31UtlXytbdxQiqkdcZO6yxJhFl0uSYoxvxfGBpD8RQjh/zC13XQYY0rP5NOPV4W+Ud3YrmlBI5Fvsr5rr6PdDc3R74BeCdMyB7c0ms1gIqEj66HI+gwS7wfEMMuXZG5MV3PAFjsqemp+RsJ58+vlG+hAqAAVM6PNFO+FRIaOi9ZnLPndx+g7yvP32pvPdbCDdJhbiay373i5exgjSFw78BJpWJ/Jktp0f0bO7k03BZbeqkmiY5sFZz+2Wn6y8eCXTT6i3Zeh8zs5jz7SAhe7zT90y162sgHh/I21CNm+mB9RqdrPShTJErtSP7U3fqF1pTs8NTkWJioc3eZJblL60dD+RrNn5RCW1tSe2J8H++bhweFx0ztFDzBkPz6Tj183aKN6m4Rlk7mfbFxlZ3B6mMeTdBukuwLF3nK9WE7Zvzml+g8hn0Lx9vm4X4n2YIlt4dsc9kF4iNAvnXV2SN3cJZNheWaY/L5WhLbfB9mwTt6XuyNPZr3jGR8lfbyLtMMar94PnhoIK+2p5+nX8JtZX4UgO8nSSfbnhynAJY2raBkeyawdTNXoSeJLeX0UK1/M1O64XSmnOPFvlhs5PTmDnyPPb7Vx/rk5Tf/q95fzMX4QXCxXEo1ys6RuXMJ+fn7F9h21PEELruifk3lJ7X3k5VskMIfz/dTya+5de2eJkkkkmmWSSSSaZ/P6Q43zX7wd5KSTzfTj+XyV926tYlldMcgqqIYp8Y5DMppeGyVxWihZ16Ya0cysNpiMybyil6GtyhHln65tIFbYNtOaSjTfQO9bSdWtA9rou4ICBPw04b794YE3BNH2fr6VvOuN4MgfYFVcRPXij4YNkUl0uI3TyevMYJAP1QgSg5nbfV8Ev97HdVO4HbQyFvvAUefIQsNSy7/3oXqqXR4bpIVWHZBCgobmWmaIkqZybvJPOBds2DBhiXTxQs8/rAKW43Jw+/Ij+MPBny5mq+B2fCReKpUXLCzjzINLovTGdaz6T2uaZF2zEcRn9jRyrPuXni66/3JZdh3jUEPxCFIYcgZJNFfq2xdTWPecg/1tbJZxLv59zxSFi/IFNmChdYAJTj/osRJQa6qVeSOVrukxZD6AcjMDddNH015AucxN9cQGonM+AQ2vKPGgPfIAQg+SIli86JO4GosbaSM3ks46xby+h3Txiz/7LCOsbRwIv0t+cGTxKx9R7ZAtwXcf0A75pz5nLt7EOVMAy8oLjduV8t4S0qLMu/e9lRGYPpyDQ3pJExP35vbRArLggpQfAR7xccrA/hCZyZqK65cZnb5ievwj3iucOLLp9oU50ltzQtq1v4c89rEv7rjM+DyqBz1zDdS7Q6eJB+sYHZlK9ep5MuhgQfb/asG3N9MIFHzl5lyXq1UUyQwifLunXJf3JGOOPj3/7akl/c3zJd8QYf/AlnvFOSd8UY/yyEMK7NAoCvyqpKOlJSX8uxticdv+xSiZfHkL4Ky9VmHtFQnDmbqRj3M1tHB7PxiVzXzlOVix7wfrEkHZj9hh6Hl5H4mK/fNFEVsVC7M0IlBZ8N589sM1IhfaRmVS+Cw9Z39IcFrH1i0kha7h0ZSTipcK4BBPxJavTGP820i0976LLqSStYI77zGX7wFPIq8vJtFqwvptbveQIxMhV78pAJfgGrKFrFe+nl445P/kodE5yXKgGLtKRvn6X4RdXdr4b1zFkV6uk+zCX6UYrPe9je2kxufGMTQf49v1kGzrxUNrl5NHlX/fwBm9Rvgo/M/hndi9bxWOlnN77QD0tbnNuQdwDfRMTC/jcvTRZkrS57BQPRiBTh1h0+d0DTK81mJY9dUplqouC/XsVFDA1bHh8mr8yUigeQOG+4SiM+PVU4hjZ7JVepk9cx+Ty+JxtmzPV1AZ5pJX8r7fst1OxnC9Md6KkP/QJDD1fR8zFTR/DGaeM0rPBtLUz8XKj0A1Ufux19IfkHFR3yRjK8Gc0KSadewATNZAk/UbHtvXOFFYA1ovfKNCfeqVCdxtbBo4Vkqz79YbjiKmBPVjBzRrN6js9v3kE9R/qYcktk1znmLZx70jqXboHcW62110dJgaYtX5K/DBw/sZMtsHc5UOn3O4O0s4t3nPG6XCkHV+xJ48oXv6+pJ/Hb0sagYVPaKSKvD+E8JMxxu2X8egfizF+w/h5/0rSV0n6/mkXvxzSqPs9CCqTTDLJJJNMMsnkkyJRryoZ+zdK+reS6KD/hZLeE2PcGiuW75H0Rf7GEMIXhRA+HkL4HUl/fNLDQwgFSXVJxyqo92VayUGM2kG06UoxIQdn8m86PPYmXiJV3NH2nKc+o+ZOgNOLpLmSdBoRvqU6dreuvBdmEmy1CJSku2fD87gDvQlU6Pl9W76NdtrVvTif4Ia3dPyeAiYGvIuBPpKN8KOw+jzBPM2DvNuBR6bO37qQvn3GRVQ+vZMCT9YRtUwTlmQ5xy4epHp5+4r9htfNpjrfAh/cr23ab396N5VjoZSGS/UYZuUKPnKnO3128OglhSjMC3sJ8jjlIoIWS+ldH9/js+11NzuJJ/PL4/XD47ULCdUM+ellpXfAwJmtyfP64PLO4XFtxiKZL15LlgMyJ3gzOFvqmYPpbitE7BmE5vsYh+82EI+WMwXPAe26gYesuvSTbz2xc3icB7p67cD6eHx0NwVSEH33kdgsH88xRd9O16NRZGVI53YdZy6DTcgpu1yx/bwPE+rp+vR+SfYFBppVHPqWCywfXIocIsvAJLJxzLtUnkxCUDwG+CF6xuG15NwDdsCQYAIqiz7VaJx4nQ9EIuJJYnXyt/p+uQYLxd50K/jU5ATeAkC0nMc5V+cMqiKSuVKyc+TNI+vFSBylrwkoY70cOESREf17ONdw1z1aTIG25BJu9W3brHcTQkku7As1ayl4fSn1dWNK39U9IS+DjH0lhEAXxu+NMX7vpAtDCGck/TFJny/p03HqjKTL+PvK+DfeW5H0LyT9QUnPSvox9/ivCiG8Q9IpSU9L+qnjCv1SgT/7SghmLYRwexkLGnFnzk2+8+5KkFQGhQ4zTgSzJbCde4BzXUziQ3ddHbMX/bO8r9pD9eHE6w7cYFkAdUQJ13kfr0af35R+/9IzdkJmxPWHd1MHfuh5m3O6hAnm/dtpgdx2EygXLkY30srhfZ7Ow5+HC8tF55P11kVmpkjPuNK0fkS/g+wxt0Brc6ZmF0v6tHHyWncT5psXUp2dQT71C227UfjYNn1u0++eloXKLd/ko3PnoRQWsPBtdmz91QpcfEkHZYURvlxgm31rMn49qFla2Az1DkD15R7euJnqfAMR5c87ZYp+v2XkHa8uuUwjzUT2PNxIm4YjtEz4m8qVV9iZneksIlf9rp+PbyABwf7AruwRbAQPzpJeyo1DmBEr8KH2Zq/rMBkvYwH3bmFkbNjCNw6NQmE/iiwKnJ985qiLiEzumAhop4yS5gn7O68Qe7+42+IJuqkUsuje5YFsCRz/1bz9kAVUUhN+pnuubSjcePj6Y53RD5vuFJJ1s2HGNR/Fz002TcFUpny2I/Z7k3PdKZzcVHvTN4Xty+t8YgvOx1SiH5uzLkqn4VLwM9cTWOGzSq1VJm8UViu2rM8jU8YQCvJZt6n57FX0Z7i6fWBLVlBPfdSgS0hk2qp7D+ZnfBlF2ogxPnGH1363pG+OMQ6DR4BeWh6X9EKM8RlJCiH8iKSvw/kfizF+Qxg9+Hsk/VVJ3zXtYS/lkzl73PlMMskkk0wyySSTTF6+xE/cFG4khPD1kv7C+M8v0cjn8kfHCuaKpC8JIfQ1Cth5J249K+m9n8g7Y4wxhPBTGpnlPzEl87UqOQVjQiJ60cdutBftlmwHAVI7CBCqx3lz3Y12Mj0+CLPEvMutTLmFtFwe8WjhGXsw3W450mY6w/+BE6l8c47H7wpQouZg4fD4hYYNkiE35jkECMwW7HvpxD8NOWv07W6Zpo0B4JDPWrF1dKKSULB1mLCeb0wPPtiCCaXtkIyr7RR4UkWa0FrePo+R0wsIVnnIpYFcArEvkYdbLTsz3Gqn7zhdS894fN629QO19P00GT/jolqJNK0jR++WgxEYgHQaUUGfuuQju1OdfWBz8fC4DnePQt4++zmQiTPn+vu2LHp8AYj9+a2Ech64XIPXkSRgcAxKt47ufBNRz34ypumW9dB0AXOMqi7C7n8xXDHXrejBw2MieD5g479eTRaBJYz5jkOZAtCyS82A362cxrBku5+sIjezcym4CBcZ8gVWnJtEHW1KZI/JEiTpQZBj03znI4SZBpam1hmHUHou4NvizeVtIFrkX/SI3SzTmtJ65NglmFaTc9WmI/xfQtKAASwjNGFLNk3tPiw6t1oekZ08R27DQnHgXBkuNtO8042pH52vWGynvpK+9zxSlTK5gSS1sXYwgLTqUOZdzDtsj7W6RTJXaqm8r2+kd/3qLduGORDbcuz6uaoBxHi5nObIczVbvgW4QC3g950ZO+881UiN2gdDv7cK0fWt4dhD7gV5JXKXxxi/RyNU8bYcTmYhhB+Q9NMxxn8/Dvz5eyGE25P7H5H0re5xH5d0IYTwcIzxOUl/6phXv0PSc8eV7f5UMoONJhziM3f6qWPmXOPmYOgsCVkHHKBLHxmayIMzq7PzkBD36d2Suy49nxQ33iSziqwtVSgHDedDuQ1ljRQ69YId9KQCOr+YHFT2W1bR+uj2Ap6R6nITfonXHYEBfZHOwVRYcxPeTSh1H9gB6bvz8WIE4uPgdmn5yERMcnPFVFZvLr9ykMy/pJ7yxMV0x2NkbWdgv+Pp3NOHx58/n5JhvWnObgCoXD1zkL5jyxGNn8RiN0cTe84qB1SGPg3maW5CJGkZZOw7W8kV4fpuUvyOo+0xEamOAPt9IC3Y7ycapIfqLrocSsRF0HhRiZakWYxdRu2fqNrpivoPFc6KU5YrcDeYK6Y+9vjwgrluHibZh+ppbJwFHYwktWHCIzH7o/N75roHYMJ/Fgr2x/bshueG6SJU4mASd/1yBnVEc++Ma5uH4O9NOqKrLeuOwsRZTO7glVsyTVBowpakXfzNzfFs1d5PurWbnVS+ky77z1Y3zRO0Ovs+y9zqfdNnbXmZ45zrgGdvOIfyzs6lfvWim3Pp5pAL7ItUol0ZYupXa/m0Brx+wdYl56Qu2rCUs/28AD9Y+rQeF73MKPlr+3adW6mm8jFjVcVt2NkGdCnydHCcj6nM54Md/88cpLpdxdox63CHGWTlO4hpXb/WtnMuidrXnC/y3ZYo6/r2qr8vxq0Qwt+R9Nvjn/52jHHLXdMOIXydpP8YQmhK+hVJ7By3fTJzGvl0vuu4d96XSmYmmWSSSSaZZJLJvS6vNhl7jPFd7u93a5Qa/Lh7/pNGvpn+9x+Q9AMv5/33pZIZZc1njyBKIx+m72SICvVjMhUGh3hyZ3kLO0EflHEaO8FimH7dLezgaTn0Jiemi2wAbXwKSKNko8NPYyd+omJ3eG/61MRskIdppP9Bu5PmDplIZAu79Ncv+IhjEFbjnnWXz/oKcgAzRZwPOHjTfNpJ03T2fMOajKSE0JC0+eEZu6teRrAV3RU8gfg5BDARofAk1Wd7Cb3ke59tWFSY6ArN74/OTe9j5NN7ZMb2Cf71OpCxMyBFkgpAhtbOJxixcA3t2fHsCAmZewS/L920pO37vcm5hn2EMBEVBlj4NHCsibVqKpNPIUgweQGIh2ccYG9+02J6175LXUikhCb3i47MmmOAKMS2479crSUU8UHwvN7sWPebKzCln62lB55AG/o542w99atlkHc7OkgtV8HYUEvHPvjoQ7vpGxkpfq5m65x1yzrad24r5A/mPMbkC5LNg30GqQtPVS0Kvg5T8G9vFXCd/Y4TSNFZYz7wkv1gulPNge/3KPck3AiMi4eb79h3+kT20nXXGhZ5PFNI/eAEoFbybEqWBYFcrN6l4KHZNK7n4Ib01NaiuY5zyxLG63MHrjIhtA68fsG2IUtBKsvlsr2uMsUq5HOhX4VVbBfWBW9lesNCFefScdUF/ti2wYnruusS9fs8reRrWWgCuXzA3ODp92rBTyjp+KA33ReMVAyf9WCauB+Yt5wIjA5dQcaU+ZLNEbsDfzeWaM+RO5sJppnK8CFnfr+CQfroTPqOT3nC5rMuvS4h4MPNpBDvOb/Ej++n5zf6k3ddPRf5uzSFd+DDu3ZCIc3FG6Covm7GKsRzoDSiG8LJilWmmDv7Ftrwc1wu71OPpQm5tZ7K9KsfWDDX8Xu34Ovjc4gzavHSwfRIYlKk0BfRk0CvYqY0Jnvnb7gNM/tON1X62p6LAF9Pi87DizuHx7Mw55eccjazgoUerz25b83Hp6tpgn/zQoogX3PRqjWY5n9rK838nrSZ7gH8dr/puoHIc5J1151f4jpyNT+3N902VYTiQRYFr7Seg+/aRjt9+29t2Tpf2k+KG03QFxu2U5Cp4GoTzBX56X7JL8Ank7RMG44d4YnFpPhSyWSmIsn6rd6CCXvWKfY5ELpfbKR6nXeKEduKfo2XGpPnD0mqYuPRcdlnGKlPEn0/bi42aU5Ovx+4eev5Pavw3ZaG85tcQ4Q0zcJNdztzYpPN5AV8/GbXzmmrpfSNZOf4+J4d42eggNKdymdPqyH/fB4K2dApxPQFZ7s7rnPl4DJG9gCfjWnLMEBM9iWXbHT9KezbPCUV/ViZja3uLtxBnbXApvGA892EW7c229PH/92SezDg/RWV+1bJzCSTTDLJJJNMMrmX5T7XMe9PJTMXLEq52UlbGTofz7qdEaMCmbat43at3ElXC9Oj1VZPJrSscjL9vnjVRsk0gRT2YHb68K1lcx0DVPbBdehTJg6GU8zTDpcf3AQh+YfSez8K4nNpOs+Yj7CkkCONkZfbLsDldC2de2wmIWQ+eON3wONJU9WaC0Sg4/9blhB84K7LzyLIC9/hzfQ2yGVyyjrJomAk9fbBWzcAAlrTuf3eG7DrEP30JiP2RfKZ3mpbWOLX1hNq8jdgPavMI0CgYz9+/XKqc7oUrLcsysQAn3MrCc1ffMSG9C7cTB//OqCadc+xCDMgA7Y84sG2OS59H01k5B/1fHrMycwUe8vO1EqUiK4kyy6d5SWgagz6KITp8w7HVL0wGVmVpI1OQsU4p/mc5BfBKEELABMQSLbft6aYeyXLxUjEzgf+kSeXn+sTYNC8X0Rd+hSHRNyIkvp8BusYX3RH8fyIa0yUYdBy+zyb/nSyq4skdfB8v17cloWCtRDNY40h1+RaxT78gVoaX/Ow6HiXnQ20KQMqfbKD1pQly7taXGsT8eS66YOt0vFJpKI9ur5i7KFevXVsq5u+d2BUMFt/RaapxHXzbrySu3PfT/B3WaKOIs33m9yXSmZQMJMj9YEXW0nxO+hZHxQS9FKJYHYNSaoV0iJ7CwtuxREID29g4sil97YdPQ8Vy053us8NB/rz8PXzyWfOgNx2HabIZz9sc7VXMWE9D8XyqX3bLew6k55HX9XrLqLvXDfZQzjIT1RtYd+6mCYUKtHXXIT7M/tY3NAc/VlbVi7GFbThQdM+r/Ziem8bdennoOEUBfu6s5ctmqww0+lq1iqTIzHnum7BgFmH37vpmZC9pnT7Hqfcfiqanhl7cqZanAsA+uV1ROP/zo71UaS8oZkWuvmmVTJz6AcLxfQd6y4PNEcbidlfbLgIZmZ3QUX7TEokKN+HduAX31PY8JyrprGxUrb+gYzwZa5sT5NN0+YZLL5Nt/PgxoN9gn3Zm9ToU0gKI0/pda2d6raQS3PV+brVCpfwjb++mTYAm25TuNebvCCW3cB5Htm2bF75ibdLkl6AKd2PQyqnTMbgI46p/HHe96ZgstzcgD112WV3uoBMbfPos3VH2s7ybuDZ7QHclRbtHPT6udQxOV59v6RQsTyODYLURLPO3WMLc00DffRINiZM/BdR5wcuSn4ebco+6+mvmL0njxgFvxHfRdT9TEh9tuQ6BddoZvzZde433ESsT9Ow75bEo99/v8nLyV3+siSE8O4Qwq0Qwkfw21II4T0hhGfG/y+Of//TIYQPhRA+HEL4tRDCW9yz8iGE3w0h/PSrVd5MMskkk0wyySSTT5bcDvy5k3+vVXk1kcwfkPRPJf0QfvsWSb8QY/yuEMK3jP/+ZkkvSPq8GON2COGLJX2vpLfjvr8s6UlJd5TGMsjuLM/NpO3uOaVjDwLZ3OXp2Jtk+Ow6zOVFZ/ZbR1TqjacTOuDTTy6WEwp4q5XQVb9TZZrJE0jf95YFiyJexTM+tJO+97dBrj0qB3ad5LWsTbH3SNo3fHjpnmbfQgo0pa2glz2xaINGWH8ki//Qjo/8Te8yuZBd29Bc/vHddPzGOdt18kBN+6jXWccl2oIpkm4JHvEgykkU8mzd7r4frDMNKZ7nEB6aSp/dQ/pElzi4is44DzOWzyTGshO1XtlNQSx5l7t4dTUF8RThvnC5ac3lWzBt/vqNlHf405w5b4B+fxmpTz1KN4+IVyJfjtvdMEjMVdg/7HVE3Mmf64Jkzfg/Dk2aB0tDA24EDReURQSfJl4fhEJZgZsJ+/IlG0OlU7VUf2W81iPYRBEXYLmoOTefHZhaTdS+QwpZdtbzkeBIjFdywHpTK4V1TrOrZLkUSVjvEc9pqJAv3yxuXCylNlyt2AvJJEB2jwdq9sXkvOW3P7GS6nXZja+mQRHT7z7AbQVMGAz+9G1YRlmZ/MML+VeZz/6hWdvJ7DqV5s+bLjXwajm9l/3Nu1pIaT4gQu7X4YcqaX4iWklLw6h86dxMMa0dJfc8Gn98bvp7QeL0IXFfyKuGZMYYf1mSzzb6FZJ+cHz8g5K+cnztr8UYt8e//4ZGqY4kSSGEs5K+VNL3vVplzSSTTDLJJJNMMvnkStDwDv+9VuWT7ZN5IsZ4m53qhqQTE675Gkk/i7+/W9Jfk2WcPyJjhvqvk6Rabl434XtBTj7ujGqF6Q1H3y3vrP6mRdBpgAuw5IJV6GP4EQSuNFx2jGo+7cJMdoyifR6RzbefuXF4XHFZNPLXUsDQC420Az1fsz5yDFpgUACRVUl6Zi9VPekqTLCFgwqYOeMkUFdf41eAin18L910vWm/6SQ88lGEI7tgInZPLMMHsGT96nbgS8sMLj7F11UAr8d0F5ORiKntyP0nWSSYQRRlF9DDIAMicccht6yLtyxYn7vZYvr+m0C697eTn9jq4xZlLs6DIgSRF6erth81B6kuz6KPdRzn6PMHaQxcx6s8GlVA6sc5oJp11wBsa6LHcz5CCHKrldC8XcfPt1Rhu6VnPH7GZk+qgrP14NmEGNXz1se7A9SE/qRbLu3dDMpLRJwT3hnnBnsL9eezRVHeiBi+ZXAnNlzbkH5pB4ixRwD34GdH+iBPB7da4XySjvd608vawLkr7rJF0lqh2W7Zqcr4AdKK0HLGGQY3sTn8+H8z2pqcow1HL5cHtRMBPLZTxyHdG2i3FdTRhbqbMxDkeR0I5YP16UZU8pbSb1iSbqLfvx7+mqeXbMYq0m6tI5DooG99S88hMKmNb7zasjA4Uc4BOlbZIZ5vXUbAG6pi3fVza3lM57zbJfuwD0a6F+R+RzLvWuDPOLm6qd4QwudrpGS+Y/z3l0m6FWN8fwjhnS/xvO/VyMyuleLpSMVyr5d63ZXB9uHxWtdGUTeHaUJpBjgfRzvDPzZMQRAfR5TsSRexmZvimE3CasmauM6By86bQ6i0UrE8OLCDnsFIJLBeqVglogLT8NmHdlK57eNUejJd1x6kCJIyUhyeqdkJhWYrKlY7Pfvwp/cmR6vWXTQT89Fabjxv/kjnLkDhYd1J0jqIsw8wIa937PM4ATKy2y/sFWhKdDy/4aK8uShSYZx3kx9zo7MqfHQ+F6fPWds5PH79m9bNdaVzqX1iP42BwW7qR4XTVknKnU9tfRK8osX33LTPvpJM5CcRULIw51gUsDC/fo51buuIebBpQvXWNxI67yCk9yPHmKNrSDHp0969ARuZJ5ZSlPz8w/a6ADtx5cX03opzl1nAcR6Ksw+eIXdfF0GGD89M5miUpEsHVKAm8wVK0rNI0Uc+05rbENNF4fn99N7fPLhmrjsTEhF/K6Z6uVCzfYcmSro8zDtzeQHfdaWVn/i7ZPk6GY0876zCjOJ/ZhfzpVOCaXJnPzrnlHn2v03Mq0/uW5cRjuWIeYyuVlcatn9wXVoBcbl3u+jAbE3zvVd0S5jjzoDMfrtrr2PbMHHH8i3rTnUK5O5L2KTPuCh5lpabZR/kxTpnGXydPzyT5m0S4F9s2jVmC5ycjNC+2bT1TGDJp0m923LbJ/N+lk+2knkzhHAqxng9hHBK0iFDdgjhzRqZxL84xng7G/JnS/qjIYQvkVSRNBdC+JEY45/5JJc7k0wyySSTTDLJ5BWV+z26/JOtZP6kpK+W9F3j//+DJIUQzkv6CUl/Nsb49O2LY4zfKulbx9e8U9I33YmC2Y9RG5208yJCOYO0gx25IA+lHdS8EkJJxE6yZtM5mMsbLtCBaSW/8IHkntp0TtncIc+WUlkHbte1AJRziHMvbllE9hLMFEwRVy/ZyIlZZNUpwDbXd0EG/cFkZ+kCnu2de9so3y4CQ65bMNVwBJJb8+3Ltm0WUM/kQdx1wSDP7E/u0jSJS9J+f/J1fldJczTnAk/F1MJMQWTKZzjZAo0HXQxWKs78hl3/EtDKvisg0b2lWqrcvjMjFpD1qvDIQnrPSbhMdJydqYGHIHtSuebSNgJ1Ino5d8q6KJzrJnPcM/vJGsAsIZL0QC2V6cJMep5Hoz+4nVxBfmsz1Z83vxNlopm07RAjmtVIFdN26efyZSKt5ES1LyYKQ/TSIzd5g6pNDkJrOi7cIzEVYyG1kWSDpbaIaDmUiY87j4RkG+01cx0DJ5j951bbDsRSPr3gPFJTevP7DqwcDIzx3Ik7qD/D6enM4DzXA4JVdWbwKqoiwB1qy3ZZU8/k7vXWqBeR/YhzBl03jmS2QlAhUU66GkjSHlwbuN70XX87hYC0E4sJhVzfsZmoLjaThYJBlJsdi1DWp3By7rtp4jqyTJ0FgnrBzRMf3oU1BVVRcK5CTD1KRHbJBU71Iuscv7vAWsZoPrfnFoy7LFFZxp9PWEII/1rSOyWthBCuSPo2jZTLfxNC+BpJFyX9ifHlf0vSsqR/Nh7w/RjjE69W2TLJJJNMMskkk0zuqsTMJ/MTlhjjn5py6g9NuPZrJX3tSzzvvZLeeyfvruZz+hTk7B3EtEPjRsbnve0N0z2eXJhyAwDPSSBQy2W7SyLysngyITKrjgj5xGbaee3vIBBm3ZKnz8PxfG8vXbfufEEPsOuvgZKjVrXb9OosgiBeTM/48FWLXvzuTvK3YjzOLh7ng6hYs1exS19wGUlOgwrkAVAnPezoNIjq7sERftFRrORA8svc7zNFu6t+aCbt9K8jEKbrEM8WECTuOPvR9510zCxGB45TZgn9hcFRDYcOLKOeiHi6mBHj4/k7t5K/XH7dZota+Fhq68+9gP53IbV1cFvq+GLK9771S+lFV27aZxPlqCFQovx43Vx36kzqMO/opWfXCivmOlLtrNRSWQdDj5cnIZ1Ox41rUqkQtfJ0UJQXDhLcuPvkWXPuJMq0Cd/eDUeof6NFuiT6FNp3kbGG5+iH6VGcU7U0Xpnrfc6Nh1OVyR5fLWedICpGP0KPsM9hqqFf3VLZ+6On48vIx75c9j6Z6ZgWCo/c0rd8G/OOD8rkn2fr6Rt9hh76TVtKJO+7Scqx9B2bXdsX2eX4LgY6+SxhHG6cP5dcwGcdiDbb7WTFmiuInG/swlLg1gcKkUzv93uAXOirWHv+8EnbgZ/ZS++6iKQXXVfnHJfkpW+5tl7HZwVA7jMuZzpzqNOlfdatRaTn2ynfe/lnMp/MTDLJJJNMMskkk0xeUcnM5a9RKeQsqe4S/Gf6Bo3yaGWYcHRUykAoH6i3p163BR+X3VsJ8Vh51N5TmkPk9HraqTYd2sAIumYX+c6d7yZ3Rozsvr5tWaBK2IHeaCY078ClpmNkJ7M4MiJ6we2+Wc+r4Bypu92oJQZOEMVe10Iy9KEMwElrLqL34Zm0y94GssQySNJZUPxwB7/jIjGZQzmY3fL0/Sff1BlOR3hPVhJi55El+rFyl+4IGdSCX+F1pBCccYTO80RyCTMVUc87iXxdkmID1CTw8+0MbVmXQBbd2En9srJp+zkCrFVCfwmaPsu2gFpfObDIKNGjty1Oz3vNdmPqPN9nyR5g6FEcgspzC+izpx0tUC2f/qZPsX8ehWP5NNAjn994ppDq5RTmOo/2nKik8pFdYsf53+UDqZhAIeVYHhhBT+TsuBSHPOfL10T/5fHJsr2OxPa7PVLS2Xedq02euX35eBUj2dtuvBK9rABhnyvY59Xzk7+flDkLjiWc/uinEJzvy7rk6NcOy+B+Z79s9BykPeW6DTA7XHCUSAe9yepBITe9j11BOmBPt/bYlFQqHvFknbEmztWsQz/ZKoiCV9z6NYDv5uvm8fGWOOGuyX2uY96fSmYmmWSSSSaZZJLJvSxRRwMG7ze5L5XMZj/qdzenk6nfFr/T4q6YELb3pSEZ+yyQIPqSSdJGJ537hYunD48f27b+hm3svG45hIGyBbSRkYCXmrYZ6XfKb7rUcGGtkBuIEPTowKUmo1/T74zU9SnEWH+s57N1W+l/YDnVRRnRmx/csagr/broR+TJ2BmpzCKddynJmFZyBmiURx65Q15v8Zx9nvHxQplWXHM+MCVlZ9MR9D+5m/6mf3DFISZEvkjkveYiVBnR3H8xcUAWzieOSxVtP2o/lZCDcmU6MkLEfriRmA6u/aItK5MVXEdffNHx351B2edKRFBtHRGxZLt3nf2JUb30l3ts3n7vAjgcP+9kImCvOF/rW7AAMLK+6lD1fYyPS82EFPq0fBwf1k+vPPF3SXoeoHMdyM/AocxvXkjPmAMhv1/Y/ut6qucbCNmuuxWiAp5R9vOjRPlkjUi/+5n4g1vgdsTcMOMQVNYR23qjbeuckfobYOVe+H/be9Mg2ZKrTPCc2NeMiNy3ly/fvtYulbYSKkoSSKwNaMzEaJiBGcDolmx6xqYHMH5Az1iPMY3GxqyNFtatoYumaRqsDUEjQGgDSVUSpdpfVb19X3JfIzIyIjKWDJ8fmS/Od05lZGVVv6pcyr+yZ3UzwuOGX7/uHtc//853TBpYlNzr8aXr1xOVdkGG0bJPN0sbs29j4OrQYfKdohYU04Za/8toUO4h7kigHnitnLTF9Er73xGsBV6vZVDrcLe+P68j1BE4J43Bb0XNTHW6X0kteo1Tx62ilBvol9d7DZNZAab1ufls63jRuFXMA+Eb3yTWYrvgt8s9PDw8PDw8PDzuOfxD5i5Eza3SzRXx5BuNiRgEo/gsY6eih+GPjNHzIRuCGi+7EkSN1/m8rIjrTb0qRJ0SMgxDca1pQ8YIM05YohaDZtv56RERlYBBrQEjljcZSTqA4RkC7dA4MHvoDUlElIWI14dysjI91rGsymHWoTugubu4ZNmejaNzbbq9dqwQRj0SEaUXsq3jIKTXDAcsUyjHyGjbvpMEMg5ZndMZnYIR9VU1YJ2GTcrPfF0a+plZ9NbUzE0PRP9mIu37NvbNxXPyme6ecSlk2CP0TuUF0K0ZzdMl6ItpYN+s28ItYPOQbcgbyVkObuIyaMusryVqVcdK0o+KdRudi96O8vr5vG6kA2nw3YO6J5P63tTyMp8UQDucNBm6UvC9mEo2Y0hhzLSI4/9KUQrGzUyN3qlTFWDlTeaoK8tSh2pT6m11cBjtGwRfYJthCtM29kI/t3Mf/oUOCJZIwvnY9gMEsn7o7GDnt3QYj6XRZiqG8QxuPFZsdH4XjNdecAWxTPDUCujbIVtXeVX6YrfxWz6dlXKYKccYUtA0aK0vQZ9IGNZVacthDu8xEf09UakTpgkuvE5TLOWUX6iZIwfjMlYCJPW7aTyCA8CM7k/JsfU6XYEMVg3QUyZNOtsUZseDMVk3W5SzVfmuW8sb7yRtFxztfU1mewW6h4eHh4eHh4fH2wO3RoZs5d+bATM/zswFZj6z/u834b1PMPMlZr7KzL++hXONMvPZDc77KjN/k5l7N/v8nmQyIxyk/VFZ2aAWBhnKDrPqR08z1BgmTCutgK/XKwXwEovqZTBqhy5DapqFqj5hClZe+xJYP11uAjIhPNopjGBPQvtuFkCP88y8aORQF0akV7uYSabbrHzjoLlBTzNsPfTqI9KkGEYfNo0q6zysQM/kwePSZMdAZnQzWQ3qg5BBOV/QH5qoCE23mYch6vQqcFFl638JTWsj6BF5cAXATBk27/Uy1APZy3RY0xfIXmKftRlJMHp9ekGuPfnafOs4Otped1mDPpsKt8+aUQDGrto03olwXAbvumVjYohsMmpO7USL95qhX2UjetwgA90BY80E+9Io6GUXl4VJbhi9bFnlupc2O5rLq3IjoPu9ns+2ji8saS0djglkChUD+Do6YGOfR6uDyytjVXR50I2JzBxu3EQ2+V70ySyY8YqMKo7XuGnzZpv+WzHjC7WDuFOT1+SW+q4QbPF0x/SFYDuhFai1Ts0Dk14ryg6U9SbOw/UjwziShNzgRicN5LuKare7EAvAxOHc/EBWz/vo6XkBdMNLpv8y9APcBeszvpsYvY0Zq8hME8h49gDDfqGgC6J2OLTJHN6EPnZtGX6jzA5KHHyfu2Hnobyqd61iwY372E6Be/u4zKedcz+GLzBzkIi+QEQfJ6IxInqemb/snDv/Vs7LzL9NRJ+ltWQ7G2JPPmR6eHh4eHh4eOxkrEWXv6Nf+SgRXXXOXSciYuY/JaKfJCL1kMnMjxDRk+t/fn2jE/FaZos0EV3d7Av35EOmI6IasD+oK5qvyerHLtKXnKzkFgKSkWS0PKLKncgIy9EJi6Zeo0HrVDQA6IOMtWYWFsUnO0xyb8CpjIQgPnhKEioHTCBh6rYwJR+BVeazczlVDjU8+L3o/UdEdA1W8DOQGxzZz9vL+tqRhUU9ZLiiK3smL22E5wibHMzzVcy8IV88aSKT0QhgEDJ+2KjC6Qqyg/Je2owI1BUhI1aq65kBsyxhtGQ6pE84W0M2VF63DCVmNZmFZPLOaa9IzAb0QwNSh4Mpw3IE27OrrXMboV74sLDMvTnpH7WndR+tz2alrhA5fSjV3hMV2+tOyehRs9J/MXexZXsXwC8R72FvXBVTdZoGAdjhDhNN38RymOVKl0MyBGs0X9FfnI5g3eV7rVYNf2SQwRtI4A6M+gidBwFjZVU6UkdYM2zI4uC57Q/bPERp43tLhhp9xV1sHR9sHmodjyY1O4vsKvovBox2E318y42NWVIizWIHgH47pE0oaBy6fR7q3thkv3GiJrtCP9yfUe+hJzJ6lRaMF+uIHpYtnEjLZB8P6ou6WBRB+QLsetmqnuyQeTED3q5xowGugWYZdf7WN3YcMlGdhgxdNhNdDXY/cktSV5s9CX2V0bcYpg8iInp2Vt57aR7vtT5hw8nfKw1gkg2TmYnJ9Q9B3V8t6L6Ic33JVn4H4E1shXcz8wvw9xedc1/cpPwHmPkVWnME/WfOuXNENEREd6DMGBG9b4PP/gERfc459xQzf96892FmPkNrqcBLRPQbm1V6Tz5kenh4eHh4eHjsdLyJ3OVzzrn3bLHsS0S03zm3zMw/QkT/hYiObOWDzJwloqxz7qn1l/6IiD4JRXC7/NeI6HeI6FfanW9PPmQGmCgFzFA8hKt5ueSYETp1AyV4wMmKttv4eA1ARDNq36Im6s7BEuXBbPvMQJhXG/WVi8YHbX93vnUc7gaGraC/NwSr2P5OMdQ7tKKZFowmvH9kunUcz+oVcvK6rHYvFcVXMQOkidWPHu6Q+uEq3Q6oHJwjDie0usu5qtzPZWDc9qVsdgf5gn64XJsZCCPAC1C/BRNNiwzqEIitrAYVCZ8ZiC7NmxzHqC0bAf2tlQph3zySkL6IUZkWyZDcpyN9C+q9RMfGobuKBTc6OLckDGN9Us49vdypzwHHH+yWfn6wQ2cQQiZiuiqsejCg+zlGr3ZF5XwdJmp0BvSQFaDfxsu6jXBDAe/haNJEoUMfGQRmpKtD+9oWSlLfGyVpwDslQ6HC3+kQ9iNqiwXIwDJZlvrkovqakOl/zV1rHT8ROaXKHYFxiOyg3U3B/leAzpw0bf6e1ROt4ypvzH4S6fE7A5rCJeNcgcTSdFm+N2N8LVE3jTpd66yBUzqyl5M1zdL1ReQmdIXkeMXk0cbdnrDK862/FzOAHYQscAdzhdZx2WQxO5MX+vOVBbn2hzr1tWOGqCZJOTuXIlveGYGIb1PXv5+WufoG7LTcb743l5Ydi4eywvaeLWjadgK05YfAicFm1MrBPb2zLPPRhNNzVQBmlMcSMtaCJtMQZsrrXZG5Jjql56c++P0e22F+QY7uTe5yZv4sEf3S+p8/4pxr5TNyzn2FmX+PmbuJaJyI9sFHh9dfe6v4MhF9abMCPrrcw8PDw8PDw2MbcC+iy51zX3DOPbj+b4KZ+9c1k8TMj9Las948ET1PREeY+QAzR4jo07T2oIjnyhNRnpkfW3/pM5t89WNEdG2T9/cmk+nh4eHh4eHhsaPh3tR2+ZvBp4joHzNzg4gqRPRp55wjogYzf46IvkZEQSJ6cl2rafELRPQkMzt6feDPXU0mE1GBiH5xs4rszYdM8+S/CFuexVWh6csmTV0MzHJx27XubDNJuSzsgJSNWfRCTT6XTsoW9JHOvCoXgq20FdgCXDUpDnMHZSsiAPuuCxd0/e5Aar8eCADpM1ZH5SWjml9H0Oz6oQluFbaTlmF71fh4Uydub4Fg/uqSLoc2Mhh88KFePfJ+bEi2a8KwbTJuUmV+d0623DtgC6sjbDcl5IsnwFTeWhPN1mTLKEDSMHY7D02gMdBsqqKlBygr6AdLk4iRWmD/xeN5Y9mCptwFCIQpGbuqrvtk+yw0Kv2juSjX50o6eGv5Nfn75u2u1rHdFsaWRcP0joTekw3D9tlpCJI5M6/rGoTYizhISZp1vd04tSLftVSTuiZC+t6gX0oZGnN6RXfaKOy15qBf2e3yRHRjCydsfyK9TYlbnlMmtg9tVdAK5wBII16fPlVe6Frug9d1Pw8xGP7HMQBHX/vZRRhTddl67GhoKUM8KP13viHzydGMDphBYDCOTVOJfbsTLtJaGKFhGm7Nn5nXW7IYRBLB+xk0kowgjj1IlWnGYVdMBlwSrLumV3SfPQXb4t0QoBmCPj8+rufbCegHEzVp8w8Es6pcDyYGgGCfsNk+jsLvSA4SeYwV9feWIBAoAwFzFWPGjnd0X0bqt1DT1z5WkXF5G4I8J834KsDvMMocBklvb+N7B+F3s2y+FxFPSxtZ+zaUWiXtD9U24+2KLnfO/Wsi+tdt3vsKEX3lDT7/IhE9AC/96vrr3ybdNd4Qe/Mh08PDw8PDw8Njh2PnxbvfW+zJh8y11QGaFcvqZSAmDMpUVTMt+JkZJyvT3oZ+cM+DOB/tIRZMkAeyTvM1CAIwZtZ9KVn5LkHqSEw7SEQEzg7UWITUYEvaKwJtQm7mpe6DKZ3S8VBGaMXL492t4yNuXpVDE9wo2NAgaXI4rVlXFPuvwFLNrtp6IPDkh/vlfoykTfpJWM1XgSFOGlPkMESyoHG8tTBCa5xIQFbiF/N6yGchTWIVrJNqhrXGj6ERdacx6MegoGmw1rGpBjF1Hpr1Tpv0eAFGVl3q9Nx0tyrXe0faMzUKnx+QvrN6XQvwm8AmLVaFCXLGUB+DHmbBtL1k7Kq64lKHzqgMDpvGNMSYghXN0zVrdQBYjrGStEOnCZLRdjgY5KWKqRSHZ8EwvT9u0sCCxRcGeUSDlkGRvom7GpbNw/phsEoK+oRN5edgdyDlhHW9Vp9V5UYq/a1jBvay1NBtdKOabx0XAzL3TVJBlYtBStwUy9zCpk+kwOx9CaY7GzAzADEkMTW36ILIeKJhfcScsAApRSeb+dbxcFDbt9VgIkIGFdleIqL+LASUgGXOvopmRgf7pJ2iaanDMuysYGAekQ5MHIwI22iDmbDvoGl+T0JT4hhYV3HSeSzjeagDU41KO1xf1v08CzsRfYdl7H5sv56bL12QYNC/HJN2tnP9yZz0vxUwTB8ybY7MbTcE/oXM+F+FHahQUr7sdFZvl90qZ1vHdm7Ybjhy5N6m/fKdgj35kOnh4eHh4eHhsdOxwwLe7zn25EPmqnO0VJdVZxI0Wh0gAsytahZssSEMBa58bZo6BKb86jLpGDHVYAHYmi+Pa2b0ZIcs53FNdyBpVqoLkD6uItdRNFqVEFiLXFiS5fLr0/LJyvBsQVaxlqmKBbEt5XW0Epk11j9oG4Op2o6m9ar1w/3CvPTtkxVoo6KZwlduDLSOb4GFTJfRx+E9QIYsafKYdQOTlgFm+X84qCnFZ+blu64XpR2slRAyL2iQblkrXEkfSkn790a1dhNtQZoOGQB9PrROuggL+GWTC/Wbr0pCgR8duN06Du0XBmW1oOtwY1wYiiowt8smTd049MWuiNzfecP2JCtgiQQMZdBQN9hDFiFFqjWUx1uK5t89+mvVjkIBbIGGEvo6QDJGmHH2alEzPMOroNNVddA3Rxt5y+uWpbsFOUSzMD/h55HBIiIKwRengzL+DRFPt5dB7w1MV96YrGdZ2NCakwZbUL7NRA7mln003Dq+tqTH4T4Y9MjYWUUcpt5FmXPZMK34Xg0aM240dp0RaYs50LeuNPX1psC0HvWus2Y3Kgh9LpKS+5SO6OstAvN9Z1KOZ0B7bK2EMBlDN1TCElslGHuYore3S1uENaHc9Wn5/Vowuz3IMndHpF36Yprax12w7KIIa6M53ck6YC6dh9+BqLnZmFIUEzOgvdfa5+S9BGhQg8bIv7wk15XpkDoM5HS71IFdnSjvvM3pPf6MuTcfMj08PDw8PDw8djIceSZzV6JJjkqrstLElWGpIaumWFBrHvfFZdWJmp2bZR1d+lBOmA1MmVY0q+8F8L8uKX2bXrl1wTI9DavMZFgzS9Wy3K5CAVbIm6yFcMX4wqKOxMaV5jVY/AVZlzucEuamB1a+V5ek3uNlbfb9ySFh4k5CdO6hnkVVrvPgxib1S7N69f1qYWMH6y6TUnM4Lm12GVJgZowx8OFB0Z1G4vLe1ITWt14Fs+2lOrJM+nt7otIPsM0f7sqrcqgrwlOwWaXHIPJ/rir32ppoowl5FljSbsOqIxM2d06uqScCfdss8lEDOQ2uB1eKetxUoQ4PZmXcWU1xsbKx3ng4qe/1sbR0xiHQxE0WNKN4Jo8JF+T1sh42tARdswL5GdOGBTuSkrrn4V7bqPEMRLkPg3bYRp33NIX9yS3LbkUqpPvyIupYoX6o8S4a3WoNoqiRCY46PSDwCjGBQMQkopgx+tS7GKGT6u8BzraOU5H27BvuHOB4GDeR9Zmw2/DYpncFspcGgBm14/DykrxwMiBMfDJs20++69W83KdDKe2ckOqWzhMdkUrtb2j98sKM3N/boG1chL5jE0Jgk41C17ZOGMjg4Q5A1CQTWAVne0yFahlATFE6CM4hB7r13Dy/JNf00lXZSTo9pHW/IbiuA3Adk+ZeYy1wvFqW/sqy9OHDWdG6duZMUgT4DUxX5TpiCT0OD8OOUbVpufRthtOxIHsRe/Ih08PDw8PDw8NjJ8MzmbsUmXCQfnhQVmE9EVz1yx216owAvKL1M8Y4ElJ7dYE2J2QiQBcgjdjVZWnq93epYiqCDr+2blZdy0VZ4a3CexmjpWkovRvoW4K6fiiFO52V476YXgn2Qoq9GOhnVh0sW7t0VxoEn7b7DkrKyuSoKkYNWDyPXxEW8UZBM4oDENmJg9KuS9HH8xh4p42m9Cp4FXSFdWAH7ar6BKRWG4zJNdaNrg69QHuB0erv1pGOQYjEnpuT9qutarYM9bInOzCa2WrQQM8HUc82+n0VdJ0Xp6UDVp6R+qWSuh/lwGP1Ibi+A4Z5nIL0p1nQt8aM1moRNJqo8328V/c3/FwS6tRhvAlPQFq5MPTzqrk3h1PoNIHMmaZakOVAz1uroUQvwMO5fOt4+Al9vYEuYSyHb8+1jqN/pyOdLxXlb6wrk7TRgvH+fChn6Np1TK9k1d+zoBlHrVuP2QE4kJJ7E2ZhrSz7hvMJMjB23MSCG6c1tD6FXdB/O2C3YcmwxyvqfgDDa3aP7oem7TD9D4F1qjelMazzB6ZdDfTKb0qC9HwyOyUnxBZDFwA7ZwzEwJsUNOhJEzF/ICnjOg27W6GUns9DhLsa8pmiSWd5HFKNDiTlOjJ9epsE0xNfvCHz8bzZVerskHniQzDfPTuv53D0r+wHbWnJzH2z4AGb7ZAxmhrSfX61IXNDeRE07CY1KH5XsWE6/g7AHicy9+ZDpoeHh4eHh4fHTkdzj4f+7MmHzCA7FeWahBUtrmDt6pvhZodh1W/ZMmSt0O8Ps+sQEeXKwoAOgghlxazcjnaLviedldXkckGvumJx1JlKHayer7oi3zUImUs+sk9rbmrAFrw8K+xW2JwP/deQgUIWzbJHiimAjAuVO3o1OjmebR1fA/bS6ohiEGmLLFOxodsS73UcWJikYSgawGQiu4irciKi6ZKwFxh9ae/hMtQD676Y16v+IFzHAjB7fYZpxewbKbgmG/mfAmYjF5O+g1maiIhq4LV3qyBRozfh+P6OafWZVEoYgBhoXWlGuyOUQP81BBrFXE635VIBIvXz2daxjS7tSUtbJPvke7sauo1i83IOHK82Wj0RQr1se3YL3wszeBOaqGD8rgUY4yP1vC6YlOtlYMRRL0dE9KFueS8O42saIutz5r53RYC1BmavarSHK035rs42TBIRUb6+8U9B2OzOYN9GdjFt2hXbEndk0PmCSLOr+B5mKiIiysFcg+erNjVLl24z18eCdt8K38P6GB9aIM85ouuEuLKYbR3jtZfBo/mk8W8cgOjwCrhJ3FzQ46sBuxBxjLY23sSwwaadBEymLJxPujohk1q3Pl94eWO2HL2ciYgSVdi9gGs/mNR9DH8jcNcvSbrvxALSF2u19m0egd2tEuzyxY0msxvmRdSW7xR4JtPDw8PDw8PDw+OewpHP+LMrUWsy3YQMIHMrqOdpv2xYqILeBbJjRE0kZg5CGv/HQ8B+mGhwZGQ6h4XVMWmDKQQamRCETsZvayYIKVUGxiK0T0fdNmflcwvfgqwNp024HyD4CmTbMOzgNLChzTYM6vMLWi/3MWCgZhekfuO3k6pcARgUjOi9U9Z1GElIO4+CTm9mRa9Mn1+QFS1mzfmZqF5V5zLSRsgKVyr6OtJh+dzcCmoK9ep7FjLiILNUz2tW4g6c/3AKssUYn8xcU977LuSiRxcAIqKfOyD3tLdP3kyd1O3XmJXz3XhGzofMmdUyxXpk+mOI/N0X1ox4x6KcO5OT+nS8T2uZMwUpt/RNKffKom6j96bl/kaGpb2yEX0PwzelTshozxuvww5wbMjX5XxHUvp83dBHkAWbrerzYbaclVWp+8Az+ub0x/PyR3VjVohI6w8noX9gNjGbjxnZrTGI2p+oWC2uHJ9IQ6S0YfaK8LlXF+V4uqLr3ReX8ZaEoZc1BBGeHafcvpj+3v0JudfIiE9X9U9TEuqbAmbaMpQ4h9wsyX1aNunmZ+C6jkHlH87pPuHw8uFCnMmtXgFWtwK7HMch5/fJx/PqM8EecDO5LIzihWd0Lm/UCg+CA0IgZX6+IWz82LBogLsX9Jz7DGQD+yDM0+H7+1S5zJD8fj00J24c/2CyiS2B5rMjsjGrSUQ0Awwo3reK2RX69pR87kSHtEUiNaXKhaEvzY3LNcZNn50oy++X/V3Zdjii1T0e+bMnHzI9PDw8PDw8PHYy1phM/5C564EBjU+XbrWO+11v288USFaWhwM6HByTqSDjsWL0HqjXQq1lYtjonCDU01VkJbhqiMfYMVmR8SnJtkFD/apc8MZY63j44s3WcWi/Zjxx5TsUEWYvkNFsXs+Lshq/NS4ryyisVJ/o1deEK1rUF5bNqnUfZDVKQ2aKTFh3zVGIgsToY6vxwuwY15dBl2SyXhTBi60BdVoy5S4tSZvNgz4I2RQinV3IEWpYdTnMmT4H/aVu2OMoaNCS4AqQjWimagh0XpmfGZQ3+jXbELwimVvuHxftJepRLcM+d0XY2XgS7mdJ9/MyXEd/n9wn7tH9LRCVe9oN3qk5kzM5CKxpoEcYinBM94n94HqQryFDrBmUAmjSopCn3mqy0bsTXSOQjSLS0brz8L1Bc69rN2XM41i234u5qWcMa3oXNmNVRxgdB+R7p1Y0a4VehecgKw368RIR3SnL9+IORYfRIULacAqB9rUrajwb4RqzEDXeaTLlJGAsT4OWHKPOifQ8ixmnrP+tjoaX8+H1ERE14T3c3bpU1H37o8Dqhmelz64u6u/NwC4WMuInTounZCCtU1G5FfkMyo3tnIEMPnrXsolC524ZR50jct+SL2tPzwugHw1BPnE6NKzK8SE5Hp0/0zqufEu3EbpQ5Evym2e1hr3gB90J1zRvNJ73Q6q8Inh/2p2WAMwTEehHF83uURH9jXcYkUnkNZkeHh4eHh4eHh73GI6cZzJ3I1YdUR7y1k6UZMUYAGFj0XidpUlYgCKL7qzUyKpyJVgZYRRfyGQQugVaxhdePtg6fuim0W6BdjNfltXo6Y9q7Rs/eKB17E4ckWNDQQUmZ1rH6eOgoexOky4Ius6HYdlqPPky6eut431/l5e65mXVitdARFRGtgeiqDNGt4oMI+apfeIT46pc6L375I8OYL6m5lW5h78qdf3eOVmZD5no7WxWKJ4mRD1y3kS1wz3sAB3s6/PAy/ERyJBkfffQ07TSJqKXiCgQwIhoOZ427HYYmRxgL92+IVWOo9LOnaULrePqWemLrElcqkKe3zM3NFuO6ILozWCX3HdX0JWtX4bc9Ksy1mxGHdSC0jG579zUDM/9Y2elft/XejLE0WRhw9cLK5pBQSYzDhrZ0UHNBEUg08oq6D9TD+gGbBbkvckLG+uaiXSGlxxk1CoDY5c1zB46WaAW3LoP/G1NvhczvdRMtEEnZIjCNOQRk3B7Dti3bET6b8xEoYeh/45iXU30Ns6f+xJSzkbgo14T83fb60UPU0SXyYCF178EvxX7NRFMtQo4Y1wBb0ejQccxMNgj/TzUI59fNWmV5i5iXWWOjAQ0S2r7Swvm3vBBGAO9svsWTd5S5UZfkV06B9dONT1XuX7Z6Qv+wNHW8aGpC6pcaVbGfLgiDdud0OO/E7yT0WUja3yeq80MHMs1Ts1p3839aRmXWZhz87Na07ovId+7P2k6/g6AZzI9PDw8PDw8PDzuOTyTuQsRYKI0sE4YPXjYjbSO45voM2rN463jiokkPJDCVb+saG2GnmFYycWCsmq9say9EyPAVOE5gqNZVc4dETaUIAd74MyrutwVicJrliDbUb9e4blBYad4MS9vzGjmhjsgqjonrFCyJiv75ZLxTgPtVS/4wc3MazZ1oE/Ol/0JyTXs3vuEKtfsByYNtGA8O6PKJfPPtI6PTORbx/s/orNZBE+JftFNSx2qf6WjS1H3lwKt1UxJ38Ory8Lqvv9hYWHDvSbP95jctwa4HqwYnSO2ZxrYyo+0lxET3Zb7zgUThr4AjCVECIe6pA6Fi7r/FopyTUlgy5aN794d8BI91cjLGzXNyNTgLczhbjWK4RFpW3dgvxxHdR+LLAkj0/GynDxtPELTOfm7CYRgeMFmJAJmHnKmp/Zr9iM0APUDejDwwIgqF5iTfpU4K7sSPXXN8GTBaxezdd2AfOej4D9KpNlLtAUdTOlyH+uTN5OwU1A09xC9fxNBiHCv6XtzEJKKjySA7U3qnYImMIxRw8whuoDdQmZ/1mij0aMWo5ZRi0ukdxjmoe62j6XDeCzvDZu+k+yBjG7gAhLO6Hmi62G51xh5XpuQus7e0drjedAvIlu5L6f9NFEjizsXzYLRrdaA0U7Ld/GwnjT2D8vvRbMCDXbhtv7etPQ/d3C0dRz/BT33Rb97Xur3oq47Av2S0ct5oqjbBb1TMcNRw2QxI2A5093Sjw7PaVeWRdhVi1MbVnib4Iho1e08dvVeYk8+ZHp4eHh4eHh47HTs7UfMPfqQGQs4OgIRphith1kqIja7AyxyUAuyYldQgP0dsnIbOKhXcbUl0GRdEm1Z2kREok5psBPOEcmqcpzPyx8TEiFc/84NVa65Alk55iESs6hXeDwlLKA7I1pGt6xX6ZyDiEFYPL8wJhqgfE13pQ8NyLkjcbneYz+kGY/A4w9IvQ+DLjSiGQqeApbuDug1szqSkCCCMxoRNirQrVff7uRhOd8hYS8GFp5T5ULPCkMRwBW2YTxUVo73QALlQ4OqXGhS/Ouak3KvY7c1uxUckz5xtE0ueiIdHV7+lrRRfVn32ckp0TMdOJVvHYeHIVNGp76m6TFpM2SPUkZnGkMfWbByQJaPiBTzEAYd4v6kZpnRYSEwBVmIunTObwyHx6jbutF4rkLkP2YGuQpRtkREw8AWYrR/ZcKwYAeFGQkMwDn6e1Q5pNUiMYkyHkptrBElIpqeFKa/mJd7ljPZxJKQz/76HdHf7e/XOu7B/fJdy/Ny7ZWKZjJroHks1qWdO41ONw7tPGg0d6p+IbmHNaVbN7nQYe5D9vNIh2biw7jbA/OxZSh7QUubgH5Za7afw/F3wGrGowekzQJDMNesGONNuNe1S/nW8eKkzJ2WiSsAC4uazlVTDjV7GL1df0W3/0BuQuqK7FhNXxO+hfO5qxvG+ZlzrUM+Dpr4tBauBg4DU/qiuFicv6EZ1Byw1h2gk7S69VmINu8DhjxlslSV8uBGMihz15F+rdO/MCFa9SXD4G833g0WRu1H3tsIZr7JzK8x8xlmfmH9tf+Gmc8xc5OZ3wNlP87ML66Xf5GZn2h/Zg8PDw8PDw+P3QBHzm3t35sFMz++/ox1jpm/A69/gpkvMfNVZv71LZxnlJnPwjkL6+d9lZm/ycybibi2lcn8QefcHPx9loh+moj+rSk3R0Q/7pybYObTRPQ1IhqiTbDqiIqQlWOsApkkYPEXC+lnbLQdA3sulTWDiGgISLHBw8JGRY/oDCeB65CNBVZhIcOg9nfLOTofgTcOaBaMQGdX/+aV1vGNFzWbhxoezAJDM3lVzl0TlujF/yyr0/se1rquSAI0fLCIRX8/Y+NHw48K8xJ6TFhDd+ygKtfsgf5ZkfYKvPiyKrf61OXWMYNXZOCA9jB1s1L325ADeJAM6wKRyi4pNzQwnFXFkleEgWpCBpZIXLMDozVgp/qkTs0H79Pf+15pS14Q7Wv0ho4ADT93tXUcv5CXz5hlYbgTHAIOCPMVGdf3cOyK6J5il6TuQzFhCoImMPfUfmGjVyHS+fZ0VpUrrUo/wPqxGV+E+cWBgbVs1Goe3CDOXpPzGU0x6kzLwAqlopqRdcCgFiE7jvVsrYImEBnjaslkn5mStg0Oy722mlHOSJsn9wHTNa8nFEiTrvxR9yc0w4soF8FLEDRnAcMURoflGhMPQeR/WbNHxVdkvCbAZ3DWZN5BX1p0hiiaaPB9oGVGnbnVgmajcm9mwIXC6ttxTlM55k1U+zjM9UvYZ/UGipIL94I4/3Vdtg/0gvtgrqqbDE6wS1T5tsznM+Czu2K8cLHN6pCVxgSNK5Z+Ffpy90E9pzUgIU7z5s3WcbhP35smMKUBzMBkMts1rst13P6SMJSH/ie9K0RdMu+kT8s1nmhqvXwd+lKpJH3n+INzqtx9AzKXNleAwZ7RTOv0dWnb8Bz0CZM9rR/6YrGgI9R3At4OJpOZs0T0e0T0Cefc7bsPgswcJKIvENHHiWiMiJ5n5i875863Pdnr8bRz7sfWz/fbRPRZIvqtdoV3zHa5c+4CEREz29fxaeMcEcWZOeqc078kHh4eHh4eHh67BG/jdvl/S0R/7py7TUTknLv7xP8oEV11zl0nImLmPyWinyQi9ZDJzI8Q0ZPrf359oy/gtYe1NBFd3ej9u9iuh0xHRF/nteXpv3XOfXGLn/sZInppowdMZv5lIvplIqJcOKOiJcOwQMvByjliVsEN+AyymiaxAsWBLVDPxMY8MXqfMAIffEzea05o7aaDBWngPeCFuc9kYJiYbB0vXm6fuaQImpYssIPNWb2cX50TdnWhKizR7fOaGd0fkpUlsi7v7REm7tuTOsNM6LDoutxJ8VizbE/g4iX547xoS6e/pNtosShaNdRDdk/rfLarcImlhlzT6m2t8QqduSh/jEDkuqERAkA+xPdz23JRzApTEEabS7rNXRKo4Cp044ru0gzscXkRIpgNUxXphb6YlLblkP5ezKxydk7Yt/pLcoHDR7RWMDkMDgZQ7VTvrCpXmIDvTYKIL6qnl2oRoochn/2kyRdfBRlmEDIake2/85D3ui4s000TrRpZkDYqAXtZb+p7mK/JdeCYauQ1wzP2d3IdJ+dFyxzN6O+ljPTZ8EdkXK/+zXVV7Op5uR8L4N2ZBTeDUkWPG+UzCMzt2ZvaL/Tgsmg0+94jc4HNvT0zLXWdQ8apoa+91JB71STwuA3aH0phu7Atrb79/JJ0rDJkdKkbOS/uFh5Mtc8Dj7UIA/s5mjRzpDoFMOxG8+yK0rYMmmAX1owsvyS/0WMT2dZxBdjKzrhmHjFjGjoJvLyg51/sp48PCjsYHjSCWWik6WeAwV7UWsbFRemnqWEYX0aTuVqU843DmBq9ohnKIPilBrrlOtKn9Xide16uY+CY7AZEP/2gvgzw+A0tgefoP7ymynXMyznQs7mnX+/idHfpv3cWHK1Se/cFg+678sJ1fHGTZ6ejRBRm5m/T2oPgv3LO/Qda2wW+A+XGiOh9G3z+D4joc865p5j58+a9DzPzGSLqIqISEf3GZpXerofMx5xz4+sU7jeY+aJz7qnNPsDMp4joXxLRD230/npjf5GIaF98aG8raT08PDw8PDx2Nd4kkznnnHvPGxcjorVnu0eI6KNEFCeiZ5j5+1v54PpWexaeyf6IiD4JRXC7/NeI6HeI6Fc2q8g7Dufc+Pr/Z5j5L2iNwm37kMnMw0T0F0T03zvnrrUr1ypPTq1ig4qKhLzIhqGMwXsVWFyETTn08Zq6Jiu84ZyOAA29Hxg88Li07FZgRjQpir1smBX7nLASqV7I/VrQ0X4YrY4MgKuaTBIQhd4DkX9j1rfsotSjd1TqPtAvq8yTxjeSYHXLcxLtx3cmVbGF/yiR4mduCaO4VNcZZpA97gVdV8eC1q1hJDFqnhoFE9Wal3vFJGyoWzT3EGw9Axlg7PpM9iSSayw/JSv96M2vqlLobRc6KOew00xzVupxBzJYvGBYjp/fDzsV4J1qrddWgMFbhOjrV+eFnakZjeKBw8JUYzR49LS+9r5HYBqB+05prVHu/EFgZJ+CyP85o7UEIOO2OqvvdXUOfRCFIbtV1ixTHFg23K1IGlZ4AbSN3cA6xU30K+ZGPlYRVte9oHeN+ARIxxPSd4IZPaHMghYxoHZQpH59A5qJT4zKcXVC3vu7M/tVudlxGUejBRm7SXNNV0CrNgf50629CpJiB5IwfxgdHOaLzoOW2e4KZaBf7QOdc95kw5oGj8Wry8CcmfolISd7DO57tWnLYd+R120mrwpkx0mcknmaU3rOxexWQbiJh/tkXgib/O6FRRkf0+DRanWmWKd4TO4bx3QbYS70haLMx7Pm92EK9J8j4Y39c4mIgmnQe0Od8tqWmToz8rvEaWDcjbvEAuhT+54Qxt0NmmxddcjoBDtffEL70CZefhU+Ip/BnOZERI0iOKyk2zsibBea98DEiJk/S0S/tP7nj9AaQznvnCsRUYmZnyKiB9ZfB6sAGiYinV7vzeHLRPSlzQq849HlzJxk5vTdY1pjJs9uUj5LRH9DRL/unPveO1JJDw8PDw8PD4+3FY4cN7f0b9OzOPcF59yD6/8miOgviegxZg4xc4LWtsQvENHzRHSEmQ8wc4SIPk1rD4p4rjwR5Zn5sfWXPrPJVz9GRJsSf9vBZPYR0V+sB/iEiOg/Oee+ysw/RUS/S0Q9RPQ3zHzGOffDRPQ5IjpMRL/JzL+5fo4fAiHrBmDluYb6HsxZW101+rs2yQBMMeqCCFDUZK6M6xVU6oawdip7QrfWL2KOWNRd0rUxVa76fWHc8hPCfowc0N54yL5VpmUdwSYnOeaqnirLSrpsfdqA7cKVdCwlxwe78uozzUlkjG+2jusvT6tyV8bl2lF7ZO/FOOj2FiGqPTWh9UaoVcOc2E1ja4erbDcljOzKJZMtYkzaOVuS92Imm02zLH+/8pqwR4kLmuHJQY7d7KSwJJWiZhFWVuR+oF6rUNcNw0iz4/01lMy1ZbmO4bi0Gerlxpc145EeFz3aYD/o+ZZM9LYThhEZ1EC38VsNS/0w/3fR6P4wCh07Qt3YS46PC6N4GZgbEztoNIFyPFfV42EwLu8hq5sy5xtNCSOYn4rBO7rvxIEg4C5p2/qCvjfIuOMOTL0pfeBYl/b+Cx2XcRMakXZ+rKhJiYtj4t2JkcnIxhIRTa1s7B/YYVghZACz4PcbNlrG+hb17WU1ucLuh+H298VlACPTN23qPVMFLT44jNQNQ9nOSeTKsj7fR8FvNvJN0Y9zRF/I8mVg3JvZ1nHn/dJGwS7sK0RZaMvhSZnrp1/W+tsGRKVjZhtGZw4iYvDuzIAzwe1Ffa9xfg92wY9ATo//YFbmpwVwErBZ26rfANY/KYO0YrKYoTcmZSDbXMFkCXoJdPoHBlqHzvjQxn5UdgcL/5/0+9kxvROHWZLC4S3rH98RvF2BP865C8z8VSJ6ldY2JH7fOXfXhuhztObSEySiJ51z5zY4xS8Q0ZPrcTM28OeuJpOJqEBEv7hZXd7xh8z1qKYHNnj9L2htS9y+/i+I6F+8A1Xz8PDw8PDw8HjHcC+2yzeCc+7zRGSDdsg59xUi+sobfPZF0s9pv7r++reJKLPRZ9phx1gYeXh4eHh4eHi8W+DI0Sq3d0vYC9iTD5nRQJMOJGQLaQjMWNsZ21rgdq0Vg+NW2jyk+eIZXbAENjzhv3q+dZz7qN6W4IRsRVRflECC/E3jjk3ydzonW5bJjxnhdCeYcl+DoJYV3ZkDkO7xAUgDWTei+yLYqqCJbrJH2jid1UEZzQI2YL51uHxLb432pyEYAepn783pLrneCGx52BRs+bJsST3cKd9rF4vNgpxvdVG2mRol/b1NMIVenpFrL8/rE4Zg27oX+tuKMam+CEE8x0kCaxpmyxjb/GROtqAOp/UWbyC1caBNIKf7zgd75btSYI1TAGscZ6ywZsBeJn1F7m8gqPvR3IxsT2n7EJMaMCVthnZGj/drM+YQxJBhsFWky/Tfm3L8QE7GmjXyRgNxZbLe1G2JZtmpiLRR32FtgdLXlL+XJsGQfNbYDN2UfhAGeQWmmyUiOpIx24XraLr285Obl3HDI2KB1PlxXe74N2Q+QUP9nrLe2j8KY972g3Z1wjHaMG0+mgbbKDi3lTLYAKS7wHna1qkC5zuSMbY7bdJH2jm8HTCAjIgo3gcWYRHpH+VrevyXluTe98A2c+ijJ6QOx4+qz1AIkllcE1ur/tgrqljlmmxHq/aLGwujjAycniM3W8exMd3GI5BSlDugz/ZrGRe2xPsPSMrKmpGZYJ1uT4i0ylrrjfTl5Y956POLep5YfhrmKrxxIzo5iTskgUA9j0n9Khf0eJ2flHksGtx5D3RvF5O5U7AnHzI9PDw8PDw8PHY2nH/I3AtYgpRzVlCOcBAshOXsigzZkKF0e6PXJQi2KAAzVf9DvVrOxoClCwoLGY/pwInuY8ImRT55HE6gU2W5QbD/OS3lApeNxcplWf0NHocVrbGeaZ6Tche+LqLvhTFZOVdruitFgZ0JlIRtKCxqUfYCBBwhAzXSpaM8MgNy7ZjasmHSxa3egHSiS1LXoL4kCuRAhA+r5aB2aaYaBA9VqsIAJMy9WS5K+82AnVNHVJdLhOT8cxCsko0bex5g2Qpl6b8BE2CBTB/tk/se6M6qcqdyEljQuCnMSMclOR6f0p9Jx+S9xQVMe2cYe7D+iS5Iu2J7ERH1D0qfiICh9sq0YUYwNWWv9O2QyfmXOAc2XhUdVIFowDTXAPbtdUkMgHV+zyHpf7GfOaHKUVy+K3pGAiuXntZzQRPio5pFYMvr+nqRfcO5KgasS0OTPRSch/GQgUHQp+VSnT8q37U6Ju2fGtN1xQC3xWW518s1fQ+R6cPxaplCZSTfkHNUbFBhm+mYWX9vDVMhwm2zbDSW24wJ3iqCSQicjMp3BY0dUf+HwJ5rAKzJwLqOcjlSKMpNdWD0HjymA3piNcwXiX5GZqcrAuPwH52Sl8/fVsXmvikd08EuDtvfkV5hNrtr0hdrz+kEGGglFgRbsMn59ikcm1fB+ss471+5KgE+pzqlXOSItr9zI2IRFnhEkh3E6YYq1xOR8VFf3pjp3i44WnvM3Mt4Vzxkenh4eHh4eHjsLDhqbj3jz67EnnzIrDZZGTLPQ7q4ybKsGtCOg4hopc297ozqcg+DHvL9DwBjF9erJLSieBG0eDWjG+oDc/EqvPexh2+pcpH3g7kzsCkUaL86c9msHN93Sr0XQEPhOjB4Fc2qYaqwwT7jI7OOmXGtM+0BA9zQqrR5pa4ZilQEbJAek5V96L37VDnqFd0ZBcEKZ0Zbuwx/Q5il/PPSRuERzXTxEbHGCILmMVTQFkvplNzrJrBghaKmRkOgIUOdWcowmd3AOnUek/eaVU3pxK7JOf7ggrRFT1SX+2ARDKKByXAZzSIoo5icsMmZpFxv+Smt07sNxu9o8G+vKQYpK6Ngyh0I6BU62jShxu58Xtf1GBjbU4/UgXs1EzQwLalBp74h32U1mX1JafNlsGJZMebzOC4jvXKMae6IiFyH1DdQEEYwflVrK8vjwL5FsS3093aCLrm8KFMyXgebmdqtyPmWvyPtFduXV+WsbU7re+b0CZG9PDOfbR1bY3C0m8KUk9YiqBdMtG+W5HqtNVl/TPrE1AqypLogGqZ3wRhIh3QfmwUjefyMTaiB9Y1Ad+mL6vN9KAb3AMzPYyeMNvqUJNFwsHukynzPJFy5BYxgBubPkp5/i+DoE++W+oXqRl8Ic6RLgqVXXtPgjYbo76u35bvik8YV8JAY+7v3S6Bx5L4jqljknMy59T+Tcwx06fGAZvTly21SM5PW8C7fhrScNzSTSbhj1yfsZ6BLz+HlZ8HkP2+ShuwAeCbTw8PDw8PDw8PjnsKRowZvHPy2V7AnHzIdMa2oyEd5rwdWpmljNIzSkGnIPpUK6XIJ0J2EjwDTMpBV5QaSsvJ69O+FcbJsXhIiWVNpYc4S7zcaHtTZ3RCdZP3srC4H1xH+ADCCRqdHVWCkrsuqenVCr3w5DuwKRBYuLIEm07BCAUgXh3rI45/Sq29kFClzSI6bNi8iCNxwBb+q6WdkkxPAkr6OQkFmFFb94Xkt8uxoCFO1Cn0intYTw+yUsIOnnsjL1/ZrDSo6+/Mx0REpZpqIBl640jr+6ZL0nZLRyJUvSVukes/LGyalW+2KsLXBDEQSQ9rGQECfuwj99AMnRNPZNNkJzt8QDVlPD7DREX1vroyJxgu1cyuGeawvyfmjGHlqNGgMFBSyqWHTd0IwXlEfaBnPLIzD1SIwRmOGQTkh97T5vkdax5FBraULf+sMbYRsUqe2mz8n9eiCdJao1TS3hgIJea9RkXt47ltmzgBkwGx+saKZ+JcWhJ1FNnBRk9aUg4BmZAoPJfW4Rn37/gS4ChiGEo3BMWuoM2LNU1n5G9OBztb0vINzeGKTX7dkoL02HxHE8QvzO3foce2OHZY/oP/xBLCVV7RR/tzXZK6JdQgbHe3WbVQpSb8vL8sNGLisGbvAosxVPAJ9cUXfxDIktqhel0bq/dOLqlzik3I+96DokpHJJyJi2BkJReV6k4O6T4RykBwDXDyqm6RVyeeln8a/r3et4vtlXDqIPOdhHSUfiuRbx5Mm4cT2w3km08PDw8PDw8PD497CEVHTeU3mrgOTo3hQVqp5WFXPg/ZtrKRXsxi8WocovkhVMx5jsBLkFLArnTqyM3BYVnIHssLI1C8vqHKlCVnhZX8QVsinRkkXFJajcV7YrcWLJgIU2IHQFVlZ5k7pNJXNEkQCngedXs6kktsnK+EEXOK1aYgkXtVdKXEUIqIfEm2PYhAt8sK2NZ/V6VDnn5PjADAZ2dO6ro1FSCsJEf3NRa0PChSFRcAoSv6ITkYVHQX2oRtYoqJmPNMXoBwYPfKp/aocMpZKN2mYVh6VVKGjx0SbO3tLr8TH7sgN6f5bYR5mFzTTMl8Rxhj1lRj9PmD0to9/+E7rODQo9Q4M6X7+/iVIObkofdlV9eR5f6cwLxjNPL2iGcqFGWm/yHelzwaSehzWplDXhW4QutzZOdFD95JCWgAAJhxJREFUXwdWKGbYLEw5G3tJ6j5w64oq1/tPgMW+/2TrsNmn/WoDH75P/rgmbRkwfrXpHmHp5wpyf0vAJB8a0GM8OCp9MdUUhic1p1mrOXBveHFc6pczLDOmiES28ZYxz8BUvD1AvludOd6PGIzXstnxmIc0kIfSmFKT2gLdPZJBfQ8vQRdmEPutmvD3GOSVBPtLOmA2Hgg0o+70MTnu0GOA8zJe+bz0l8azEtmN/ZWI6Pa06AizS0Lj9rGxEgBcmpX5k7+j/WU790s/CJ6D3xizibPSgL4D479pUtbO/4n8dmRelp2z0HHNFKJfZ+oB/G00Pp7gFVu8KHPG2KRm32+A9zTuppRr+nwnvne5dRxMQGdM6zkyCQH+g7Pt3WC2B57J9PDw8PDw8PDweBvgfHT57kM4QNQNK/VOWKWXjU9bO6CHnjPemioovQzMQdUImEADyYdEGxk5qVdTkQroDZOglTJsmTsnrE7pJhRb1no+9Nes1+V6i1f0SrUGDNK1RalrFZgfIqL7i6L5xExDQ8DO9p/UdQ3sA01QBLrZrQlVrvZdWennr8lKFfWeREQLoCELQgaXU2mtS2pUQOsH7OrSJX3fO+hs6zj0o8Jeum7NtDKylx3gf9epV98MeqjGOalT8Mx1Va65KIwFh0Fzd1CzA81r0ubXL8r9mDNaum7Q8AWAmWPjZVkARgD7dgHYAaVhJaLUUTj3cYnkdEcPqnLozxcog95wWfeJ4E3RUHV8TfrBsSXN3MSiUg8HpJ+r6WvCCPDspHzvVdN/48CkHU5K/y02NKuGDNnsioyphQmTyeeLck8zR8V7Njhk9F77hamihsxBjamqKlYtgidqFdh3uNxAlzF6PSrZTkLdwqoNzWvWdf6MfO54h7gHFIy2dwT8fg/DHPlITrcRMksXwGGhoW8NJQLISkp/64tpFrcbnDvKEK2eMFHj8eDGP8TW6/QH+zbWWi6bjFpY3w7Q81pGdvWmMJTBXrnvbD0qQW9ZOyefyd+Q8TWb1zTprZL0lzJ4tAbG9DWghh/9m2Nx3ZbVRZj7xuQzyU7d3zCbUjgs5wjGjf/tjFzj038j89MTN++ocun3QqaxAdidWdHzSQ3cFxbmZS612Z06I1KndJuMUEREV/5e2u94P8yzg3r8o8PC0HGYa77a9tTvILwZu4eHh4eHh4eHxz2GI0dN56PLdx3qTaI5iDrMQaRzClbIQcP24Kp4s1y3acydPSNsTaBpolArkE3hMDB7JjJRaUimRGfTeFGzfue/K+xZOCirzJDxI0TfseWylKusaE3LImRJWQBmA3M9ExGdnZZV7EhZGI+RA7JiD/VrNtUtCmvSeFVYuaXrRpO1kG0dT0GmnJDRyy2DdxpqCqfv6EhHXPUvQhai5WXNPIRvSf2if/ayvH5Yn6+5LKww5i7mgz2qHHrbla5K3csva7ZhfklYp75OWVVnF3XfqS/IOTCbzbJh3waRlYjBsekTYejrnRBFPQ/M2fVFrTMLvyR1HxgEzVlYMxkq6hs9WxeMp2pVxkMYiOCyye8egvHq4DJWiybbUQJ0mOhxGdDMCLJvyF5aFsz+3aqractXb4u2MTou76EfJxHRvgeEXQnmoF9eNxpUYO0xy88NjIStmfzmMTjHsLDMsUd0BO79TWHVm/BbVpjW4xWRXxZmKh3TLFgQNJ6dYZlPkiHd5tZf8y6ipi2xzSur0kZ2/kVfVbyHlvGMwfnrW5zPUTNqTSgmvy/XmLkirLXN716rSJ3O3BbPzHbtQKTZ1XRIPo+ZymydMGPYZsAMbMEl3UZVGG/dSZnPX5cVDeYM3L37+3Paw/j+adF/dvXI79dKSbPl12ZEF56LyXyZN5psZJNjML91dejxtQAZ04rfkfkp9bDusyi6DQ8anegOgGcyPTw8PDw8PDw87jGc12TuRlRXmS4VZOlVdxDxCv5r0aBejfbC4t76wyHuy0B+3CVZWXJYZ2pYfk2og2t/LquwQ/t1LtlIWlYyc7dkdfba9LAqh1GfC7BSfahTsxy4Un0Bsndkw3oVjCzCRKV9V0DGtwGfiY/J9UVmTMRsDhhe8CO9Pa21jFPAjOSBrVyoaW1UHiIf01DVFxa1djMKH5sAeeBDvfpeo9fjlRelTvPf1QxPJzA5CWAAh47fVOVCPcAcwPXeWdDs4MWCsNiNuWzr+MFZfQ+jwAxdh2jLC0u6XU50AusH92bFsINXIao6ExKGAVmczqBeUZ8HBnv6j5EdyKtymG/7QKe854wnYv9RYU2QVZsxeceHIFtXrArZOqZ0uYWiMH2zcI4pw4xMrsj4x6xelmPqAOJlX0IK9ia0ryXqYlHbWKzre526Km2WHZXjYEgzPJOgzUP2Hcdn7apmcSKhV1vHPAwatJBmuptwveVF+V7c4SAiqkHU9w1g0izHkof6LYDe+7l5k3++Tdpwmz0tF5G7ALJaCrFlmeV4CdL1dIR1P5+DTEj4mbjJ7tYAarMO+c9HUnp83VeRdoouS1+8M6vv9bmCZh/vIge7Xla3ilXCHYpXC5pSXG5Iwc8clIjv9Kh+OHFwTfl5mN8mtM78OmR3GuzdOIObxdWSjPHOsO4Vz0KU/PRtYdWLZhf4B3tl/KOTxdHTRhs9DLtJEJHeuKl/lBf+AX4rr8r3Zu5oJrOvS3aMErmdtTXtiMg5z2R6eHh4eHh4eHjcU/jAn12JUICoG0iPfYmNNZkmKYrSvqysto90RGYPc05zSbN5pYKs/q4D63LpVa3JRA0KRtYljM5pARijRWARUhG9wguDjiUDK+k+o6/CrBwYAWozsJRgJT0OHqHzE6JNs9qjh8qi04kDg2pZK9RXVYBdbBpzN8wogt9lNVSovRqEDCexmF7BBqOow5IP2XzWl4ChwLq+35TDCEn0c7N6PsyZ3FSaMcO0YP8DhvGYIUxSEC0dgn4eM9otjKpGhiwJ5eLmMzOg4Z2FdrCRvhi9fW5GWBM7dSYSG28P2Ej4RErKhYAwYm0kQEVgEdF/scfkVu+AKP4QfJfVt2K/GkhBjvkuzSLWpvTn7sJGbN+czbaO+yqYP12ziKiBTsOYR11yeUZ/52pV2JnCV6VvR0309gqMt4szwkzH2kRrE+n7VjZR2ai9jASw3rocbhKhTtKZcY3nGAYCL/a6cQOOCHXIhW7rDiSYysxm5iec77BOXRHNWivdOUhkEwU9n6DmGZsCx3/XJpHSfdDfDndo3SCy9JmM1C80arIOgf9q7czGfZRI715gVp5Qr/7exJiMoyywl3a84vkeyMg8EzU7IyM5YS+znxF3BPfAKVWumYEseiVhP0NnzqlyxxPgTHJGdoKSfXoMBBPQd66b1FnbDUfkvBm7h4eHh4eHh4fHvcRadPnWgrl2K/bkQ2Y04OhwSlYHuGpdhKhzq8nCLBO4El9p6lUh5s7FfKxKS0JEXUVZBe9fkGjmgFkJZuOi5URt1JJhPB5NC3sxclpWheE+vTrjpKxIhyYlW8zyDeMBByzF/Snp6FGduISqwCD9wznRiS6B7q9i8lljtO9yVeozV9V1tUzkXSTNKhjZ1SiwMMezWlNUA3bqbF7uB2ZVIdIei5lZYQduFzU7gKt0ZEZumQhQLDcM9ylkWGHU1cYUI6v7BEZcYxSqbeeOAWEbIiPSzn11rfHsG5I6YUadmSWhZ4qGiUPN2EFgWlZMdqcJ0K0VgGE/kNRtPpeX78KI0ukV/b2JXoiSH5HP5MqaUZzJS5/FjFPWHQH7HDL7Npp8Beo+8pC0V/hYVpXLzEjbTv2D9LfnxvXAmQQG6k5Z2tzuoGCdsJ9nA8J8oc6XiKgJmXJemhDnijN5PWegfhnZKOusEYXMOcherhhdLf4Vhf5bNIwn7ij0RWGnwJyvADrsNOwYLZo5Nx60s/Ua5mtb04IawwEqtfFLjgV0345AHnHMF5+Ialby0T6Jqu7qkX6aeRx+EyD3ORERRYE5hDHUNDnJXdU4C6yD09YhQH5HDn5E6jBa1p8v34ZsRwdlfPEh3X9zOXEq+JG6OEosl3Qfi8Lu2wqMNasLT2chZmFINJRWRxy4I9/lMEPag5rxDOakbbPge9ws6E4QBOeTREEz1duPvR/4szVncg8PDw8PDw8Pj3sK55pb+vdmwMz/OzOfWf93lplXmblz/b1PMPMlZr7KzL++hXONMvPZ9ePHmbmwft5XmfmbzNy72ef3JJPZJKIyMD7IHiETlA7p1XG7VbD1WNuXkBVZcBAYLZNpIDQjehLU5gx265VlCLITIWMxEjMecCcgs8J9R+WNjBHqwQo5DFmIchOz1Bb97XOKhy8IG/reFfHujCQhU0ZJr0ZrK9K1YklZ9VutYAgYwIHT0F5HTG7glF49t1DWN6d6ThiF3utyvki/Xk+Fjsr19gZkxT7yPZ2NKZuSle8s5JWOGL0snh01fPWqbpejRek7RyASO9dTVuWW83IPn56V+4tRz0SavQy871DrOPUDpr0a0u6pBel/wxfEn3PxJd2WVyEqFbM7JdOaobwPxtf0nNT1pmF7kT1Dv7/uqO4TYcjTzSeGWsexYd1Gh1YkA9bAIvT5qG6jkUVjALgOq4NFV4bQQaj7oydVucCKXH9fTTxW768uqHLo2Yrozek+BoYXyiFgelFYdauDY2D2UtAXT3VoPWoJmH3FohtmENnffaCdXTDs9i2I/F8CXjNs5k7MA49Z1mJmhwJ3mZCV7DV9YgmuA/tRyujlcX5fAmbazu215saTvdWqBvuEBeOY9I/egyZL1WPAzB050Tp0vcZPF1GSeYLrMke+jvkB5wlXgvvbb7KOHRdmD2ed4FXtaxstAlOKW0m9+veLB+XZoXdU5sjembwq14R84BN/J/etp1/38+RRuLKSjGU+e1GVW/5jyVqVfBTGwPtOqHKYnS34sGg86bmbqhz6G+MO1k7B2xFd7pz7PBF9noiImX+ciP5X59wCMweJ6AtE9HEiGiOi55n5y86582/i9E87535s/dy/TUSfJaLfald4Tz5kenh4eHh4eHjsZLh3Jrr8Z4noT9aPHyWiq86560REzPynRPSTRKQeMpn5ESJ6cv3Pr290UmZmIkoT0dWN3r+LPfmQGSCtdxuOy+oPowztqrVdVgirXxrsgBXaYch+0KvzTwcWZLV76sNztBUE+4R14SP9+s0YaHhKoC25NqbLRYF9wFzoGZNbOQjr3RVYIa8ajUiXsDodp2RVXYOERLGI/kwCdGaRo7IazQxn9bkxWwzmOGez4oSVPmGudyPqDIAPX24YGOc+k2VpWO5VCBiBEye1xrM5KefoD0ibr85rT1TMjd5xSuoQPJhV5T6GHnNJ2GWoa+Ym/qywD59xcn8bJiJa0WANvAcm6wW+B/0jcEiYls60ZtjfC1lmGNrZVfS9cUBbpUCHfCSu25JB5Fm8KPWOTJv+FsTwXOjLae2JGj8g/cU1IMK620S/AnO4sgiemWXN0hXyoHGrwXhYMW2ZkDEV/OSDreOD7zfaOWCM3bTMBY0JreerL0LmItBapspSh/g+08/TUveHasJG376j2a07kDWoC9wluuJam4ZacGRNe4yLQiYs114F/WjKMPuod7XzZ7tyyRBoUM1nSg25XszoFDRR4yswPjA6387tq27jDFEdxplA5eI+MNg6jD2sz0cdMkc66B9cBMbzhp6nm6/J33wQfjtMpH79ar513MjLhcR7TX8Lt5n305rJb0J3bi7CHHn+hj5fPzCbGZg/u3UfCyxI/YZi0he5d0CVU+N3Rlj/5iWtQR27A7tYQMIennxBlQs9Jjs3WKfgA3p8rXxdotArC+2j7rcLb4LJ7GZmbIQvOue+uNkHmDlBRJ8gos+tvzREqlVpjIjet8FH/4CIPuece4qZP2/e+zAznyGiLiIqEdFvbFaHPfmQ6eHh4eHh4eGxo+HeVO7yOefce97kN/w4EX3PObfwhiXXwcxZIso6555af+mPiOiTUAS3y3+NiH6HiH6l3fn25ENmKOCoLyYrUowuvVnGaMatrbCtfqk3CdowjH4LmyjvuDCPoffpfK8KmLUCIuaoZjrfJVn5Vl7Kt46vX9RamiVgQ7oTM63jwf2WWZLj0izkIe7Sq/nYEWEbA2nQvvVCdHRSd6UAMofdsDK14eQF0SW5RTluXDNZjOYgQnVJ2jk9rNtoFQKQz16QaMmTK3q1nAwLDcsY9Yl1JaJAFq4D8nKH6vp7c8PC4BFkqaG49p6jGryXX25bLtgj/QrZy4aJip17TtozceVy67g4pyNP5yGKvDcn7IqKTj+sGY/AKOh0O8G7bhNz0iC+FzLTS0VYk47kzdZx4ZuGebgGXnsV0Wu9bsEP3zs/LdfXnDKsH7Bitwsyvkom+nUa5on935X7mbisGZTIMOhgjwIbHTc6WOhLjO9Nao1cvSz3dHpK6oeZhQ70aKYQdzk6RmU+On5uRpXrvyDjaLkIEcxGj4quChjxbTWUU+AEgLp3mwUG38PjsNmgqMBw2JeQdi0bF4XpFflgD0SrW8ZzHjKFxYC0WjVTPTqJZEEHfyildyhOFoDNh/6rdw2ICHTrbkrGV31e+vbsRT2+xhaFfTt1RBjA2H7dSLUZqd/lK7Lz0DeWV+USKbn3qYPyenBA7wDgvH/um9JHB7q0zrReB6/YfXLt0dNaa80HZAzwEWAvq/p3hCZE11l9RZ55Lr2s4wFeW5Q6FcC14PJX9Nz80QnQbv6wsMyUMw4hH5A2i8COAv0n2gFw90STycyfJaJfWv/zR5xzd3/gPk2yVU5ENE5E+DAyvP7aW8WXiehLmxXYeSpYDw8PDw8PD489jrtpJf9ro8udc19wzj24/m+CiIiZM0T0ESL6Syj6PBEdYeYDzByhtYfQL5tz5Ykoz8yPrb/0mU2++jEiurZZ3fYmk8lNpT9KQ6aFkWT75+ogRFiiZidksk/EgSVFNoUNu0UFYRiasLrljGaZOAMr3DlZOa/ezqty8y/I6v7shPhVsnH8nAVfynFgQ+bKeiWNfpMYfRlZ1Kv00gVhL47tlwj1+ABkgTDN2pyQ62hel+soXdV1ReamBl6HSzWtRy0Dm4dZQkaKmvGsg4asAZqxK1d1lOfqZbng/oxcU6eJYA7Boh0ZPPReI9IRjKhzqpzROqzpO3K96CN36IRmoHD5N70sjGzFsG9B0Nwl54UWqht/zhowoOVZYVAa0/J67qJmcfaNyAI3fkSYYGSziYgIrp3jwOaHNtE/1aWPFSpaK7xwQfpp+BL4lJrMVkmIgsb7vmCySiEwqj1k9Hw9Mbl+jKxPzupxPQA+mY1n5b6Nz2um5fgp6VfRA8Iirhb1975yTdgfdKHA+ah6VffLWCYvf2SEqQod17rwrgHRXmbHYaegoOe09ITMl5iXu2o0mT1RKVdv411r34sAG+oMo4jnx8w7NvvUiebG87E9H3q44rxo64fzO7azHTdLT8Nuw9OXWoc4bxERzcDcGg4A2wvj9VZZ90vMarR6Wea73G09DlEjG4ffskLJMqNy3/aVZNcqV9BR3pV5qRPOkbdmsvp8cE3RSanD6EXNeA70iZYz3iPXVMtrNvrqTembtVVjxgxAz9ZeuG/W1/bbr0hE+YdrMs+m7jNezF0yPji083g19/YF/vwUEX3dOdca+M65BjN/joi+RmsmBE86585t8NlfIKInea3z2cCfu5pMJqICEf3iZpXYkw+ZHh4eHh4eHh47G/dmu3zDMzv374no32/w+leI6Ctv8NkXiegBeOlX11//NhFlNvpMO+zJh8xwsEl9GdDFgMYoD6tJ63WI+acxS00iopkMzK2sdJPzi6pcA6ICzz0tusmi8c/rA43nvuOyAg0YQmZhKds6rgAzZVd4mbBmAe7Crubxutwm0aAdwF6MTUgdCKLLbcaauqpf+zzrWHdc9VsmIxbc+JpsVgkEMhSbfe9UQTQ8xYrJZgH1QB/FSl1/L7I1xZqcL2nyFSNz0IB2mb9tWGbIQY3tb7PZ4D3ENfqKiUJHfVoM+n0U+sq8ZUYgyrN2Y2OGmEjnpm8CtRQLaUYmm5V+jv3NjsNqXd4bLwkLUTfZmMKL0hbIQkaMjhDHNfbTYEP3WXuvpH6676WGIUf0AkTMT+pxffGcsOdDUzKuGw09sFPwvVh3ZLBunNcRvYmr0p8TCWGqMqNGBwe3agVY6+W8rgPeD+xT0aa+N8i0Iutnxz+OS+y/q6bvYD+1keLtgN9VNxrlJPRFbD9n5kiMNu+AXS+bV35iUsbA4oq0mWU88XzIlmP+7qyZlzGjVhXnS3PuXErGTQh8QSsV3d+wn1dAO7tqMr0F4B5if5tf0X2iE/sBnBuzdRERVcbAr3JcGmLWnG8AfufQL3nW7LB1mbn6LlYMq46j/MYt+X2NjOs+m0kKm4+OIzsFb9dD5k7BnnzI9PDw8PDw8PDY0XCOnM9d7uHh4eHh4eHhcS/h6G3VZO4I7MmHzEDIUSorlPvirFxmoSbb4K6mt1BQKI7bqfma3h7IpMHIuEdoetehxeChD8g21vBlESY/d2NQlUtUTSDFOoI5vR2Sg+9dWchuWFciojBvfB1zZvsitYoCcLQZ0Z0etymCbc6Non0iva2L28J2G1fVD9rBbvnj+fHcxbpuO7vNfhfTJW3jgUb8KHDvber6YbvUYBsrYbZ4i5DCDs2dl2q6frdgS7o7ClvdeW0Lgu2CcoOGSYeH14/3rWDSAWZg66vSkHK4CWtT71VBEoASD7ttFYRrxO3BGbMNhoFnKI2I2u1taL8cmGPPmICe4ZQEsixB36ms6mkNTb7R1DtuJBhFaDMMCjoxooOyAhA8GAIj+ozZ5sN5Y3U2K99j5DLo+hSEe9POMJyI6A5IB2J5ea8xbqQMwY2Dwez2Nloa1VQ5Vex1co27SBmpgbVIuospMw7xc/lq+z6GW9Dt6kqkk23gGLL3GqURY5D+1NYbvzcVlvt7saDn+iTMB2Ho2yo4ysgBXilI/3hfZ/ugvVsw12MdLFC2gnPBnUVdV3yvCfNq2pz7ErQL/jbivEVEVGtuHOBn+w5KjFCykzBz9gsLUt80yAM6I7rcLPSX7iimT9X1Scbat9n24+3TZO4U7MmHTA8PDw8PDw+PnY/VNy6yi8HOekDsAbxnpMc9+7/9VOvvQB+wRLi8apdH8o0AafmaT3xIXk9qK5bAU9+Tci+LWS8njGl7GphSTAkZ0WsANyvBTK7QXsCMdjrKXiZq1hR4fmwXuwTdCmxbtmtne25gbpTBsS0HRug27dqW69TuPTRIN23eti02MSRXqBlGtgSrargOThoj77ditYF1sGbR7doP6Us7F7R7b7N2fSt9ZzMsS1BGs6jTOwZywJTa+3Yv65Q0EXiYjnUJkglMa2sXV4OAI7BR2bSPbbWuW5273qnz2c9j/8Pr3Wye2Ox8Wy3XDsFNxtPqFpmkFQiUrJggMRzL8F0OrLrsnN1cxv4BCS+6NNvbtm9vdc7dbC7Az9i5Cscbni+m69PWtszeszbziVvS7dL2t83OiWgfmJKdDE6b8YopcedlvAb/yb958S1k0LmnYA66QCD5xgWJqNksbnt93wo8k+nh4eHh4eHhsS3w2+U7Asz8CSL6V7RmIPr7zrn/u11Z13DUXJRV2D03YMVV65JYk7ioYaMGxXCWL4nfD5p1ExEFgM1jFMll9AqHE8DqTIne09Xsal5W2RyRVRzHzQo00mbVea/Zjy2ewyGraeqgUhludj+bbRi3TZhHZJxUm2z0uXavNzaeKJxpo2ZBmEyOgPZtxWhJ213jFtkLvCYiMwbwGtu11ybn3jLL9FYZRLwOaJdmoX2O303H+FupB47JfvP5QTA8r0v9XFMnBlidB9Ya6vC6PtYOb2XXZTOGfbN2uMfMqBpTW51btnq9m5Vrd71bvfbN5gnsiyU9Xhn8iDiMTCboH4vGsL4g544E4Pfqdbs4ba7Dzjlvhe1Fls/MQeoawe6LY3qscVKYzLa/KbYe+L2GuVxd3FhXz2F9PpxbA1VghWvtt5/tb+/2w5Fze3u7fOfZ328AZg4S0RdoLUn7SSL6WWY+ub218vDw8PDw8PD4r0Fzi/92J3YLk/koEV11zl0nImLmPyWinySi8xsVLhdD9NK3xAj5WlEYwbmarLQwco2IKA8RwjGIBMyEdbmf+tB1KTciqcZ4qKDKuf5eee/D97WOg5duqXJUgtUVajJzOioQ9S6BRTG2vfHXeq1wZTEr9YPI3aoxLsYIWowat1GGVyGSFRenyTYm10REVYiQxAXsiqkDRgxilLFdfGPkLkp7gibaFdPKzYJp8NSK1sHOVqUepzvk3EUT/Y7RqpjO0l4HRpfG4Tq6YxVVbrEqbgQTYPweC7afRJYbkPoxrFe9ZajHbFXqnjV9dmIF+g603xCYvtvozTuVCLwn31us6zYqNtCZYONrINLjDX3Qiw39oQyUw6s4lNJtif25BBG9bPrirbJcRw3dAgyBgCTM6Q75ro/+dzrJAh8ckj8GZZ4JLOr0fchaL70ox/Nz2lT+NkTxYmQxOiB0xrQeNQTvFaCf3zLR29h/p1ekjW6WNCt0JI1jD4zZTb/E8+F9m6/qezgUl/rh2LAuFNiXGpsQitg3sxAZPmucORZqMP6rcpKoIY+PQEINnPts38Z6VKHv2Ehx/F3JwdjDc9+pmJSwcO4uGF8Dm0RDY9KB7o6Sem+lKudHJ4fOuGbvgjCPTS1LX1w2CSbmwW0B703NOFws1DZ2I4gHdRvhuO6Da+yKaQ3lxQKOB2CIzbhGFxVMRWnnZvwtOZjS6Vl3BPZgXAxiVzCZRDRERHfg77H111pg5l9m5heY+YV8fQd2JA8PDw8PDw+PFtyW/9ut2BXR5cz8KSL6hHPuF9f//jkiep9z7nNtys8S0S0i6iaiuXesorsPvn3aw7fN5vDt0x6+bTaHb5/28G2zOe5l++x3zvW8cbG3D8z8VVq7pq1gzjn3ibezPm8Hdst2+TgR7YO/h9df2xB3Ow4zv7AbQ/7fKfj2aQ/fNpvDt097+LbZHL592sO3zebYa+2zGx8a3yx2y3b580R0hJkPMHOEiD5NRF/e5jp5eHh4eHh4eHi0wa5gMp1zDWb+HBF9jdYsjJ50zp3b5mp5eHh4eHh4eHi0wa54yCQics59hYi+8iY/9sW3oy57CL592sO3zebw7dMevm02h2+f9vBtszl8++wy7IrAHw8PDw8PDw8Pj92F3aLJ9PDw8PDw8PDw2EXwD5keHh4eHh4eHh73HHv2IZOZP8HMl5j5KjP/+nbXZ7vwRu3AzD/PzLPMfGb93y9uRz13Cpj5SWaeYeaz212X7cYbtQUzP87MBeg7v/lO13EngZn3MfO3mPk8M59j5n+63XXaLmylLXz/ETBzjJmfY+ZX1tvr/9juOm0XttIW/ndr92BPajLXc51fJqKP01p2oOeJ6Gedcxumodyr2Eo7MPPPE9F72hnbv9vAzD9ARMtE9B+cc6e3uz7biTdqC2Z+nIj+mXPux97hqu1IMPMAEQ04515i5jQRvUhE/+jdNu8Qba0tfP8RMDMTUdI5t8zMYSL6LhH9U+fc97e5au84ttIW/ndr92CvMpmtXOfOuRoR3c11/m6Db4c3CefcU0S0sN312AnwbfHm4JybdM69tH5cJKILZNLfvlvg2+LNwa1hef3P8Pq/vccAbQG+LfYW9upD5hvmOn+XYKvt8DPM/Coz/xkz79vgfQ+PdvjA+rbW3zLzqe2uzE4BM48S0UNE9Ow2V2Xb8QZt4fvPOpg5yMxniGiGiL7hnHvX9p0ttoX/3doF2KsPmR5bx18R0ahz7n4i+gYR/eE218dj9+AlWsv/+wAR/S4R/Zftrc7OADOniOhLRPS/OOeWtrs+24k3aAvffwDOuVXn3IO0ljb5UWZ+18p1ttAW/ndrl2CvPmS+qVznexhv2A7OuXnnXHX9z98nokfeobp57HI455bubmutJ0sIM3P3NldrW7GuIfsSEf2xc+7Pt7s+24k3agvffzaGcy5PRN8ioj2f1/qN0K4t/O/W7sFefcj0uc7X8IbtsC7Qv4ufoDXtlIfHG4KZ+9dF+sTMj9LafDK/vbXaPqy3xb8jogvOuf93u+uzndhKW/j+I2DmHmbOrh/HaS1Y8+K2VmqbsJW28L9buwe7Jq3km4HPdb6Gdu3AzP8nEb3gnPsyEf3PzPwTRNSgtSCPn9+2Cu8AMPOfENHjRNTNzGNE9FvOuX+3vbXaHmzUFrQmwifn3L8hok8R0T9m5gYRVYjo024v2lVsHR8iop8jotfW9WRERL+xztK927BhWxDRCJHvPxtggIj+cN0RJEBE/9k599fbXKftwoZt4X+3dif2pIWRh4eHh4eHh4fH9mKvbpd7eHh4eHh4eHhsI/xDpoeHh4eHh4eHxz2Hf8j08PDw8PDw8PC45/APmR4eHh4eHh4eHvcc/iHTw8PDw8PDw8PjnsM/ZHp4eOw6MHMXM59Z/zfFzOPrx8vM/HvbXT8PDw8PD29h5OHhscvBzP+ciJadc//PdtfFw8PDw0PgmUwPD489A2Z+nJn/ev34nzPzHzLz08x8i5l/mpl/h5lfY+avrqc9JGZ+hJm/w8wvMvPXTDYRDw8PD4+3CP+Q6eHhsZdxiIieoLXUc/+RiL7lnLuP1jLM/Oj6g+bvEtGnnHOPENGTRPR/bVdlPTw8PPYS9mRaSQ8PD491/K1zrs7Mr9FaatWvrr/+GhGNEtExIjpNRN9YT6MdJKLJbainh4eHx56Df8j08PDYy6gSETnnmsxch9zYTVqb/5iIzjnnPrBdFfTw8PDYq/Db5R4eHu9mXCKiHmb+ABERM4eZ+dQ218nDw8NjT8A/ZHp4eLxr4ZyrEdGniOhfMvMrRHSGiD64rZXy8PDw2CPwFkYeHh4eHh4eHh73HJ7J9PDw8PDw8PDwuOfwD5keHh4eHh4eHh73HP4h08PDw8PDw8PD457DP2R6eHh4eHh4eHjcc/iHTA8PDw8PDw8Pj3sO/5Dp4eHh4eHh4eFxz+EfMj08PDw8PDw8PO45/n/amoCClXod7gAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import librosa.display\n", + "\n", + "# Calcul du spectrogramme de Mel\n", + "S = librosa.feature.melspectrogram(x_train[0])\n", + "\n", + "plt.figure(figsize=(10, 4))\n", + "# Passage en échelle logarithmique des énergies, pour mieux discerner le signal. \n", + "S_dB = librosa.power_to_db(S, ref=np.max)\n", + "\n", + "# Affichage du résultat\n", + "librosa.display.specshow(S_dB, x_axis='time', y_axis='mel', fmax=8000)\n", + "plt.colorbar(format='%+2.0f dB')\n", + "plt.title('log-spectrogramme de Mel pour le premier échantillon (' + languages[np.argmax(y_train[0])] + ')' )\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1868. 1682. 1808. ... -683. -1842. -2194.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2292. 2214. 2194. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-26. 14. 20. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 34. 36. 50. ... -50. -99. -37.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 39. 30. 19. ... -3245. -4218. -4835.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-37. 388. 655. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 233. 242. 108. ... -206. -40. 100.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 233. 249. 423. ... -2344. -3690. -5155.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[251. 573. 690. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 23. 27. 47. ... 222. -133. -409.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[5166. 4490. 7298. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[163. 441. 515. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[146. 10. -22. ... 74. 11. -52.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-35. 93. -53. ... 472. 437. 363.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -38. -100. -298. ... 74. -140. -6.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1331. 1241. 1143. ... 466. 1091. 1302.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 17. -221. -344. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-474. -388. -483. ... 550. 222. -144.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 664. 841. 1210. ... 1105. 374. -594.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-14. 12. 5. ... 63. 83. 192.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-177. -147. 5. ... 957. 740. 457.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 101. 105. 83. ... -1641. -1711. -1699.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 9. 15. 10. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-204. -336. -451. ... -127. -250. -450.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-55. -54. -63. ... 125. 180. 228.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -12. -15. -22. ... 64. 62. -289.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -142. -174. -178. ... -2413. -1727. 638.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -75. -57. -136. ... 144. 134. 199.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 9. 13. 19. ... -423. -357. -317.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2. 0. -2. ... 144. 78. 13.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-445. -701. -898. ... 139. 315. 242.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-309. -123. 189. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 115. -35. -257. ... 1571. 1542. 1775.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -49. -248. -750. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[69. 52. 99. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -21. -390. -520. ... 750. 759. 779.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -65. -90. -218. ... -1695. -2015. -2385.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -270. -363. -492. ... -2675. -3040. -3006.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -79. 256. 334. ... -24. -333. 1052.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -47. 132. 654. ... -324. -42. 257.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-121. -298. -386. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -11. -116. -165. ... -29. -99. -103.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2153. -2076. -2189. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 131. -1497. -2234. ... -1682. -1319. -923.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 6. 170. 11. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -3. -4. -3. ... -340. -1289. -1869.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 30. -237. -349. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -11. -34. -66. ... 5556. 5059. 4398.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 80. 90. 62. ... -112. 609. 869.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 589. 250. 423. ... 1561. -1915. -1149.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-802. 238. -628. ... 1391. -415. -263.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[3167. 5233. 5952. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 55. 6. -96. ... 742. 379. 202.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -184. -258. -123. ... -4410. -4473. -4336.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 7. -7. -13. ... -303. -468. -659.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-724. -735. -665. ... 158. 148. 169.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 164. -66. 55. ... -244. -516. -449.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 5. 3. 3. ... -82. -88. -108.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 799. 850. 879. ... -2698. -1479. -292.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-53. -41. -47. ... 822. 782. 759.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 914. 1797. 2290. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-137. -139. -137. ... -103. -56. -6.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 163. -166. -476. ... -6369. -6003. -3381.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -74. 36. -191. ... -6991. -5762. -3464.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 345. 367. 307. ... -908. -1511. -1828.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[414. 381. 315. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[142. 428. 263. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[29. 9. 19. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-48. -36. -46. ... 969. 981. 947.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 6633. 5134. 4190. ... -3964. -4997. -5391.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-110. -82. 10. ... -15. -32. -45.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 211. 258. 246. ... -2205. -2571. -2833.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-421. -561. -358. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. -4. -3. ... -13. -23. -25.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-128. -167. -152. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-23. -13. -21. ... -23. -23. -20.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 78. 90. 85. ... -1084. -1675. -2414.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -95. -137. -76. ... -321. 198. 988.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[4.2900e+02 4.7700e+02 1.1000e+01 ... 1.2891e+04 1.4489e+04 1.4006e+04] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 7. 13. 20. ... 16. 15. 13.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-186. -222. -217. ... -30. 34. 46.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1148. 1417. 1741. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 43. 70. 37. ... 2797. 3141. 3130.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 19. 32. 43. ... 185. 27. -111.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 572. 413. 226. ... 694. 1484. 2105.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -2. 0. 0. ... -16. -9. -5.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-146. -115. -77. ... 3082. 2916. 2633.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2690. -2313. -558. ... 9815. 13151. 11276.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -22. -30. -31. ... -224. -253. 191.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -96. -87. 514. ... 3233. 2978. 2835.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 40. 29. 11. ... -2156. -1938. -1682.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -33. -21. -23. ... -1314. -1233. -881.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -11. -327. -351. ... -3915. -5020. -4456.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 87. 100. 149. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-648. -712. -334. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 105. 7. -110. ... -20. -27. -28.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-197. -188. -176. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[545. 6. 614. ... 109. 43. 182.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[43. 31. 8. ... -9. -9. -4.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 800. 957. 938. ... 9331. 9313. 9137.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1.9316e+04 -1.9283e+04 -1.6783e+04 ... -1.2000e+01 1.9200e+02\n", + " 2.1200e+02] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 496. -9. -204. ... -167. -185. -197.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1. -3. 0. ... 152. 316. 523.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 546. 1433. 1705. ... -3300. -5434. -7149.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[221. 370. 57. ... 174. 87. 229.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 4. 1. -4. ... -114. -271. -408.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-317. -338. -347. ... 139. 178. 202.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -859. -1025. -850. ... 6607. 7748. 11262.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 41. -58. 7. ... 407. 308. 590.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -62. -95. -121. ... -1847. -2105. -2441.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 38. -44. -111. ... -955. -1182. -1233.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2962. -4090. -4668. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 6. 31. 3. ... 185. 168. 121.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -845. -1942. -2401. ... 4340. 5346. 6928.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -113. -68. 157. ... 545. -2329. -1058.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -683. -520. -491. ... -635. -859. -1514.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1001. 579. -90. ... -12586. -10704. -8844.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 67. 65. 63. ... 1759. 1808. 1827.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 119. 259. 215. ... -4492. -4767. -4672.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[266. 268. 270. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-309. -334. -331. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -19. -35. -29. ... -3309. -3931. -4191.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1539. -1436. -1333. ... -1323. -1180. -952.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-264. -234. -154. ... 1988. 1593. 1056.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1018. -1112. -1141. ... 1054. 1067. 1187.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 61. -38. -136. ... 91. 266. 567.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -273. -324. -333. ... -1059. -925. -1021.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -213. -215. -225. ... 19014. 19936. 19675.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-752. -783. -679. ... 4988. 5765. 6854.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -97. -1. 84. ... -977. -906. -819.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 255. 310. 264. ... -160. -121. -110.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 49. 90. 102. ... 188. 238. 139.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-4127. -4757. -2472. ... -9270. -8527. -7741.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -61. -67. -55. ... 91. -148. 5.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2848. -2730. -2936. ... 4246. 1768. -1758.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -93. -81. -220. ... -140. -55. -21.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1071. -1031. -70. ... 1188. 1173. 1310.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1401. 1208. 1234. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1256. 1221. 1075. ... -190. -229. -264.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-30. -35. -30. ... -45. 563. 528.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -645. -604. -142. ... -12735. -12150. -10739.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1284. 1436. 1613. ... -332. -469. -566.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 243. 238. 215. ... -3824. -5164. -6007.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-22. 152. 377. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 226. 272. 271. ... -148. -125. -19.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 16. 11. -3. ... 321. 320. 312.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-167. -226. -152. ... 359. 326. 292.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -37. -28. -15. ... 1199. 1538. 1790.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 13. 20. 38. ... 462. 372. 318.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -28. -49. -55. ... -719. -451. -61.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-131. -189. -97. ... 1849. 1210. 2163.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1636. -962. 269. ... -1947. -2208. -2460.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 341. 166. 57. ... -1613. 6732. -8400.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[414. 452. 471. ... 52. 40. 22.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-322. -401. -434. ... 777. 422. 482.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 162. 137. 240. ... 313. 1814. 815.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-114. -91. -44. ... 39. 23. 12.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1.000e+00 0.000e+00 0.000e+00 ... 3.996e+03 4.096e+03 4.355e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[610. 637. 657. ... 387. 402. 388.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 721. 1014. 1376. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-125. 64. 145. ... 4022. 4637. 7377.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-32. -89. -90. ... 87. -33. -96.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[150. 165. 173. ... 242. 239. 354.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2. -1. -8. ... 26. -81. -145.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 51. -31. -77. ... -679. -593. -594.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1547. -2501. -4102. ... -1418. 250. 538.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 433. 405. 403. ... -1288. -969. -926.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 313. 139. -500. ... -599. -461. -261.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1596. 1670. 1255. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -2. 4. -40. ... 496. 669. 400.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-126. -130. -102. ... 1264. 1072. 833.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1.000e+01 2.000e+00 -1.300e+01 ... -1.815e+03 4.269e+03 -2.165e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -52. -54. -19. ... -326. -118. -43.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -59. -75. -66. ... -166. -224. -269.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 232. 263. 296. ... -774. 693. 2872.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -72. 241. 101. ... 5214. 2041. -458.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1.100e+01 -1.500e+01 -1.000e+00 ... -1.456e+03 -1.277e+03 -1.067e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -29. -15. -20. ... 302. -238. -757.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-146. -78. -37. ... -475. 386. 816.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1027. -934. -838. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -143. -109. -77. ... -1743. -686. -402.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -78. -165. -1688. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1211. -344. 303. ... 12430. 12232. 10396.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-6414. -964. 730. ... 1433. 2573. 2578.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 100. 49. 205. ... 1594. 1390. 770.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-261. -56. 75. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. 0. 0. ... 385. -315. -562.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-920. -362. 5. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-36. -30. -5. ... 203. 248. 76.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -28. 85. 31. ... 2078. 3257. 4710.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-839. -804. -768. ... -70. -75. -40.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-23. -29. 8. ... 73. 526. 17.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 161. 94. -13. ... -139. -110. -115.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1013. 1081. 1097. ... -556. -908. -1143.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 658. 858. 1626. ... -1286. -944. -993.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 874. 858. 577. ... -1383. -1924. -2708.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 75. 42. 47. ... 480. 464. 363.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-142. -91. -94. ... 236. 183. 100.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[3427. 2595. 1218. ... -761. -142. 759.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 107. 200. 152. ... -330. -358. -286.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1639. -613. 428. ... 198. 180. 170.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-289. -308. -306. ... -461. -472. -943.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1358. 1324. 1177. ... 160. -1939. -2244.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1009. 1007. 1008. ... 3980. 4373. 4675.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2757. 2226. 2033. ... -4851. -4967. -5038.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-86. -43. -99. ... 375. 257. 306.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 19. 15. 15. ... -39. -402. 51.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-3141. -2428. -3595. ... 20069. 16373. 15233.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1073. 1164. 1204. ... 5499. 5447. 7431.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1536. -3468. -1926. ... 398. 490. 487.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -217. -138. -136. ... -1394. -618. -2388.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 3. 0. 0. ... 0. -1. -4.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 139. -103. 160. ... 155. 170. 123.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -18. -6. -4. ... -1700. -2226. -1956.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -31. -34. -127. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-347. -417. -650. ... 1182. 1198. 1240.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2847. -2855. -2827. ... -298. -248. -234.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2255. -3404. -4702. ... 7574. 7225. 6733.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 4. 120. -36. ... -191. -219. -211.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -219. -221. -204. ... -1642. -2086. -2400.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1971. 2466. 1933. ... 34. -479. -859.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-206. -166. -173. ... 82. 131. 156.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-5.000e+00 -1.000e+00 8.000e+00 ... -9.680e+02 2.314e+03 4.943e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[166. 135. 106. ... 123. 88. 62.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 20. -23. -82. ... 70. -172. -251.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-220. -207. -85. ... 338. 727. 918.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-572. -565. -554. ... 4. -6. 43.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1863. -1788. -1851. ... -1441. -1419. -796.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 732. 80. -229. ... -307. -142. -1310.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 41. 51. 60. ... 663. 915. 1074.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-206. 168. -192. ... 1722. 892. 254.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-391. -430. -390. ... 1585. 2165. 4413.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 79. 91. 238. ... -2714. -1777. -913.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-3025. -3556. -2742. ... -167. -618. -785.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -77. -108. -89. ... -857. -749. -558.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2163. -1966. -1654. ... 4782. 333. -3909.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1582. 436. -1233. ... 2138. 2344. 3471.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1594. 874. 1181. ... -1789. -2227. -1873.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[208. 149. 63. ... 917. 874. 850.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-217. -484. -207. ... 63. -39. 122.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 227. 265. 302. ... -640. -200. 665.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -50. 161. 249. ... 5935. 6184. 6701.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-339. -192. -157. ... -6. -328. -134.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -1. -2. 0. ... 621. 650. 714.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 138. -46. 114. ... -4496. -4088. -3775.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2.400e+01 2.400e+01 -8.000e+00 ... -9.494e+03 -9.654e+03 -1.028e+04] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[128. 159. 52. ... 288. 243. 195.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 647. 50. -775. ... 540. 1370. 557.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1252. -1401. -1515. ... 58. 348. 635.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 832. 942. 727. ... 5141. 5159. 5266.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 3836. 3831. 3304. ... -2559. -2651. -2373.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-468. -457. -453. ... 268. 276. 472.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -32. 347. 611. ... -319. -345. -262.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 329. 300. 264. ... -8077. -8895. -9651.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 22. 11. 10. ... -1036. -641. -604.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[140. 140. 135. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 69. 105. 135. ... 28. 28. 29.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-162. -53. 27. ... 2549. 2274. 2151.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 34. 240. 101. ... -425. -532. -652.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. 0. 0. ... 1576. 1218. 1039.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-100. 184. 549. ... -163. -281. -30.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -136. 63. -131. ... 15925. 15647. 15452.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -8. -107. -116. ... -1483. -1716. -1896.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 171. -380. -1863. ... -2344. -2032. -2055.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -74. -83. -59. ... 1093. 825. 576.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -21. -212. 160. ... 212. 521. 698.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2081. -409. -706. ... -6525. -6739. -8221.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1651. -1700. -1750. ... 8399. 2356. -941.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-3004. -4072. -1726. ... 594. 572. 571.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -66. -22. -26. ... -1124. -1082. -1196.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-136. 11. 242. ... 572. 58. -302.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[468. 141. -69. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -70. -48. 10. ... -109. -125. -118.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1958. -3361. -3756. ... -2580. -4584. -5875.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -459. -451. -447. ... -8488. -7917. -7432.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0.000e+00 -1.000e+00 0.000e+00 ... 4.444e+03 4.310e+03 4.572e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-64. -45. -59. ... 63. 20. 39.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -5. -35. -29. ... -1820. -2357. -3260.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 406. 338. 238. ... 4427. 4534. 3997.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1117. -766. -260. ... 1060. 1026. 995.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -82. -101. -129. ... 608. 648. 656.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-3053. -2841. -2629. ... -3063. -980. 703.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 58. -230. -321. ... -68. -158. -212.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -947. -1665. -1114. ... -876. -65. -765.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -156. 44. 24. ... -2987. -3364. -5744.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 4302. -22. -3888. ... -4079. -4952. -7226.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-116. -66. 9. ... 351. -310. -690.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -8. 8. 1. ... -502. -436. -416.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-337. -234. -115. ... -915. -783. -535.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -37. 1528. 3251. ... 2347. 2332. 2465.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 467. -1223. -1717. ... -1448. -1628. -1223.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 117. 133. 94. ... 83. -150. 415.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 5203. 7222. 4580. ... -3314. -2318. -1229.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-278. 180. -572. ... 273. 274. 280.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-581. -467. -429. ... 262. 95. 124.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 145. 151. 148. ... 977. 1057. 1106.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[612. 425. 151. ... 48. -15. -69.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -740. -574. -480. ... -1664. -1421. -1173.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -281. -1229. 376. ... -1888. -1428. -904.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 511. -280. -422. ... -1098. -1120. -956.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[112. 245. 224. ... 239. 382. 462.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -366. -267. -197. ... -6601. -7080. -7386.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1819. 2574. 3269. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 232. 272. 188. ... -8506. -9403. -8482.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-343. 223. -97. ... 8055. 7806. 7245.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 154. 181. 213. ... -52. -366. -438.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -96. -144. -151. ... 1797. 1804. 1746.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. -1. 0. ... -340. 426. -458.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -142. -164. -127. ... -1968. -69. 1733.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[3435. 3990. 4240. ... 4009. 3200. 2054.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 28. -419. -661. ... 3898. 4765. 5336.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-15. -17. -27. ... -26. -91. 135.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 109. -228. -569. ... -1555. -428. -14.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-109. -139. -115. ... 46. 7. -9.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 694. 1942. 1845. ... -943. -344. 358.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 923. 1270. 1234. ... -3049. -3551. -3264.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 30. 21. 39. ... -302. -102. 158.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 434. 767. 1032. ... 20. -60. -36.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -337. -173. 59. ... -633. -1851. -724.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 32. -19. -32. ... 1467. 1020. 2506.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0.000e+00 -1.000e+00 -1.000e+00 ... 1.758e+03 1.293e+03 8.010e+02] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 9. 0. -13. ... -2804. -2541. -2900.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-389. -415. -434. ... 3014. 3575. 3175.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -17. -1. 3. ... -712. -812. -799.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1459. 1432. 1369. ... 7737. 6502. 7242.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 423. 265. -89. ... -708. -672. -457.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-311. -161. -302. ... -279. -107. -116.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 634. 47. 64. ... -3347. -5231. -5114.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 20. 3. -1. ... -27. 170. -35.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 129. 140. 93. ... 209. -401. 139.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 879. 993. 982. ... -2685. -1217. -574.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 551. 418. 315. ... -823. -613. -384.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 3877. 1487. -1018. ... -1367. -738. -490.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 65. 140. 207. ... -3043. -2883. -2415.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-4692. -4500. -4616. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 19. 14. 11. ... 599. 734. 856.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-301. -298. -274. ... 26. 63. 81.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 433. 257. 92. ... 1411. 1368. 1317.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -308. 2854. 3611. ... -1924. -2563. -2949.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1. -1. -1. ... 317. 216. -628.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -116. -91. -39. ... -5179. -4762. -4437.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-143. -50. -281. ... -180. -86. 246.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. 0. 0. ... -546. -564. -689.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-925. -681. -480. ... -147. -151. -79.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -1. -86. -189. ... -217. -198. -303.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 15. 975. -164. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-32. 31. 63. ... 481. 480. 651.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-4335. -3208. -1911. ... -8434. -7995. -6910.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-239. -240. -221. ... 2773. 3227. 3359.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 77. 68. 49. ... 1437. 1562. 1898.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1263. 1303. 1572. ... 359. 383. 460.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-252. -46. 138. ... -275. 1137. 1679.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-449. -797. -865. ... 273. 486. 739.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. -1. 0. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-641. -675. -723. ... -815. 128. 419.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[24983. 25141. 24061. ... -1052. -3416. -4292.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-4.000e+00 -1.100e+01 -8.000e+00 ... 5.379e+03 5.342e+03 4.814e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-207. -129. 96. ... -125. -88. -176.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 380. 196. -14. ... 113. -17. -149.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2106. 1616. 1431. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 998. 1092. 1181. ... -2189. -2069. -2255.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -19. -22. -17. ... -2495. -2454. -2302.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-59. 2. -21. ... 555. 514. 375.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. 0. 0. ... -658. -714. -822.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-173. -56. -17. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-64. -68. -66. ... 57. 13. -30.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[162. 164. 291. ... -58. 16. -82.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1273. 1167. 1101. ... -19097. -19016. -19329.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1.800e+01 2.000e+00 1.200e+01 ... -2.146e+03 -1.879e+03 -1.566e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. 0. 0. ... -1556. -1566. -1490.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 337. 366. 395. ... -62. -129. -214.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 12. 93. 133. ... -987. -847. -918.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -174. -106. -54. ... 495. -1383. 1611.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-277. 114. -96. ... -557. -609. -713.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -69. -66. -50. ... -908. -893. -821.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-551. -464. -406. ... 925. 1302. 1369.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -757. -711. -518. ... -2304. -2389. -2546.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -392. -237. -286. ... -546. -1308. -3014.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 72. 213. 382. ... 14131. 14166. 13432.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-261. -281. -274. ... -510. -521. -523.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 7. -26. -7. ... -335. -433. -362.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 57. 85. 116. ... 427. 690. 882.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-507. -706. -731. ... 136. 55. -241.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 76. -343. -587. ... -2319. -1612. -1580.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2316. -1901. -1043. ... 883. 1184. 1426.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1366. -1178. -984. ... 355. 393. 371.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -2. 58. 65. ... -654. -344. -262.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -455. -251. -372. ... -2638. -1027. 19.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-109. -176. -154. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[344. 367. 313. ... -57. -22. 12.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 426. 388. 345. ... -371. -418. -168.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2923. 2787. 2005. ... 3814. 3202. 2902.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 456. 142. -188. ... -640. -146. 312.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. 0. 0. ... -2225. -1749. -1079.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 5. 7. 30. ... -984. -1035. -1039.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1191. -1236. -1467. ... 1632. 2666. 4987.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-21. 0. -4. ... -68. -15. -9.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-671. 23. 337. ... 926. 16. -283.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 587. 1102. 1560. ... 127. -157. -44.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 890. 1646. 2440. ... -46. 232. 1194.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 99. 105. 97. ... -20. -20. -15.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-26. -32. -28. ... 425. 349. 251.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-108. -133. -101. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 6359. 4616. 1016. ... -4605. -5724. -5314.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -26. 56. 37. ... -1972. -1494. -1186.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-581. -236. 76. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-361. -335. -243. ... 40. 173. -110.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 47. -10. 16. ... 392. 338. 265.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1683. -890. 161. ... 3569. 3376. 3137.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1086. 1421. 1441. ... 525. -348. -352.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2. 2. 2. ... 391. -341. -357.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-17466. -18677. -19594. ... 8533. 8582. 9680.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -837. -66. 349. ... -578. -3142. -2056.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2. -3. -4. ... 11. 12. 13.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[3763. 2891. 2025. ... 3731. 3242. 2630.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 127. -18. -93. ... -171. 259. -168.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 14. 19. 35. ... -21. -308. -549.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 18. 10. -33. ... -280. -259. -272.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-147. -592. -172. ... -812. -850. -862.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1548. 2588. 2745. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 202. 212. 269. ... -489. -539. -577.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-5. -1. -7. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -54. -6. -39. ... -1118. -733. -790.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-45. -39. -38. ... 978. 673. 564.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-32. 50. 48. ... -36. -58. -49.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 127. -1133. -1547. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[819. 709. 614. ... 88. 101. 126.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 363. 510. 376. ... -47. -478. -377.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-259. -275. -276. ... 547. 502. 472.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 506. 582. 741. ... 2550. 2864. 1374.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -69. -663. -697. ... 1872. 1655. 1369.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -62. -35. -7. ... 1303. 1979. 2923.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-17. 23. -10. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2355. 2415. 1878. ... 1629. 1718. 2090.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-481. -235. -111. ... 69. 33. -62.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-328. 97. 413. ... 267. -627. -343.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 66. 55. 56. ... 501. 396. 274.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1019. -727. -1459. ... -2151. -1454. 528.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -344. -974. -48. ... -539. -1904. 1008.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -7. -62. 80. ... -9. -511. 193.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-10180. -10987. -13687. ... 2832. -3341. -4187.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1.000e+00 -2.000e+00 0.000e+00 ... -1.860e+03 -1.119e+03 -9.400e+01] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 55. 49. 31. ... -3. -9. -17.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-625. -500. -434. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1349. -1624. 889. ... 1897. 477. -223.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -144. -159. -46. ... -576. -874. -1054.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-938. -316. -400. ... 1398. 1243. 1101.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-71. 36. 137. ... 155. 276. 342.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1051. 545. 1205. ... 1109. 1018. 824.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2119. -2517. -2285. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-63. -54. -18. ... 0. -17. -9.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 28. 6. -22. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -86. -56. -42. ... 1513. 1843. 2209.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -5. 3. -3. ... -30. -10. -32.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1.000e+00 3.100e+01 8.200e+01 ... -4.072e+03 -3.682e+03 -2.482e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-211. -310. -465. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 403. -1137. -1046. ... -4746. -4088. -2655.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 66. 53. 42. ... -67. 212. 120.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -25. 15. 58. ... 73. 1168. 2490.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[176. 160. 107. ... 97. 130. 100.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-294. -299. -246. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1.000e+00 -1.000e+00 -2.000e+00 ... -1.663e+03 -1.552e+03 -1.276e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-229. -193. -207. ... 133. 600. 1528.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2376. -2570. -2539. ... -2352. -1920. -1689.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 152. 130. 181. ... -2226. -2331. -2389.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 492. 609. 712. ... -1179. -1903. -1825.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 18. 52. 31. ... -35. -46. -46.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -39. -63. -91. ... -611. -567. -532.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 5. -13. -7. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -768. -1007. -1019. ... 1477. 1132. 598.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1240. -1283. -1272. ... -63. -89. -133.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 37. -136. -477. ... 635. 1039. -18.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -56. -58. -138. ... -2979. -2601. -2502.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -1. -38. -27. ... 81. 143. 137.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 208. 63. -202. ... -645. -789. -971.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 105. -544. 517. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1728. 1790. 1790. ... 2796. 2179. 885.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-282. -249. -198. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-7.000e+00 -1.000e+00 4.000e+00 ... -1.311e+03 -1.301e+03 -1.241e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 11. -6. -8. ... 2708. 5531. 5357.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2601. -3631. -5005. ... 2636. 2503. 2627.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 303. 294. 477. ... 4106. 3404. 2359.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[672. 632. 568. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1451. -1464. -1451. ... -694. -949. -422.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 46. -15. -49. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[12. 16. 8. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 528. 234. 282. ... 17737. 15142. 21255.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 17. 13. 19. ... 223. 268. 275.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1602. 1367. 1027. ... -1649. -3851. -4871.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -84. -179. -135. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 33. 26. 50. ... -1062. -1289. -1532.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-519. -184. -450. ... 8. -185. -20.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 315. 245. 295. ... -804. -937. -1073.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-5. -7. -5. ... 3. 3. 5.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-108. -122. -74. ... 343. 334. 303.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 377. 515. 588. ... -39. -119. -101.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1438. -1580. -1679. ... 2107. 2175. 2164.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[130. -64. -9. ... 418. 667. 919.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 27. -8. -65. ... -422. 460. -444.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -17. -34. -54. ... -5368. -5167. -4428.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-279. -269. -254. ... 4490. 5406. 6299.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -1. 0. 0. ... -807. -357. -300.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2. -3. 0. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -28. -169. -233. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -1. -1. 0. ... -72. 117. 311.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[7298. 7521. 5519. ... 4288. 3951. 3527.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 3. -52. -7. ... -1224. -468. 716.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -38. -7. -25. ... 1363. -993. -903.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -128. -102. -95. ... -856. -1290. -1787.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 529. 684. 404. ... -3883. -4797. -4763.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 65. 15. 5. ... -1247. -1228. -1191.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 9. 29. 33. ... -3. 6. 13.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 319. 247. 164. ... 5949. 6259. 6764.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1661. -2098. -2166. ... 154. 320. 628.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-464. -470. -479. ... -438. -507. -311.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-206. -217. -216. ... 456. 426. 394.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-331. -400. -392. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[88. 84. 52. ... 7. 25. 14.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -7. -23. -21. ... -5075. -3343. -3875.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. -2. 6. ... -1354. -1632. -1320.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-134. -21. -164. ... -63. -347. -742.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-135. -65. -141. ... -811. -568. -826.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 27. 15. 16. ... -78. -81. -74.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -9. -14. -12. ... -44. -73. 11.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-232. -223. -224. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-41. -35. -34. ... -65. -67. -13.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 144. -31. -104. ... -423. -290. -110.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 88. 83. 95. ... 2040. 1697. 1083.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -93. -105. -56. ... 377. 781. 608.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[697. 553. 390. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1962. -3070. -2844. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-429. -255. -126. ... -426. -420. -347.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 786. 662. 1149. ... 7055. 7928. 7220.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 44. 96. 104. ... 753. 595. 402.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -25. -29. -23. ... -306. -240. -13.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[20. 66. 15. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-3636. -3192. -1745. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 59. 54. 62. ... -488. -353. -293.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 182. -1249. 604. ... 152. 258. 380.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[393. 368. 430. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[67. 76. 78. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -26. 110. 177. ... -140. -215. -11.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 365. -245. 206. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. 39. 50. ... 2360. 2212. 2012.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -4. -3. -2. ... -16. -16. -16.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -5. -6. -7. ... -767. 55. 593.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -42. -39. -11. ... 254. -418. 621.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 15. -2. 4. ... 877. 1146. 1195.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 685. 2076. 2138. ... 1279. 1066. 811.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -6. 2. 3. ... 108. -346. -344.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1239. -1232. -1236. ... 2988. 1235. -1497.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1. -2. -3. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -7. -4. 0. ... 883. 1223. 1523.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 20. -14. -95. ... 525. 582. 639.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 291. 224. 109. ... 880. 484. -329.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 196. 231. 254. ... 120. 7. -169.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[148. 518. 798. ... 300. 320. 43.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 570. 36. -40. ... -1459. -1486. -1629.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 56. 7. -31. ... 2328. 3028. 2632.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[0.000e+00 1.000e+00 0.000e+00 ... 3.850e+03 4.319e+03 5.122e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-16740. -14570. -14838. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 50. 35. -27. ... -134. -9. -73.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -534. -655. -1171. ... 2033. 1272. -102.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-146. -209. -286. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 30. -20. -63. ... -14. 232. -233.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-3040. -4836. -6325. ... 439. 371. 291.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 10. 5. 5. ... -1474. -1637. -1730.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 70. 239. 211. ... -1510. -1837. -2248.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2362. 2390. 2440. ... 1878. 1903. 1931.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-669. -401. -499. ... 206. -139. -409.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 15. 16. 20. ... 1152. 2118. 279.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 14. 17. 39. ... -24. 0. -30.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 12. -54. -102. ... -970. -910. -1371.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -454. -878. -1044. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[110. 50. -44. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 53. 78. 75. ... 664. 810. 735.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-116. -112. -61. ... 4842. 5066. 4587.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-696. -815. -786. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-57. 94. 11. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-117. -86. 17. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-330. -339. -348. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-306. -836. -617. ... -177. -166. -153.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[5468. 6280. 7881. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -12. -29. -54. ... -872. -646. -366.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1890. 255. -1263. ... -4486. -401. 5780.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -149. -179. -361. ... -1964. -1944. -1892.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 29. 34. 43. ... 148. 253. 243.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -7. -9. 1. ... -594. -420. -245.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-155. -240. -118. ... -9. -137. -343.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-79. -93. -95. ... 43. -75. -16.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 48. -168. -32. ... -4283. 4677. -2521.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -98. -95. -229. ... 6781. 6606. 5272.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 40. 63. 62. ... -50. -3. 21.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0.000e+00 -5.000e+00 -4.000e+00 ... 3.259e+03 4.423e+03 4.568e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[584. 635. 571. ... 873. 931. 898.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 144. 49. 209. ... 2543. -6773. 1908.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-444. -420. -431. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-90. -29. -3. ... 155. 177. 161.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-75. -84. -95. ... 433. 428. 392.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1582. -1922. -2196. ... 838. 737. 903.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-41. 32. 59. ... 160. 84. 104.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-4878. -3920. -2683. ... -4610. -4776. -4966.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -49. -6. 37. ... -129. -15. 190.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 452. 456. 257. ... 569. -1146. -2520.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -1. -5. 13. ... -40. 12. 38.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 33. 36. 80. ... -749. -1547. -1622.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 407. 291. 121. ... -2727. -4487. -4894.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-183. -222. -279. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 45. 667. 1957. ... -2373. -6151. -7559.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -10. -13. -11. ... -76. -334. -506.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[3942. 4784. 4541. ... 3892. 5219. 5971.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-829. -724. -681. ... -729. -612. -760.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1209. -1499. -1412. ... -3247. -3105. -3171.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 100. 67. 62. ... -8297. -7760. -7218.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -3. -4. 0. ... -155. 447. -32.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[418. 63. 323. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 807. 2893. 4796. ... 293. 277. 274.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -5933. -11980. -13885. ... 4700. 5826. -3495.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[260. 257. 252. ... 297. 301. 316.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[233. 193. 80. ... 688. 508. 599.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -393. 376. 480. ... -414. -1091. -617.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1139. 1448. 1718. ... -7534. -10272. -10624.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[12849. 12731. 12654. ... 1303. 1558. 2600.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 4157. -2406. -4901. ... 110. 939. 2450.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 237. 268. 71. ... -1067. -897. -638.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-387. -439. -582. ... -366. -147. 51.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 25. 6. -14. ... -822. 728. -248.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -82. -85. -88. ... 1117. 1128. 1167.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 172. 142. 132. ... 2235. 1690. 1202.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 200. 108. -62. ... 1603. 972. 1447.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-51. -67. -37. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 3179. 3936. 4613. ... -1831. -1474. -1091.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-718. -698. -709. ... 1716. 1891. 2642.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -348. -313. -232. ... -2302. -2303. -1732.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1. 0. 0. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -6. -13. -19. ... 3239. 2932. 2589.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -162. 778. 1921. ... -8809. -9578. -9395.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -7. -42. -18. ... 440. 973. 1386.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 932. 2330. 4318. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-17. -3. 12. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 875. 640. 848. ... -4199. -3545. -3073.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-11. -15. 3. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 52. 114. 423. ... 505. -1014. 948.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -70. 11. -100. ... 858. 873. 870.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 227. 828. 669. ... -687. 420. 206.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -30. -34. -108. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 71. -34. 7. ... 267. 878. 2287.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -694. 325. 1134. ... -3001. -2369. -1646.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 19. 49. 61. ... 150. 143. -173.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-113. -161. -135. ... -8. 422. 538.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1445. -1601. -1666. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[4. 9. 5. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -9623. -10160. -10885. ... 963. 2596. 1713.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 140. 137. 139. ... -2535. -1648. -1052.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 16. 16. 17. ... -316. -682. 30.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2826. 2983. 3169. ... 1974. 2757. 1271.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1749. 1674. 1640. ... -2710. -3601. -3901.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 8065. 8430. 8909. ... -550. -1434. -2576.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0.000e+00 -1.000e+00 1.000e+00 ... 4.769e+03 3.916e+03 2.609e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 696. 535. 572. ... 167. -145. -203.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1738. 1993. 1626. ... -447. -890. -1490.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -22. 330. 724. ... -117. -115. -110.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-182. -151. 4. ... -90. -31. 16.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 43. 38. 30. ... 1261. 1519. 1366.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-3101. -3122. -3914. ... -434. -189. 58.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-314. -304. -295. ... 3. -30. -29.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 55. 100. 92. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -82. -222. -339. ... 62. -27. -144.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-129. -69. -66. ... 21. 42. 28.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 92. 102. 73. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 9. -413. -780. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -30. 31. 10. ... -2201. -1284. -1471.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-465. -167. -519. ... -566. -286. -413.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2681. -2273. -2307. ... -284. -164. -31.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-182. -292. -306. ... 691. -761. 1250.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 233. 251. 259. ... -5230. -5883. -6520.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 95. 154. 97. ... -1758. -205. 737.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-141. -137. -145. ... 24. 24. 43.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[236. 255. 242. ... 809. 889. 989.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-123. -257. -255. ... -18. -118. 75.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 160. 45. -45. ... 5152. 5969. 6384.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -3. -13. -36. ... 432. -184. 224.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 164. 178. 198. ... 132. -110. 51.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 23. 45. 290. ... 1207. 1438. 1160.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-172. -161. -236. ... 63. 35. -20.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2037. -1949. -1857. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1201. -1171. -1011. ... 91. 196. 433.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1199. -1338. -1306. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 529. 473. 333. ... 1514. 1067. 795.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 14. 25. 89. ... 887. 173. -103.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2617. 1216. 3591. ... 229. 235. 426.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 206. -417. -369. ... 3298. 3682. 3359.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[140. 217. 201. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1. -3. 2. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[224. 234. 329. ... 5. 3. 2.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -252. -154. -376. ... -3772. -3565. -3513.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -200. -174. -174. ... -1382. -967. -889.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-206. -184. -187. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-4314. -4876. -5279. ... -1684. -1805. -1310.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 63. 19. 4. ... -130. -187. -224.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 25. 13. 8. ... -61. -62. -52.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[36. 4. 27. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2.000e+00 -4.000e+00 -5.000e+00 ... 2.258e+03 3.154e+03 4.098e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1396. 1277. 1461. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 526. 920. 1216. ... -661. -851. -1402.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 650. -271. 177. ... -1756. -1450. -1086.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -69. 9. 59. ... -4661. -4265. -3664.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -18. 58. 92. ... -3131. 2878. 3884.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -47. -123. -54. ... -4424. -3193. -1601.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-387. -396. -394. ... 1009. 996. 984.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[736. 426. 336. ... 411. 330. 284.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1573. 1506. 1471. ... -2711. 288. 657.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -73. -43. 20. ... -913. -716. 1179.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[189. 244. 201. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 214. 104. 38. ... -1537. -1072. -459.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-235. -202. -46. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2154. -2172. -2171. ... -4171. -4221. -3716.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 898. 785. 655. ... -5059. -5414. -6135.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-462. -509. -555. ... -950. -820. -668.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -5. 3. 57. ... 411. 344. 281.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -56. -58. -51. ... -938. -991. -919.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[652. 719. 798. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 34. 9. -3. ... 696. 473. 84.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-3.700e+01 5.000e+00 -5.000e+00 ... -5.165e+03 -5.162e+03 -4.858e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -1. 0. 7. ... -60. -37. -20.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 48. -9. 2. ... -421. -224. -453.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 477. 440. 400. ... -807. -886. -728.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -34. -30. -31. ... -6144. -7100. -8208.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -687. -401. -54. ... -1032. -405. -232.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 89. 146. 122. ... 471. 387. 266.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1268. -1242. -748. ... -1147. -1173. -1171.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -22. -20. 33. ... 2482. 2382. 2104.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -67. -18. -27. ... -1280. -1309. -1229.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-271. -162. -124. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-57. 25. 67. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -449. -392. -327. ... -1098. -1418. -1924.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 575. 185. 315. ... -13454. -14304. -16139.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-669. -285. -65. ... 143. -21. -197.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-99. -83. 57. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 86. 189. 304. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -20. -27. -28. ... -321. -416. -485.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -65. -205. -280. ... 8525. 8445. 7457.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1576. 388. 1059. ... -5946. -9073. -10595.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. 1. 1. ... 85. -2. 186.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-113. -91. -66. ... 25. 47. 74.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -32. -22. -26. ... -378. -325. -326.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-21. 57. 153. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 5. 1198. -273. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 88. 135. 183. ... 1659. 1712. 1150.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1538. 1509. 1519. ... 631. 1052. 1004.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 425. -237. -780. ... 2125. 3533. 3436.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[171. 477. 375. ... 822. 760. 719.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 24. 33. 25. ... -233. -170. -65.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -1168. -826. -704. ... -14946. -16249. -15465.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-19. 37. 89. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -7124. -10049. -10627. ... -3619. -998. -1001.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-3.000e+00 -1.700e+01 -4.800e+01 ... 3.107e+03 3.275e+03 2.463e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -76. -58. -59. ... -174. -11. -133.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 48. 43. 60. ... -155. 198. 586.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-30. -44. -47. ... 855. 732. 562.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 97. 211. 140. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -82. -109. -124. ... 986. -25. -1041.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-192. -118. -114. ... 237. 112. 168.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -964. -923. -870. ... -2928. -3763. -3695.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 125. 13. -148. ... -271. -336. -394.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-170. -569. 4. ... 568. 150. -910.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1655. 1540. 1057. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -1. 0. -1. ... -336. -295. -244.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-645. -518. -547. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -8470. -10575. -10228. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[122. 90. 71. ... 154. 325. 527.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 640. -652. -1704. ... 1479. 2503. 703.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-70. -50. -25. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2644. 5383. 7245. ... 3434. 319. -2245.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1.769e+03 3.950e+02 -1.000e+00 ... 2.616e+03 2.463e+03 2.649e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1179. 779. -697. ... -5666. -5684. 897.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 85. 36. -59. ... 525. 570. 606.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 113. 75. 6. ... -1164. -1441. -1769.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-294. -407. -429. ... -882. -593. 1159.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2654. 432. -320. ... -6197. -6272. -5469.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2270. 2642. 2352. ... -891. -1762. -2643.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -2. 5. 33. ... 987. 1331. 1563.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[426. 716. 168. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-7. -5. 4. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 57. 10. 302. ... 417. 527. 654.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -11. -56. -80. ... 532. 205. -294.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[0.000e+00 1.000e+00 0.000e+00 ... 1.327e+03 1.189e+03 1.006e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 965. 162. -145. ... 2697. 2879. 3276.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-359. -319. -111. ... -312. -7. 227.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[481. 375. 348. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-87. 50. 101. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2057. 1922. 1607. ... 1142. 1018. 891.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -68. -10. 0. ... 577. -402. -806.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-3.000e+00 -3.000e+00 -9.000e+00 ... -5.001e+03 -5.933e+03 -6.767e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[12. 4. -1. ... 29. 50. 25.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[3714. 2362. 2276. ... 1969. 2048. 1675.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -44. -52. -56. ... -384. -305. -326.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-51. -58. -35. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1422. -2195. -3025. ... 138. 389. 434.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-455. -438. -505. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[177. 174. 188. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2.000e+00 3.400e+01 4.300e+01 ... -3.427e+03 -3.404e+03 -3.302e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 616. 211. 748. ... -5025. -4865. -4501.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-803. 1481. 1044. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -44. -144. -188. ... -16. -11. -5.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 465. 388. 537. ... 442. -468. 154.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-143. -131. -72. ... 1121. 1180. 1164.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -34. -32. 0. ... -1282. -1567. -1983.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1848. -1775. -1816. ... 2660. 2559. 2344.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1248. 1154. 1247. ... 2571. 3975. 4620.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-724. -541. -636. ... -296. -592. -353.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -137. -268. -116. ... -1037. -1177. -1312.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 521. 633. 729. ... 6084. 5192. 15805.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1375. -1636. -2160. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 854. 1061. 2486. ... -4221. -4507. -4773.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-119. -118. -55. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-35. -57. -37. ... 94. 77. 13.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 15. 68. 199. ... -65. -119. -102.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 220. 277. 358. ... -231. -102. -55.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 90. -71. -46. ... -1264. -1472. -1517.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-491. -479. -504. ... -158. -162. -151.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -33. -42. -56. ... -676. -721. -769.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-220. -463. -541. ... -599. -467. -353.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 805. -868. 615. ... -573. 596. 1946.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-65. -64. -63. ... 11. 3. 1.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -942. -339. -299. ... 1532. -347. -1518.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 626. -421. -675. ... 3235. 3172. 3035.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[6383. 5622. 5137. ... 5774. 5922. 5320.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 26. 37. 34. ... 3227. 2536. 1556.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2670. 2889. 3107. ... 4856. 5853. 6369.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[21. 18. 12. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 46. 143. 32. ... 182. -9. -45.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1136. -1030. -1141. ... 1440. 1697. 1495.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1577. -2737. -2742. ... 68. 73. 195.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -17. 55. 50. ... 400. 1096. 622.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 50. -96. -19. ... 1043. 1705. 1342.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1143. 1518. 1887. ... -3699. -3923. -4075.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 180. 201. 443. ... 683. 2621. 3727.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[18. 30. 90. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -25. 0. -15. ... -939. -862. -605.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 260. 575. 881. ... -12670. -14967. -15211.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 24. 38. 15. ... 256. 265. 294.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 25. 38. 29. ... -119. -44. 7.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 3. 7. -1. ... 4. -6. -6.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 447. 434. 507. ... 1589. 1368. 1328.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 59. -360. -838. ... -25. -220. 49.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 28. -75. -12. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-287. -352. -465. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-121. -101. -20. ... 2776. 2657. 2376.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[3453. 1987. -80. ... 378. 1006. 1775.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -221. -157. -30. ... -1374. -423. 579.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 197. 174. 153. ... 5579. 5183. 4835.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1020. -1418. -1519. ... 1683. 1514. -5959.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-347. -313. -334. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. -1. 0. ... -1. 31. -10.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -83. -3661. -4137. ... 2469. 3161. 3549.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 35. 16. 1. ... 107. 436. 534.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-3235. -3315. -2273. ... -997. -1336. -1160.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 243. 251. 254. ... -1645. 1858. 3697.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2310. 2695. 2826. ... 5394. 5421. 5344.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-17716. -18347. -19136. ... -23178. -23157. -20927.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. 70. 60. ... 40. 51. 49.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -585. -459. -414. ... -6176. -6611. -7048.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -53. 593. 352. ... -323. -1081. -1174.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-54. -40. -47. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 146. 100. 68. ... -3325. -3045. -2550.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-385. -398. -403. ... 217. 206. 172.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-40. -28. -36. ... -80. -65. -49.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1039. -767. -245. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 60. 148. -43. ... 384. 788. 433.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1420. 1512. 1865. ... 28726. 28510. 28467.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 130. -365. -720. ... -3074. -3870. -4312.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-279. -568. -771. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-47. -63. -24. ... 673. 709. 782.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 24. 104. 103. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-5349. -5067. -3926. ... -6783. -1764. 913.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-233. -15. 151. ... -33. -139. -84.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-276. -272. -80. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[795. 744. 729. ... 26. 258. 452.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -21. -17. -30. ... -678. 512. -814.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 98. 67. 46. ... -3054. -4358. -5121.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 5. 62. 249. ... 753. 263. -390.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-356. -138. -296. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0.000e+00 -1.000e+00 0.000e+00 ... -1.011e+03 -2.790e+02 -4.040e+02] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 131. 95. -46. ... 10464. 9482. 8887.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-4.000e+00 -3.700e+01 -4.800e+01 ... 2.847e+03 4.469e+03 4.791e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -257. -323. 42. ... -3960. -3958. -4358.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[24. 24. 32. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 888. 582. 267. ... -616. -725. -805.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -575. -531. -583. ... -1051. -894. -1037.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2680. 871. -388. ... 4170. 4851. 5724.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[89. 91. 93. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -219. -246. -146. ... -1469. -1360. -1123.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. 0. 0. ... 161. -55. 24.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 155. 200. 281. ... -1082. -1243. -1327.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 225. 295. 136. ... 7972. 11578. 10180.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[278. 141. 163. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1237. 988. 3671. ... -1686. -2792. -3747.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-309. -880. -403. ... -347. 117. -38.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -69. 95. 110. ... -4158. -4650. 150.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -545. -711. -664. ... -2538. -2688. -2558.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -15. -844. -203. ... -140. 405. 1003.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-973. -250. -609. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 74. -52. -42. ... 27. 13. 27.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-271. 291. -174. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1562. 1994. 1814. ... 1597. 2196. 2445.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 220. 231. 225. ... -2516. -2927. -2225.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -206. 86. 284. ... -6725. -4943. -4948.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. 0. 0. ... 828. -227. 2484.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-352. -290. -229. ... 384. 471. 392.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1860. 1714. 1666. ... 829. -3. -781.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2356. -1761. -1103. ... -5574. -5398. -5321.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 11. -21. -32. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 3375. 3625. 3727. ... -1171. -841. -561.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 16. -21. -3. ... -386. -569. -775.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 188. 200. 186. ... 1724. 1596. 1520.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[12074. 17736. 21630. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2.600e+01 1.000e+00 2.900e+01 ... -3.177e+03 -2.644e+03 -2.025e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-6785. -7661. -7239. ... 5335. -7042. -9454.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 128. 33. -147. ... 3875. 1560. -487.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 109. 23. 62. ... 1913. 2229. 538.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 8. 5. 5. ... 605. 825. 1108.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -347. 65. -191. ... 10592. 9693. 8862.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1062. 743. 603. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 396. 378. 386. ... -628. -802. -92.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1124. 1149. 906. ... -71. -75. -60.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 472. 487. 558. ... -1437. -1446. -1338.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -85. -54. -59. ... 2500. 336. -1083.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-376. -120. -143. ... -10. -14. -12.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. -127. -188. ... -299. -619. -1702.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 976. 2067. 2434. ... -5437. -5654. -5568.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -12. -12. -2. ... -1183. -1003. -756.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 49. 24. 11. ... -10. -11. -14.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-237. -213. -225. ... 4472. 4213. 3856.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 4. 80. 79. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-218. -351. -270. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1401. 76. -683. ... -1271. -800. -463.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[7273. 7545. 8934. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1184. -1146. -959. ... -3010. -2149. 644.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 20. 38. 23. ... 936. 1536. 1953.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -125. -240. -207. ... -1377. -1421. -1859.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1837. 582. -2267. ... -142. -11. 1589.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -881. -194. -151. ... -2258. -1907. -1470.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. 1. 0. ... -56. -128. -162.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 146. 146. 140. ... 4515. 5059. 5228.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[311. 324. 325. ... 4. 4. 5.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -655. -589. -261. ... -7508. -6925. -6460.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -261. -102. 28. ... -5979. -6975. -7444.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2. -23. -16. ... 24. 28. 30.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[3003. 2442. 1418. ... -25. -370. -610.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 57. 28. 41. ... -1846. -1347. -929.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -586. -586. -582. ... -3632. -3306. -2901.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1016. 1259. 1635. ... 305. -379. -109.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-218. -301. -87. ... 6966. 6502. 6142.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -287. -43. 184. ... -1369. 325. 1838.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-794. -814. -464. ... 4. -290. -672.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[904. 773. 630. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -135. -126. -101. ... -1176. -1543. -1679.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1336. -1305. -1296. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[3.000e+00 1.700e+01 3.400e+01 ... 7.857e+03 7.265e+03 7.651e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[142. 139. 53. ... -22. 3. -13.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-513. 220. 286. ... 1962. 2783. 3100.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 12. 35. 35. ... 556. 1087. 2289.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 202. -16. -213. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-153. -274. -445. ... 2024. 1910. 1587.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[111. 221. 285. ... 489. 810. 587.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[134. 181. 169. ... 462. 331. 197.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-4970. -5164. -4388. ... -239. -269. -301.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-383. -375. -337. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 175. 240. 285. ... -3321. -3338. -3183.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 46. -25. 21. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -40. -304. 40. ... -317. -345. -299.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 158. 148. 152. ... -180. -291. -270.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -98. -166. -48. ... -2915. -3041. -2667.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-3434. -2476. -1728. ... -678. -1286. -1026.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1151. 1158. 887. ... 2156. 2316. 2367.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[743. 759. 506. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-50. 13. 0. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 24. 1. -24. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2.000e+00 -1.000e+00 0.000e+00 ... -1.802e+03 -1.666e+03 -1.622e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -74. -146. -227. ... -493. -812. -1170.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[260. 112. 70. ... 87. 137. 203.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1666. 1618. 1583. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 616. 611. 600. ... -210. -184. -188.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -539. -716. -570. ... -3319. -3853. -4006.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1429. 1575. 2045. ... -427. -582. -574.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-44. -65. -79. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 29. 40. 30. ... 155. -527. -1130.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 314. 77. -197. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1329. 1176. 975. ... 5492. 5614. 5520.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 808. 803. 789. ... 3811. 4952. 4812.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 432. 149. -204. ... -5358. -5483. -5304.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 411. 454. 486. ... -246. -119. -316.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1068. -133. 1777. ... 34. 82. 136.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 15. 31. 38. ... 4377. 3640. 4498.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1. -33. -16. ... -176. -196. -37.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1.000e+00 -6.000e+00 2.000e+00 ... 3.000e+00 2.178e+03 3.947e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 7286. 6842. 5581. ... -16689. -13749. -10313.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2563. 2335. 2271. ... -8656. -9197. -8843.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 68. 120. -78. ... -560. -543. -525.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 323. 340. 414. ... -2797. -2168. -1730.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1232. -969. -673. ... -971. -443. -735.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[152. 42. -45. ... -24. -29. -34.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1797. 1749. 1613. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 3.0000e+00 -2.0000e+00 1.4000e+01 ... 1.5185e+04 1.6562e+04\n", + " 1.6419e+04] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2874. -1886. -4379. ... 4694. 5277. 4096.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -9. 22. -4. ... 375. -981. -1619.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-127. -224. -258. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2563. 2403. 1674. ... -245. -107. -157.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 169. 68. -27. ... 5314. 14902. 19070.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1231. 1644. -725. ... -1941. -3595. -4985.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2592. -6663. -6295. ... -3111. -2919. -2991.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -35. -34. -38. ... 1440. 1490. 1245.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -22. -35. -13. ... -2443. -1966. -1659.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -690. -1166. -2070. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[111. 6. 34. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -746. -1081. -889. ... -1684. -1513. -1681.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-95. -20. 71. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-110. 83. 1. ... 35. 53. 74.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-763. -792. -783. ... 44. -31. -195.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 66. 65. 29. ... -278. -139. -81.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 474. 538. 704. ... -312. -489. -449.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 241. 229. 251. ... -755. -677. -751.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 351. -80. -364. ... 1676. 569. -475.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -52. -77. -69. ... -265. -845. -1246.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[187. 319. 502. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 43. 73. 33. ... 1964. 1787. 1792.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1165. 1056. 432. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 452. 466. 457. ... -12648. -12694. -12541.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 638. 474. 380. ... -3530. -4179. -4827.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 190. 170. 136. ... -175. -147. -61.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-586. -535. -505. ... 3657. 3559. 3538.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 380. 498. 253. ... -2781. -1031. -1407.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-676. -703. -759. ... -73. -93. -13.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-64. -56. -22. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. 0. 0. ... -11176. -13038. -13836.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 266. -107. -936. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[3237. 4369. 3864. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -89. -79. -85. ... -635. -556. -440.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-578. -134. 28. ... 14. 174. -38.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-8.000e+01 -8.000e+00 7.400e+01 ... -2.003e+03 -7.288e+03 -9.892e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. 131. -12. ... -11. 2. 164.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-36. 143. 86. ... 171. 472. 483.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1058. -758. -424. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 159. 85. -317. ... 1229. 1029. 1002.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1591. 2110. 2628. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 94. 78. 74. ... -1030. -1009. -932.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 141. 109. 359. ... -130. -193. -214.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-36. -54. 67. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 39. 304. 820. ... 5709. 3468. 1959.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-313. -287. -184. ... -66. 53. 82.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 65. 547. -138. ... 2157. 7860. -233.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-333. -67. 363. ... 4018. 5649. 7619.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -120. -134. -139. ... 13425. 11703. 10027.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-3. 2. 0. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -899. -985. -1006. ... -5533. -6273. -6493.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 295. 204. -57. ... -161. -184. -76.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-221. -58. -186. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 5. 4. 5. ... 10. 4. -3.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[0. 4. 4. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2929. 2348. 2210. ... 375. 80. -281.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 132. -143. -244. ... -155. -272. -325.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-121. -82. -76. ... -175. -192. -191.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 86. 172. 210. ... -223. -202. -170.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-8. -3. -1. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 68. 151. 103. ... -1075. -1086. -1111.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. 0. 0. ... -1237. -1556. -1383.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[411. 354. 378. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 4.000e+00 -2.200e+01 -4.900e+01 ... 5.349e+03 4.548e+03 3.690e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-620. -450. -250. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 16. -37. 13. ... 3371. 1668. 23.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -18. -62. -71. ... -2716. -2337. -2572.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 91. -55. 30. ... 728. 935. 1247.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -70. -59. -100. ... -345. 458. 1421.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2410. -2391. -2344. ... -1592. -2228. -1783.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-3984. -2826. -2239. ... -2292. -2586. -2448.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[633. 752. 782. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 244. 290. -20. ... -1099. -497. 149.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[31. 34. 41. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 143. -116. -173. ... 3. -168. -321.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-3.000e+00 1.000e+00 -3.000e+00 ... 1.316e+03 1.143e+03 1.005e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 13. 9. 8. ... -11. -16. -10.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-61. -90. -47. ... 8. -10. -6.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 87. -101. -164. ... 5663. 5635. 4279.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-414. -465. -559. ... 402. 422. 435.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -13. -13. -6. ... -1538. -1495. -1343.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[378. 333. 307. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 135. 1344. 1698. ... -1718. -2279. -6824.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[3489. 2852. 2003. ... -708. -643. -658.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-4188. -4115. -3916. ... 1177. 376. -77.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[434. 484. 453. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 63. 46. 0. ... 646. 564. 498.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 3. -3. -29. ... -486. -521. -687.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-381. -317. -255. ... -940. -941. -929.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -4. -8. 9. ... -171. -157. -131.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -88. -170. -6. ... -181. -195. -166.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -574. -444. -278. ... -844. -2061. -2861.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -43. -15. 38. ... 49. -128. -255.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -16. -13. -21. ... -349. -130. -362.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[544. 528. 550. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -4. -10. -18. ... 22. 23. 9.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -68. -91. -121. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-3864. -4841. -4876. ... 4255. 5190. 4466.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1385. 1487. 1542. ... -473. -488. -597.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 193. 169. 138. ... -217. -156. -88.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1009. -145. -841. ... -607. -336. -264.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-679. 76. 1079. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -245. -248. -212. ... -1408. -1314. -1211.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 4. 5. -1. ... 165. -53. 128.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 141. -36. -102. ... -589. -546. -623.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1592. -1781. -2103. ... 6941. 6916. 7638.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 4448. 5506. 5915. ... -1028. -1230. -1319.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 620. 571. 562. ... 1098. 1056. 1051.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2897. 2642. 2348. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 128. 125. 96. ... 689. 1187. 926.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1867. 1337. 1089. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-172. -51. -31. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2089. -1990. -1815. ... 2898. 4445. 5243.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-499. -270. -107. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -88. -145. -32. ... 180. 54. 84.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[103. -73. 123. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-9101. -8422. -7251. ... -3583. -4143. -4493.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 13. 11. 8. ... -72. -8. -3.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 79. 97. 162. ... 5811. 6193. 6080.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 3. -8. -26. ... -1095. 2146. 341.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[337. 431. 475. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[158. 141. 358. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-625. -736. -839. ... 204. 140. 259.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1914. -1735. -1035. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1849. 1587. 942. ... -2787. -2615. -2473.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 5. 4. 3. ... -1402. -808. 160.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-109. -40. -36. ... 64. -259. 341.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1556. 4302. 6441. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[44. 43. 41. ... 20. 20. 16.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-19. -18. -23. ... 104. 113. 103.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-72. -79. -61. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 260. 61. -275. ... 101. 2295. 544.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-229. -240. -256. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -84. -101. -114. ... 70. -78. -59.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[64. 64. 44. ... 40. -6. 4.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -19. -42. -40. ... -1378. -1786. -1935.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -1. 0. 0. ... 175. 28. -66.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -251. -273. -71. ... -3024. -4950. -6120.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 6. 71. 192. ... -1245. -917. -351.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 44. 37. 27. ... 1216. 1292. 1317.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 72. 87. 110. ... 6082. 6602. 7059.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -7. 42. 69. ... -1883. -2081. -1981.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 26. 27. 31. ... -4131. -4097. -4506.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 86. -76. -123. ... 569. 431. 586.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2281. 1478. 965. ... -1771. 283. 2105.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-466. -467. -492. ... 115. 83. -11.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. -2. -1. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 18. -5. -69. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 284. -553. -235. ... -4856. -6507. -7217.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-3619. -3936. -4510. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 84. -134. -457. ... 90. 95. 85.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-20. -32. -11. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -234. -179. -25. ... -1312. -1722. -1871.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 9. 17. 20. ... -2779. 1678. -594.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2889. 556. -775. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -9. 85. -142. ... -64. -73. 195.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 186. 221. 225. ... 2767. 4074. 6289.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-112. -267. -195. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -34. -29. -98. ... 4820. 3693. 2663.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-8160. -6825. -3942. ... -514. -750. -855.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-585. -345. -439. ... -42. -66. -65.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-4464. -4094. -2018. ... 5804. 5845. 5922.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 205. 58. 95. ... -285. -18. -215.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[9. 6. 5. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -8. -8. -6. ... 181. -280. -858.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 117. 117. 109. ... -4772. -2698. -622.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 3. 4. 6. ... -2. 2. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[162. 253. 83. ... 2. 7. 27.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2040. 2301. 1322. ... 137. -207. -120.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1727. 1851. 2080. ... 1726. 787. 1131.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-861. -731. -554. ... 714. 620. 360.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2745. -2682. -2553. ... 2321. 2944. 4444.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1123. -916. -556. ... -3504. -4607. -5261.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 209. 159. 117. ... 457. 2682. 5346.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-280. -453. -116. ... 196. -64. 405.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-482. -208. -40. ... 93. 998. 1997.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 32. 36. 42. ... -384. -808. -1879.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 206. 185. 244. ... 956. 388. 1430.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 31. 49. 32. ... -3464. -3235. -3139.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -144. -26. 85. ... -17009. -13625. -12708.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 14. -23. -38. ... -1545. -1446. -1204.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-8540. -2873. 1795. ... -2309. -6212. -8446.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -1. 0. 0. ... 311. 827. -504.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1142. -917. -2415. ... -1045. -1171. -1108.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -60. -149. -55. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-488. -763. -947. ... 1094. 591. -283.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -99. -174. -182. ... -303. -213. -306.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 69. -23. -19. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 4477. 4877. 2410. ... 7356. 4578. -2374.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 62. 59. 60. ... -786. -933. -891.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-273. -211. -64. ... -80. -53. -41.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[11232. 10500. 10049. ... 597. -110. -478.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 45. 33. 23. ... 1364. 1552. 1732.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 23. 5. 5. ... -1034. -1117. -1230.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1.700e+01 7.400e+01 1.000e+00 ... -1.775e+03 -1.586e+03 -1.414e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. 0. -1. ... -84. 12. 108.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -36. 88. -99. ... 451. 991. -456.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-160. -27. 7. ... 2243. 2325. 2434.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -33. -10. -174. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 27. 17. 29. ... -69. -665. -1282.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[111. 101. 16. ... 201. 313. 211.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2831. 688. -1094. ... -2003. -2226. -2443.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -5. 67. 141. ... -137. -92. -37.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 272. 517. 703. ... 1640. 1692. 1661.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-363. -81. 16. ... -42. -20. -33.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 797. 981. 1172. ... -80. -13. 121.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-859. -751. -729. ... 375. 1303. 2472.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -87. -104. -121. ... -1535. -1457. -1441.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 312. 388. 386. ... 317. -42. -454.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[360. 218. 95. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 53. -99. -178. ... 1141. 340. -192.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1246. 1073. 755. ... 6914. 6516. 4960.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -148. -115. -82. ... -466. -2052. -1984.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -536. -555. -577. ... 48. -3781. -7563.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-232. -585. -406. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -99. -51. -274. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[55. 31. 18. ... 39. 6. 45.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -23. 111. 195. ... -952. -1207. -1376.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2396. 3068. 3082. ... 445. 88. -22.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -72. 739. 1357. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 76. -38. 18. ... -494. -641. 724.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. -25. -8. ... -28. 35. 39.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-25. -33. -46. ... 21. -62. -80.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1422. 1461. 1491. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. -1. 0. ... -286. -590. -661.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -69. -68. -70. ... 707. 1391. 2388.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -3. 2. 5. ... 172. 103. 51.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 752. 850. 1187. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-16. -22. -25. ... -11. -48. -40.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2172. 2015. 1661. ... -1556. -417. -269.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0.000e+00 0.000e+00 1.000e+00 ... -7.131e+03 -7.987e+03 -8.642e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -16. -68. -327. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 78. 35. 52. ... 3. -89. -94.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 32. 23. 11. ... 271. 332. 436.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 90. -162. 33. ... 495. 503. -104.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -1. -10. 5. ... -261. 61. 320.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2338. 1316. 211. ... 111. 107. 67.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-152. -363. -171. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 7. 24. 24. ... -224. -1061. -2080.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -889. -859. -666. ... -22519. -21216. -17821.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1138. -897. -518. ... 168. -237. -663.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1195. 1192. 1205. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-17. -8. 0. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -9. 100. 252. ... -42. 419. 1019.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1672. -1938. -1929. ... -4861. -4745. -4735.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-113. -130. -131. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1005. -68. -1204. ... -268. -425. 145.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-16. -14. -12. ... -1. -12. -14.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -20. 53. 71. ... 447. 79. -117.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -10. -31. -18. ... 2. -14. -136.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-136. -63. -166. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[6765. 6477. 6436. ... 434. 415. 403.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 4.000e+00 -1.040e+02 -2.600e+01 ... 2.188e+03 -3.347e+03 -8.381e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[109. 176. 119. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 331. 672. 617. ... -1926. -1836. -2013.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1485. 1511. 1895. ... 4658. 5958. 6662.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -18. 60. 76. ... -687. -1018. -977.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2147. 2103. 2103. ... 156. 732. 1046.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-271. -258. -465. ... 4296. 4275. 4366.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[4494. 4076. 3679. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 690. 567. 574. ... -1009. -1949. -1401.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[321. 315. 389. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -9. 1. -9. ... 823. -231. -870.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-21. -10. -8. ... 4. -21. -39.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 82. 69. 53. ... 65. 16. -31.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 623. 372. -6. ... 2132. 1946. 1502.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -2. -2. 0. ... 897. 594. 428.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-635. -35. 438. ... -85. -9. 193.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[151. 598. 738. ... 452. 200. 701.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-643. -580. -463. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 8.000e+00 1.000e+00 -3.000e+00 ... -1.022e+03 -8.090e+02 -1.138e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-386. -412. -402. ... -29. -41. -53.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[713. 808. 890. ... 474. 428. 355.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 136. 411. 797. ... 1420. 1341. 1046.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 341. -383. 226. ... 9548. 7667. 8658.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[9.000e+00 1.040e+02 1.290e+02 ... 9.473e+03 7.961e+03 6.454e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-225. -173. -134. ... 787. 707. 652.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 67. 140. 134. ... -155. 287. -122.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 12. 8. 6. ... -1. -18. -34.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-111. 382. 728. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[2332. 1800. 1204. ... -349. 406. 1095.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 498. 428. 487. ... 3177. 3524. 3496.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -54. -80. -83. ... -2805. -4524. -4702.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 186. 236. 225. ... 5070. 4379. 4764.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[181. 274. 93. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1936. -2192. -1724. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[6. 7. 8. ... 1. 1. 2.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 15. -4. -41. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -39. -20. 27. ... -1786. -1035. 428.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-43. 6. 75. ... -6. 23. 65.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -93. 33. 75. ... -450. -314. -295.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 892. -612. -446. ... -9151. -6921. -4047.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 87. 68. 61. ... -1931. -1905. -1735.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[72. 89. 96. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 5223. 5465. 5359. ... -2763. -3324. -3413.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[69. 63. 20. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-413. -382. -409. ... 569. 841. 1225.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 3.000e+00 0.000e+00 -1.000e+00 ... -2.022e+03 -2.089e+03 -2.088e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-357. -482. -423. ... 3144. 3072. 3132.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-188. -80. -31. ... 3204. 2654. 2162.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2012. 1937. 1899. ... 4795. 8164. 11198.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-10. 15. -2. ... -17. -10. 22.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-2452. -2378. -2118. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 44. -74. -90. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1175. -1187. -713. ... 4655. 4712. 4414.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[89. 49. 77. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. -1. 0. ... 21. 17. 12.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-353. -408. -408. ... -436. 29. 384.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 51. 41. 22. ... -481. -298. -212.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 91. 97. 106. ... -6431. -5858. -4946.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 54. 59. -94. ... -4699. -2467. -1771.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 75. 42. 17. ... 159. 181. 159.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1214. -118. -880. ... -9231. -7343. -6355.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[1488. 1546. 1400. ... -161. 186. 669.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 20. -56. -27. ... -26. -1324. -2779.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-194. -374. -319. ... 734. 519. 234.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -5. -14. -3. ... -32. -34. -25.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1045. -1101. -1110. ... 1453. 2269. 2998.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[0. 0. 0. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-543. -619. -530. ... -35. 47. 345.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 896. 1438. 1895. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -49. -106. -145. ... -798. -878. -886.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-310. -253. -157. ... -54. -32. -38.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -27. -477. -236. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 138. -121. -303. ... -272. -240. 2.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 323. -26. -298. ... -317. -203. -66.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 103. -430. -300. ... 542. 767. 838.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[316. 225. 211. ... -27. 475. 168.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-4611. -4529. -4377. ... -5389. -6854. -8815.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 42. 44. 43. ... 693. 597. 522.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-972. -797. -713. ... -527. -500. -421.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -84. 55. 199. ... -1935. -2360. -2283.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 107. 132. 127. ... 4016. 3147. 2352.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 204. 22. -222. ... 5184. 4977. 5185.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[105. 122. -24. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 86. 98. 202. ... 3411. 3691. 3174.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-175. -135. -92. ... -521. -419. -336.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 412. 437. 487. ... 401. -532. -827.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 13. 32. 59. ... 1724. 1367. 941.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 187. 231. 316. ... 5549. 9277. 15216.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -824. -1012. -1267. ... 4594. 4240. 3760.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -555. -556. -536. ... -1334. -3344. -6048.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[6373. 5814. 5189. ... -188. -83. -152.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. -1255. -3087. ... 1068. 1149. 425.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -36. 4. 34. ... -368. -343. -347.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[3.000e+01 1.100e+01 1.000e+00 ... 1.862e+03 1.790e+03 1.562e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 81. 242. 339. ... 146. 160. -79.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1736. -1552. -1295. ... 190. 114. 119.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 4. -1. -1. ... -455. -326. -217.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1.000e+00 3.000e+00 9.000e+00 ... -1.014e+03 -1.236e+03 -1.243e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-72. -58. -57. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -212. -57. 58. ... -1727. -2284. -2787.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-410. -684. 20. ... -6. -4. -3.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 5. -98. -222. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[4. 5. 5. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1.000e+00 2.100e+01 3.300e+01 ... -1.384e+03 1.200e+03 -7.900e+02] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 2158. 571. -407. ... -1845. -1677. -1826.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 0. 0. -1. ... 49. 41. 29.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -74. -43. -53. ... 7951. 7153. 6282.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-198. -206. -209. ... 1956. 2205. 2438.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -104. -62. -71. ... 14265. 14190. 12021.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-765. -117. 117. ... 513. 229. -20.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -170. -444. -313. ... -1096. 6. 979.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 4.000e+00 -1.000e+01 -2.000e+01 ... 3.271e+03 3.795e+03 4.202e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -45. -54. -42. ... -1190. -1493. -1797.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-140. -133. -233. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 335. 293. 145. ... 986. -1239. -3947.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1. 2. -1. ... 30. -44. -204.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-1029. -1022. -1078. ... -6645. -6135. -5773.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-563. -429. -497. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 867. 443. 45. ... 1499. 2732. 2664.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 168. 186. -19. ... -4709. -1767. 825.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 74. 11. 22. ... 4690. 5579. 6419.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-114. -55. -20. ... -11. 59. 81.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 6097. 5373. 4938. ... -6742. -7051. -7257.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 200. 283. 226. ... -429. -605. -641.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 1455. 1522. 1674. ... -1518. -460. 788.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-346. 411. 786. ... 3691. 3212. 2321.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -65. -64. -80. ... -1390. -1466. -1417.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-45. 54. -62. ... -84. 18. -40.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-653. -736. -785. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-188. -206. -187. ... -28. -26. -40.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 365. 247. 275. ... -119. 268. 312.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-199. -210. -278. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[-280. -866. 2148. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -313. 176. 19. ... -656. -2032. 1026.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 455. -79. -606. ... 873. 1046. 946.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -8412. -11524. -12513. ... -12109. -11182. -9477.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 5. -2. -1. ... -136. 179. 213.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 49. 16. -54. ... -172. -99. -67.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ -61. -109. -70. ... -11. 32. 10.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 462. -1170. -465. ... -2097. 990. 2519.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:3: FutureWarning: Pass y=[ 186. -136. -523. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 63. 59. 65. ... 278. 182. 203.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-187. -96. -175. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -130. -267. -237. ... -687. -1116. -1384.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 177. 269. 225. ... 3516. 3753. 4145.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[207. 253. 257. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 99. 472. 647. ... -53. -64. -69.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -32. -161. -239. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-628. -362. -641. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-223. -282. -389. ... 276. -142. -207.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -374. -1037. -1178. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 25. 5. -6. ... 485. 427. 295.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-242. -222. -202. ... 471. 1175. 1542.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[243. 680. 527. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[1904. 2892. 2009. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -37. -44. -43. ... -364. -305. -247.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 153. -10. -130. ... 390. 258. 75.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 169. 154. 118. ... 522. 1028. 575.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -112. -103. -65. ... -597. -998. -1437.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-130. -181. -112. ... 378. 293. 124.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-1160. -1167. -1044. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 337. 254. 52. ... -68. -279. -987.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 990. 1060. 1195. ... 208. 221. 281.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[174. 152. 236. ... -1. 3. 1.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-42. -22. -1. ... 423. 329. 173.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -3. -35. 36. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-5594. 2564. 3623. ... -70. -20. 101.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-1243. -1106. -905. ... -1156. -767. 370.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-1830. 806. 6255. ... 5670. 6067. 5708.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -5. 38. 60. ... -716. -697. -709.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-1. 6. 7. ... 51. 58. 63.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 88. -114. 71. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 90. -46. 26. ... 3136. 2131. 700.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 0. 1. -1. ... -341. -298. -264.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 397. 229. 88. ... -188. -186. -234.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -94. -68. -69. ... -39. -735. -2040.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-575. -600. -488. ... -544. -234. -302.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 11. -62. -115. ... -769. -686. -609.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 1115. 1691. 2281. ... -500. -1231. -1683.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -4. -2. 13. ... -689. -740. -675.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 91. 105. 106. ... -2564. -2637. -2511.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 235. 1856. 2808. ... -119. 708. 845.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 662. 442. 222. ... -1148. -72. 616.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -293. -412. -381. ... -1872. -919. 670.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[3217. 3443. 3149. ... 1723. 784. -366.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-41. -40. -39. ... 31. 37. 40.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -101. -168. -232. ... -7053. -7020. -6930.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-2457. -3675. -2784. ... -2547. -2906. -1317.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[1494. 1515. 1478. ... 1734. 1842. 1953.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 1447. 1083. 864. ... -3195. -3527. -3452.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-12. 7. -19. ... 1. 3. -32.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 12. -3. 6. ... -83. -135. -68.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 2560. 2796. 3109. ... -7371. -7627. -7217.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-125. -23. 0. ... 864. 799. 976.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 67. 103. -12. ... 48. 50. 10.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-52. -82. 10. ... 11. 18. 2.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-1.000e+00 3.200e+01 9.700e+01 ... 1.291e+03 1.114e+03 9.070e+02] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-243. -397. -257. ... -609. -573. -493.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 386. 14. -740. ... -351. 188. 659.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-412. -423. -854. ... 221. 361. 429.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 5. 1. -3. ... -14. 6. -5.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-105. -175. -112. ... 290. 197. 157.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 36. -29. 11. ... -518. -604. -563.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 239. 238. 256. ... -2354. -2458. -2551.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-115. -179. -281. ... 4326. 2601. 873.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -78. -243. -219. ... 10960. 10191. 9596.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-655. -503. 297. ... 2183. 2975. 4102.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -85. -30. -48. ... -452. -762. -1153.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 58. -78. 109. ... -4. -14. -90.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 826. 1031. 1043. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-210. -172. -195. ... -78. -60. -55.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-404. -199. -221. ... 110. 545. 109.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -48. -152. -73. ... -516. -1109. -1360.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-4.000e+00 -2.000e+00 -2.000e+00 ... -7.729e+03 -6.753e+03 -5.047e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 656. 679. 1083. ... 628. 865. 772.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-102. -107. -81. ... 222. -20. -250.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 30. -121. 152. ... 8661. 8683. 8279.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[125. 97. 176. ... 808. 632. 264.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[305. 99. 50. ... 1. -34. 8.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[3004. 2656. 2193. ... -304. -188. -80.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[458. 486. 266. ... -46. 119. -66.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 3. -45. -51. ... -51. 44. 137.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-359. -413. -418. ... -353. -152. 50.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 83. 74. 47. ... 643. 491. 114.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-395. -379. -468. ... 330. 2301. 1437.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[114. 115. 102. ... 74. 140. 182.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -764. -801. -798. ... -7309. -7309. -7210.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 89. 42. 93. ... 131. 243. 195.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -471. -436. -410. ... -2029. -2816. -2702.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 268. 117. -48. ... -371. -423. -1021.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 0. 4. 5. ... -141. -190. -171.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -9. -36. -41. ... -2257. -1821. -1171.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-2757. -2783. -2656. ... 229. 2189. -561.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-225. -235. -134. ... 2519. 3123. 2934.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -662. -4347. -7671. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 224. 358. 643. ... 6060. 5394. 4833.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 208. 249. 386. ... -564. -291. -123.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 293. 286. 286. ... -1336. -1099. -1140.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-501. -406. -343. ... 640. 400. 243.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 61. 71. 82. ... 907. 584. -229.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[599. 560. 498. ... 195. 192. 189.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -253. -102. 74. ... -4506. -4383. -4174.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-21. 5. 2. ... 918. 912. 725.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[5752. 6724. 7591. ... 1081. 1030. 976.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 75. 65. 64. ... -1223. -1003. -853.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 31. -8. -31. ... 38. 141. 256.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[204. 223. 339. ... 42. 76. 68.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 8474. 10442. 12050. ... 9491. 6705. 6383.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -312. -90. 194. ... 1656. 588. -2269.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 4. 22. 102. ... -32. -55. -49.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-256. -92. -236. ... -730. -734. -569.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[1674. 2251. 2596. ... 32. 43. 99.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-5.000e+00 -1.500e+01 -3.000e+00 ... 3.144e+03 3.991e+03 2.929e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 139. -92. -169. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-1025. -1074. -1115. ... 56. 10. 77.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-115. 238. 218. ... -559. -589. -593.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[302. 367. 50. ... 6. 68. 58.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -447. -792. -769. ... 4585. 12337. 4352.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[1427. 1042. 882. ... 852. 929. 535.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 22. 47. 56. ... -1282. -1559. -1801.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 2.000e+00 -5.000e+00 -2.000e+00 ... 3.152e+03 4.001e+03 5.043e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 206. 37. 171. ... 9873. 8129. 3815.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[50. 47. 45. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 0. -1. -1. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-3198. -3363. -2732. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -223. -154. -149. ... 2725. -2073. 1376.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[894. 815. 916. ... -82. 241. 365.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-1446. -1547. -1620. ... 212. 212. 281.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-10540. -9607. -8978. ... -1210. -111. 802.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[604. 597. 525. ... 684. 897. 980.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -771. -1101. -685. ... 9028. 8882. 8035.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-1032. -1607. -1553. ... 327. 507. 392.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-20. -33. -10. ... 615. 608. 629.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-569. -627. -697. ... -26. -157. -537.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 93. 35. -14. ... 1266. 1223. 1188.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[199. 86. 44. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 697. 726. 584. ... 772. 321. 4173.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 804. 3646. 2102. ... -3717. -4298. -4721.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 27. 27. 60. ... 2188. 2234. 2253.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -962. -193. -373. ... -1245. -920. -1411.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-127. -295. -202. ... 1045. 529. -169.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 0.000e+00 0.000e+00 -1.000e+00 ... 3.162e+03 3.467e+03 3.512e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 65. 108. 212. ... 1432. 2045. 2042.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 286. 387. 528. ... 126. -7. -172.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -11. -4. 2. ... 1209. 1368. 709.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[198. 92. 33. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[28. 41. 39. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 52. -10. -62. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-1131. -365. 538. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-1442. -1624. -1736. ... 3312. 3659. 3758.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-18. 4. 27. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -45. 1616. 1379. ... 538. 430. 616.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 90. 61. 41. ... -311. -193. -161.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-433. -348. 107. ... 105. 152. 272.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 2413. 821. -218. ... -901. 4047. 10527.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[10. 55. 40. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -14. -9. -5. ... 4. -43. -126.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-196. -675. -726. ... -67. 33. 155.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[1216. -296. -423. ... 3362. 4954. 6151.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[147. 156. 171. ... 285. 509. 993.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 0.000e+00 0.000e+00 1.000e+00 ... -2.521e+03 -4.232e+03 -5.075e+03] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 13. -39. -130. ... 584. 881. 1093.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[185. 399. 447. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-19. -34. -8. ... 22. -18. 41.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 37. -70. -36. ... -520. -344. -349.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -161. -168. -133. ... -687. -1434. -1642.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -15. -67. -67. ... 702. 1031. 1194.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-124. 576. 1215. ... 632. 949. 1151.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 254. 233. 254. ... -454. 424. -322.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -99. -211. -84. ... 190. 317. 698.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 96. 133. 103. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 176. 137. 215. ... 4003. 3710. 3943.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 85. 140. 180. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 509. 1594. 2655. ... 2371. 888. -673.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-194. -185. -123. ... 4507. 3854. 3127.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 57. 81. 200. ... 74. -26. -57.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[1. 0. 1. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 519. 247. 79. ... -1677. -1013. -2287.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 3. -18. -52. ... 56. -255. -596.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-358. -472. -432. ... -374. -362. -343.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-617. 5027. 7072. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -52. -112. -186. ... 17. 206. 60.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-3192. -1650. 1297. ... -4775. -5900. -6560.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -6. -216. -424. ... -969. -551. -940.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 2318. -713. -2751. ... 661. -1291. -1970.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 701. 655. 517. ... 1734. 1166. 2607.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-303. -210. -284. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[36. 44. 68. ... -9. -5. -4.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-2134. -2929. -2911. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 264. -493. 63. ... -1225. -1713. -2106.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[166. 134. -7. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 3. -32. 41. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-603. -742. -771. ... -370. -280. -234.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -223. -235. -224. ... -1882. -1449. -1631.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 51. 37. 42. ... -452. -215. -122.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-124. -75. -36. ... 2121. 1988. 1775.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[405. 553. 768. ... 116. 79. 130.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 128. 133. 139. ... 23. -67. -101.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-4346. -6254. 473. ... -460. 2174. 2989.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[1784. 1827. 1707. ... 6246. 6423. 6451.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-2208. -1702. -2163. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-9624. -9365. -9586. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[692. 675. 553. ... 0. 0. 0.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-242. -227. -210. ... 1946. 2013. 1986.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-735. -248. 1070. ... 817. 659. 730.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 615. 413. -102. ... -97. -180. -432.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[-310. -358. -380. ... 4021. 4756. 1832.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -45. -396. -549. ... -881. -1105. -1506.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 370. 363. 394. ... -1559. -1440. -1568.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ -61. -58. -54. ... -3246. -2632. -1735.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "/tmp/ipykernel_91783/1318606634.py:7: FutureWarning: Pass y=[ 70. 223. 197. ... -1431. -1288. -1162.] as keyword args. From version 0.10 passing these as positional arguments will result in an error\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n" + ] + } + ], + "source": [ + "x_train_mel = np.zeros((x_train.shape[0], *S_dB.shape))\n", + "for i in range(x_train.shape[0]):\n", + " x_train_mel[i] = librosa.feature.melspectrogram(x_train[i], sr=sr)\n", + "\n", + "x_test_mel = np.zeros((x_test.shape[0], *S_dB.shape))\n", + "for i in range(x_test.shape[0]):\n", + " x_test_mel[i] = librosa.feature.melspectrogram(x_test[i], sr=sr)\n", + "\n", + "x_train_mel_normalized = (x_train_mel - np.mean(x_train_mel.flatten()))/np.std(x_train_mel.flatten())\n", + "x_test_mel_normalized = (x_test_mel - np.mean(x_train_mel.flatten()))/np.std(x_train_mel.flatten())" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [], + "source": [ + "from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPool2D, Input\n", + "from tensorflow.keras.models import Sequential\n", + "\n", + "def create_model(input_shape):\n", + " model = Sequential([\n", + " Input((input_shape[0], input_shape[1],1)),\n", + "\n", + " Conv2D(32, 3, activation='relu'),\n", + " MaxPool2D(),\n", + " \n", + " Conv2D(64, 3, activation='relu'),\n", + " MaxPool2D(),\n", + " \n", + " Conv2D(128, 3, activation='relu'),\n", + " MaxPool2D(),\n", + "\n", + " Conv2D(256, 3, activation='relu'),\n", + " MaxPool2D(),\n", + "\n", + " Flatten(),\n", + "\n", + " Dense(256, activation='relu'),\n", + "\n", + " Dense(7, activation='softmax'),\n", + " ])\n", + "\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_33\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " conv2d_52 (Conv2D) (None, 126, 155, 32) 320 \n", + " \n", + " max_pooling2d_52 (MaxPoolin (None, 63, 77, 32) 0 \n", + " g2D) \n", + " \n", + " conv2d_53 (Conv2D) (None, 61, 75, 64) 18496 \n", + " \n", + " max_pooling2d_53 (MaxPoolin (None, 30, 37, 64) 0 \n", + " g2D) \n", + " \n", + " conv2d_54 (Conv2D) (None, 28, 35, 128) 73856 \n", + " \n", + " max_pooling2d_54 (MaxPoolin (None, 14, 17, 128) 0 \n", + " g2D) \n", + " \n", + " conv2d_55 (Conv2D) (None, 12, 15, 256) 295168 \n", + " \n", + " max_pooling2d_55 (MaxPoolin (None, 6, 7, 256) 0 \n", + " g2D) \n", + " \n", + " flatten_31 (Flatten) (None, 10752) 0 \n", + " \n", + " dense_44 (Dense) (None, 256) 2752768 \n", + " \n", + " dense_45 (Dense) (None, 7) 1799 \n", + " \n", + "=================================================================\n", + "Total params: 3,142,407\n", + "Trainable params: 3,142,407\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + }, + { + "ename": "ValueError", + "evalue": "Data cardinality is ambiguous:\n x sizes: 128\n y sizes: 1400\nMake sure all arrays contain the same number of samples.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/home/laurent/Documents/Cours/ENSEEIHT/S9 - IAM/IAM_2022_Classification_Audio_Sujet_totally_not_a_virus.ipynb Cell 16\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m model\u001b[39m.\u001b[39mcompile(optimizer\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mAdam\u001b[39m\u001b[39m'\u001b[39m, loss\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mcategorical_crossentropy\u001b[39m\u001b[39m'\u001b[39m, metrics\u001b[39m=\u001b[39m[\u001b[39m'\u001b[39m\u001b[39maccuracy\u001b[39m\u001b[39m'\u001b[39m])\n\u001b[1;32m 3\u001b[0m model\u001b[39m.\u001b[39msummary()\n\u001b[0;32m----> 5\u001b[0m model\u001b[39m.\u001b[39;49mfit(\n\u001b[1;32m 6\u001b[0m x_train_mel_normalized\u001b[39m.\u001b[39;49mswapaxes(\u001b[39m0\u001b[39;49m, \u001b[39m1\u001b[39;49m), y_train,\n\u001b[1;32m 7\u001b[0m epochs\u001b[39m=\u001b[39;49m\u001b[39m20\u001b[39;49m,\n\u001b[1;32m 8\u001b[0m batch_size\u001b[39m=\u001b[39;49m\u001b[39m16\u001b[39;49m,\n\u001b[1;32m 9\u001b[0m shuffle\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m,\n\u001b[1;32m 10\u001b[0m validation_data\u001b[39m=\u001b[39;49m(x_test_mel_normalized\u001b[39m.\u001b[39;49mswapaxes(\u001b[39m0\u001b[39;49m, \u001b[39m1\u001b[39;49m), y_test)\n\u001b[1;32m 11\u001b[0m )\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/keras/utils/traceback_utils.py:67\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 65\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e: \u001b[39m# pylint: disable=broad-except\u001b[39;00m\n\u001b[1;32m 66\u001b[0m filtered_tb \u001b[39m=\u001b[39m _process_traceback_frames(e\u001b[39m.\u001b[39m__traceback__)\n\u001b[0;32m---> 67\u001b[0m \u001b[39mraise\u001b[39;00m e\u001b[39m.\u001b[39mwith_traceback(filtered_tb) \u001b[39mfrom\u001b[39;00m \u001b[39mNone\u001b[39m\n\u001b[1;32m 68\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[1;32m 69\u001b[0m \u001b[39mdel\u001b[39;00m filtered_tb\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/keras/engine/data_adapter.py:1653\u001b[0m, in \u001b[0;36m_check_data_cardinality\u001b[0;34m(data)\u001b[0m\n\u001b[1;32m 1649\u001b[0m msg \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39m \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m sizes: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m\\n\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(\n\u001b[1;32m 1650\u001b[0m label, \u001b[39m\"\u001b[39m\u001b[39m, \u001b[39m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mjoin(\u001b[39mstr\u001b[39m(i\u001b[39m.\u001b[39mshape[\u001b[39m0\u001b[39m])\n\u001b[1;32m 1651\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m tf\u001b[39m.\u001b[39mnest\u001b[39m.\u001b[39mflatten(single_data)))\n\u001b[1;32m 1652\u001b[0m msg \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mMake sure all arrays contain the same number of samples.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m-> 1653\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(msg)\n", + "\u001b[0;31mValueError\u001b[0m: Data cardinality is ambiguous:\n x sizes: 128\n y sizes: 1400\nMake sure all arrays contain the same number of samples." + ] + } + ], + "source": [ + "model = create_model(S_dB.shape)\n", + "model.compile(optimizer='Adam', loss='categorical_crossentropy', metrics=['accuracy'])\n", + "model.summary()\n", + "\n", + "model.fit(\n", + " x_train_mel_normalized, y_train,\n", + " epochs=20,\n", + " batch_size=16,\n", + " shuffle=True,\n", + " validation_data=(x_test_mel_normalized, y_test)\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 3. LSTM" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": {}, + "outputs": [], + "source": [ + "from tensorflow.keras.layers import Dense, Flatten, LSTM, Input\n", + "from tensorflow.keras.models import Sequential\n", + "\n", + "def create_model(input_shape):\n", + " model = Sequential([\n", + " Input((input_shape[1], input_shape[0])),\n", + "\n", + " LSTM(128, activation=\"relu\", return_sequences=True),\n", + " LSTM(64, activation=\"relu\", return_sequences=True),\n", + " LSTM(32, activation=\"relu\"),\n", + "\n", + " Dense(256, activation='relu'),\n", + "\n", + " Dense(7, activation='softmax'),\n", + " ])\n", + "\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_42\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " lstm_27 (LSTM) (None, 157, 128) 131584 \n", + " \n", + " lstm_28 (LSTM) (None, 157, 64) 49408 \n", + " \n", + " lstm_29 (LSTM) (None, 32) 12416 \n", + " \n", + " dense_62 (Dense) (None, 256) 8448 \n", + " \n", + " dense_63 (Dense) (None, 7) 1799 \n", + " \n", + "=================================================================\n", + "Total params: 203,655\n", + "Trainable params: 203,655\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "model = create_model(S_dB.shape)\n", + "model.compile(optimizer='Adam', loss='categorical_crossentropy', metrics=['accuracy'])\n", + "model.summary()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/20\n", + "88/88 [==============================] - 18s 175ms/step - loss: nan - accuracy: 0.1386 - val_loss: nan - val_accuracy: 0.1429\n", + "Epoch 2/20\n", + "88/88 [==============================] - 16s 177ms/step - loss: nan - accuracy: 0.1429 - val_loss: nan - val_accuracy: 0.1429\n", + "Epoch 3/20\n", + "88/88 [==============================] - 15s 172ms/step - loss: nan - accuracy: 0.1429 - val_loss: nan - val_accuracy: 0.1429\n", + "Epoch 4/20\n", + "43/88 [=============>................] - ETA: 7s - loss: nan - accuracy: 0.1308" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/home/laurent/Documents/Cours/ENSEEIHT/S9 - IAM/IAM_2022_Classification_Audio_Sujet_totally_not_a_virus.ipynb Cell 20\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0m model\u001b[39m.\u001b[39;49mfit(\n\u001b[1;32m 2\u001b[0m x_train_mel_normalized\u001b[39m.\u001b[39;49mswapaxes(\u001b[39m1\u001b[39;49m, \u001b[39m2\u001b[39;49m), y_train,\n\u001b[1;32m 3\u001b[0m epochs\u001b[39m=\u001b[39;49m\u001b[39m20\u001b[39;49m,\n\u001b[1;32m 4\u001b[0m batch_size\u001b[39m=\u001b[39;49m\u001b[39m16\u001b[39;49m,\n\u001b[1;32m 5\u001b[0m shuffle\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m,\n\u001b[1;32m 6\u001b[0m validation_data\u001b[39m=\u001b[39;49m(x_test_mel_normalized\u001b[39m.\u001b[39;49mswapaxes(\u001b[39m1\u001b[39;49m, \u001b[39m2\u001b[39;49m), y_test)\n\u001b[1;32m 7\u001b[0m )\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/keras/utils/traceback_utils.py:64\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 62\u001b[0m filtered_tb \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m 63\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m---> 64\u001b[0m \u001b[39mreturn\u001b[39;00m fn(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 65\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e: \u001b[39m# pylint: disable=broad-except\u001b[39;00m\n\u001b[1;32m 66\u001b[0m filtered_tb \u001b[39m=\u001b[39m _process_traceback_frames(e\u001b[39m.\u001b[39m__traceback__)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/keras/engine/training.py:1384\u001b[0m, in \u001b[0;36mModel.fit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m 1377\u001b[0m \u001b[39mwith\u001b[39;00m tf\u001b[39m.\u001b[39mprofiler\u001b[39m.\u001b[39mexperimental\u001b[39m.\u001b[39mTrace(\n\u001b[1;32m 1378\u001b[0m \u001b[39m'\u001b[39m\u001b[39mtrain\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 1379\u001b[0m epoch_num\u001b[39m=\u001b[39mepoch,\n\u001b[1;32m 1380\u001b[0m step_num\u001b[39m=\u001b[39mstep,\n\u001b[1;32m 1381\u001b[0m batch_size\u001b[39m=\u001b[39mbatch_size,\n\u001b[1;32m 1382\u001b[0m _r\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m):\n\u001b[1;32m 1383\u001b[0m callbacks\u001b[39m.\u001b[39mon_train_batch_begin(step)\n\u001b[0;32m-> 1384\u001b[0m tmp_logs \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mtrain_function(iterator)\n\u001b[1;32m 1385\u001b[0m \u001b[39mif\u001b[39;00m data_handler\u001b[39m.\u001b[39mshould_sync:\n\u001b[1;32m 1386\u001b[0m context\u001b[39m.\u001b[39masync_wait()\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/util/traceback_utils.py:150\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 148\u001b[0m filtered_tb \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m 149\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 150\u001b[0m \u001b[39mreturn\u001b[39;00m fn(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 151\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n\u001b[1;32m 152\u001b[0m filtered_tb \u001b[39m=\u001b[39m _process_traceback_frames(e\u001b[39m.\u001b[39m__traceback__)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/def_function.py:915\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 912\u001b[0m compiler \u001b[39m=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mxla\u001b[39m\u001b[39m\"\u001b[39m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_jit_compile \u001b[39melse\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mnonXla\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 914\u001b[0m \u001b[39mwith\u001b[39;00m OptionalXlaContext(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_jit_compile):\n\u001b[0;32m--> 915\u001b[0m result \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_call(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwds)\n\u001b[1;32m 917\u001b[0m new_tracing_count \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mexperimental_get_tracing_count()\n\u001b[1;32m 918\u001b[0m without_tracing \u001b[39m=\u001b[39m (tracing_count \u001b[39m==\u001b[39m new_tracing_count)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/def_function.py:947\u001b[0m, in \u001b[0;36mFunction._call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 944\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock\u001b[39m.\u001b[39mrelease()\n\u001b[1;32m 945\u001b[0m \u001b[39m# In this case we have created variables on the first call, so we run the\u001b[39;00m\n\u001b[1;32m 946\u001b[0m \u001b[39m# defunned version which is guaranteed to never create variables.\u001b[39;00m\n\u001b[0;32m--> 947\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_stateless_fn(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwds) \u001b[39m# pylint: disable=not-callable\u001b[39;00m\n\u001b[1;32m 948\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_stateful_fn \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 949\u001b[0m \u001b[39m# Release the lock early so that multiple threads can perform the call\u001b[39;00m\n\u001b[1;32m 950\u001b[0m \u001b[39m# in parallel.\u001b[39;00m\n\u001b[1;32m 951\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock\u001b[39m.\u001b[39mrelease()\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/function.py:2956\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2953\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock:\n\u001b[1;32m 2954\u001b[0m (graph_function,\n\u001b[1;32m 2955\u001b[0m filtered_flat_args) \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_maybe_define_function(args, kwargs)\n\u001b[0;32m-> 2956\u001b[0m \u001b[39mreturn\u001b[39;00m graph_function\u001b[39m.\u001b[39;49m_call_flat(\n\u001b[1;32m 2957\u001b[0m filtered_flat_args, captured_inputs\u001b[39m=\u001b[39;49mgraph_function\u001b[39m.\u001b[39;49mcaptured_inputs)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/function.py:1853\u001b[0m, in \u001b[0;36mConcreteFunction._call_flat\u001b[0;34m(self, args, captured_inputs, cancellation_manager)\u001b[0m\n\u001b[1;32m 1849\u001b[0m possible_gradient_type \u001b[39m=\u001b[39m gradients_util\u001b[39m.\u001b[39mPossibleTapeGradientTypes(args)\n\u001b[1;32m 1850\u001b[0m \u001b[39mif\u001b[39;00m (possible_gradient_type \u001b[39m==\u001b[39m gradients_util\u001b[39m.\u001b[39mPOSSIBLE_GRADIENT_TYPES_NONE\n\u001b[1;32m 1851\u001b[0m \u001b[39mand\u001b[39;00m executing_eagerly):\n\u001b[1;32m 1852\u001b[0m \u001b[39m# No tape is watching; skip to running the function.\u001b[39;00m\n\u001b[0;32m-> 1853\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_build_call_outputs(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_inference_function\u001b[39m.\u001b[39;49mcall(\n\u001b[1;32m 1854\u001b[0m ctx, args, cancellation_manager\u001b[39m=\u001b[39;49mcancellation_manager))\n\u001b[1;32m 1855\u001b[0m forward_backward \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_select_forward_and_backward_functions(\n\u001b[1;32m 1856\u001b[0m args,\n\u001b[1;32m 1857\u001b[0m possible_gradient_type,\n\u001b[1;32m 1858\u001b[0m executing_eagerly)\n\u001b[1;32m 1859\u001b[0m forward_function, args_with_tangents \u001b[39m=\u001b[39m forward_backward\u001b[39m.\u001b[39mforward()\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/function.py:499\u001b[0m, in \u001b[0;36m_EagerDefinedFunction.call\u001b[0;34m(self, ctx, args, cancellation_manager)\u001b[0m\n\u001b[1;32m 497\u001b[0m \u001b[39mwith\u001b[39;00m _InterpolateFunctionError(\u001b[39mself\u001b[39m):\n\u001b[1;32m 498\u001b[0m \u001b[39mif\u001b[39;00m cancellation_manager \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 499\u001b[0m outputs \u001b[39m=\u001b[39m execute\u001b[39m.\u001b[39;49mexecute(\n\u001b[1;32m 500\u001b[0m \u001b[39mstr\u001b[39;49m(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msignature\u001b[39m.\u001b[39;49mname),\n\u001b[1;32m 501\u001b[0m num_outputs\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_num_outputs,\n\u001b[1;32m 502\u001b[0m inputs\u001b[39m=\u001b[39;49margs,\n\u001b[1;32m 503\u001b[0m attrs\u001b[39m=\u001b[39;49mattrs,\n\u001b[1;32m 504\u001b[0m ctx\u001b[39m=\u001b[39;49mctx)\n\u001b[1;32m 505\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 506\u001b[0m outputs \u001b[39m=\u001b[39m execute\u001b[39m.\u001b[39mexecute_with_cancellation(\n\u001b[1;32m 507\u001b[0m \u001b[39mstr\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39msignature\u001b[39m.\u001b[39mname),\n\u001b[1;32m 508\u001b[0m num_outputs\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_num_outputs,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 511\u001b[0m ctx\u001b[39m=\u001b[39mctx,\n\u001b[1;32m 512\u001b[0m cancellation_manager\u001b[39m=\u001b[39mcancellation_manager)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/execute.py:54\u001b[0m, in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m ctx\u001b[39m.\u001b[39mensure_initialized()\n\u001b[0;32m---> 54\u001b[0m tensors \u001b[39m=\u001b[39m pywrap_tfe\u001b[39m.\u001b[39;49mTFE_Py_Execute(ctx\u001b[39m.\u001b[39;49m_handle, device_name, op_name,\n\u001b[1;32m 55\u001b[0m inputs, attrs, num_outputs)\n\u001b[1;32m 56\u001b[0m \u001b[39mexcept\u001b[39;00m core\u001b[39m.\u001b[39m_NotOkStatusException \u001b[39mas\u001b[39;00m e:\n\u001b[1;32m 57\u001b[0m \u001b[39mif\u001b[39;00m name \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "model.fit(\n", + " x_train_mel_normalized.swapaxes(1, 2), y_train,\n", + " epochs=20,\n", + " batch_size=16,\n", + " shuffle=True,\n", + " validation_data=(x_test_mel_normalized.swapaxes(1, 2), y_test)\n", + ")" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3.10.8 64-bit", + "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" + }, + "vscode": { + "interpreter": { + "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}