{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "6d138c8bef4a12d7",
      "metadata": {
        "collapsed": false,
        "id": "6d138c8bef4a12d7"
      },
      "source": [
        "# UD03 · Notebook 5 — Ampliación: clasificador de géneros musicales\n",
        "\n",
        "Como ejemplo del uso de modelos que funcionan en audio, haremos un clasificador de géneros musicales. Para hacer esto, utilizaremos el conjunto de datos GTZAN, un conjunto de datos de 1000 muestras de audio etiquetadas con el género de la música."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6c615f3690694907",
      "metadata": {
        "collapsed": false,
        "id": "6c615f3690694907"
      },
      "source": [
        "## Instalación de librerías\n",
        "Para ejecutar este cuaderno, necesitaremos instalar las siguientes librerías:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "2f002a03e6f0e117",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2f002a03e6f0e117",
        "outputId": "4c4d3021-6a63-47e1-f4e0-56ea2323013a"
      },
      "outputs": [],
      "source": [
        "%pip install \"transformers<5\" datasets librosa soundfile torch accelerate evaluate\n",
        "\n",
        "import os\n",
        "os.environ[\"WANDB_DISABLED\"] = \"true\"\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f506289975ff0d80",
      "metadata": {
        "collapsed": false,
        "id": "f506289975ff0d80"
      },
      "source": [
        "## Cargamos el dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "b232bb10c0394142",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b232bb10c0394142",
        "outputId": "f283925b-3cb6-40e1-dfcf-4049d5e0dd2f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.12/dist-packages/huggingface_hub/utils/_auth.py:94: UserWarning: \n",
            "The secret `HF_TOKEN` does not exist in your Colab secrets.\n",
            "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n",
            "You will be able to reuse this secret in all of your notebooks.\n",
            "Please note that authentication is recommended but still optional to access public models or datasets.\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "DatasetDict({\n",
              "    train: Dataset({\n",
              "        features: ['file', 'audio', 'genre'],\n",
              "        num_rows: 999\n",
              "    })\n",
              "})"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "from datasets import load_dataset\n",
        "\n",
        "gtzan = load_dataset(\"sanchit-gandhi/gtzan\", \"default\")\n",
        "gtzan"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7926aead087f9ec4",
      "metadata": {
        "collapsed": false,
        "id": "7926aead087f9ec4"
      },
      "source": [
        "Como podemos ver, el conjunto de datos consta de 999 muestras de audio etiquetadas con el género de la música."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "588dcd3a3af20280",
      "metadata": {
        "collapsed": false,
        "id": "588dcd3a3af20280"
      },
      "source": [
        "Los audios están en formato de 22050 Hz, y el modelo necesita 16 kHz. Las versiones recientes de\n",
        "`datasets` exigen instalar `torchcodec` (y un FFmpeg compatible) para decodificar audio\n",
        "automáticamente con la clase `Audio`, algo que falla con facilidad según el entorno (versión de\n",
        "FFmpeg, sistema operativo...). Para evitar esa fragilidad, decodificamos el audio nosotros mismos\n",
        "con `soundfile` (lee los bytes) y `librosa` (remuestrea a 16 kHz), y guardamos el resultado en\n",
        "columnas propias (`array`, `sampling_rate`) en vez de depender del tipo `Audio`.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "eda1d3f9717dbc08",
      "metadata": {
        "id": "eda1d3f9717dbc08"
      },
      "outputs": [],
      "source": [
        "import io\n",
        "\n",
        "import soundfile as sf\n",
        "import librosa\n",
        "from datasets import Audio\n",
        "\n",
        "TARGET_SR = 16000\n",
        "\n",
        "\n",
        "def decodificar_audio(batch):\n",
        "    \"\"\"Decodifica los bytes de audio a mano (sin torchcodec) y remuestrea a 16 kHz.\"\"\"\n",
        "    arrays, sampling_rates = [], []\n",
        "    for item in batch[\"audio\"]:\n",
        "        data, sr = sf.read(io.BytesIO(item[\"bytes\"]))\n",
        "        if data.ndim > 1:\n",
        "            data = data.mean(axis=1)  # a mono\n",
        "        data = data.astype(\"float32\")\n",
        "        if sr != TARGET_SR:\n",
        "            data = librosa.resample(data, orig_sr=sr, target_sr=TARGET_SR)\n",
        "        arrays.append(data)\n",
        "        sampling_rates.append(TARGET_SR)\n",
        "    return {\"array\": arrays, \"sampling_rate\": sampling_rates}\n",
        "\n",
        "\n",
        "gtzan = gtzan.cast_column(\"audio\", Audio(decode=False))\n",
        "gtzan = gtzan.map(\n",
        "    decodificar_audio,\n",
        "    batched=True,\n",
        "    batch_size=16,\n",
        "    remove_columns=[\"audio\"],\n",
        "    desc=\"Decodificando audio\",\n",
        ")\n",
        "# (Ojo: NO usar gtzan.set_format('numpy', ...) aqui - en Colab con torchvision ya\n",
        "# importado, el formateador numpy de datasets intenta importar VideoReader de\n",
        "# torchvision.io y revienta si esa clase no existe en la version instalada. Basta con\n",
        "# convertir a numpy con np.array(...) justo donde haga falta, mas abajo.)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "403ed153c7d5afba",
      "metadata": {
        "collapsed": false,
        "id": "403ed153c7d5afba"
      },
      "source": [
        "## Creación del conjunto de datos `test`\n",
        "\n",
        "Para evaluar el modelo necesitaremos un conjunto de datos de prueba. Para hacer esto, dividiremos el conjunto de datos en dos partes, uno para entrenar el modelo y otro para evaluarlo."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "ac796c9364dc1882",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ac796c9364dc1882",
        "outputId": "49c73c92-11d4-4145-a69b-19fec2340cc2"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 4,
          "data": {
            "text/plain": [
              "DatasetDict({\n    train: Dataset({\n        features: ['file', 'genre', 'array', 'sampling_rate'],\n        num_rows: 899\n    })\n    test: Dataset({\n        features: ['file', 'genre', 'array', 'sampling_rate'],\n        num_rows: 100\n    })\n})"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "gtzan = gtzan[\"train\"].train_test_split(seed=42, shuffle=True, test_size=0.1)\n",
        "gtzan"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "dcf1f1bf669ab51d",
      "metadata": {
        "collapsed": false,
        "id": "dcf1f1bf669ab51d"
      },
      "source": [
        "Una vez que el conjunto de datos se ha separado en dos partes, el conjunto de datos de prueba contendrá 100 muestras de audio.\n",
        "\n",
        "A continuación, mostraremos una muestra del conjunto de datos de prueba."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "4a6af0527a74e424",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4a6af0527a74e424",
        "outputId": "64e7bf49-0562-4aa3-e40f-67ac198d84f9"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 5,
          "data": {
            "text/plain": [
              "{'file': '/home/sanchit/.cache/datasets/downloads/extracted/f729783d70a4541cc4c9d5649655490a9c660280bdbecddfe38a8a806c73f60e/genres/pop/pop.00098.wav',\n 'genre': 7,\n 'array': [0.08735090494155884,\n  0.2018338441848755,\n  0.479086697101593,\n  0.35623201727867126,\n  0.21140910685062408],\n 'sampling_rate': 16000}"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "muestra = gtzan['train'][0]\n",
        "{**muestra, 'array': muestra['array'][:5]}  # solo un fragmento, para no imprimir 480 000 numeros"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "467261b3fee3498c",
      "metadata": {
        "collapsed": false,
        "id": "467261b3fee3498c"
      },
      "source": [
        "De cada muestra del conjunto de datos podemos ver los siguientes datos:\n",
        "- `array`: audio en forma de lista de números. El valor de cada elemento representa la amplitud\n",
        "  de la onda en un instante de tiempo. Como el `sampling_rate` es de 16000 Hz, esta lista tendrá\n",
        "  16 000 elementos por segundo. Se convierte a numpy con `np.array(...)` justo donde haga falta\n",
        "  (al pipeline de clasificación, por ejemplo).\n",
        "- `sampling_rate`: la frecuencia de muestreo del audio, ya remuestreado a 16 kHz.\n",
        "- `genre`: el género de la música como entero. Podemos usar el método `int2str()` del `feature`\n",
        "  `genre()` para obtener el género en formato texto.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "4fe2912b123d91a3",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "4fe2912b123d91a3",
        "outputId": "1d3941f6-1c32-415f-ec55-bf7bcc56c456"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'pop'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 6
        }
      ],
      "source": [
        "int2str = gtzan[\"train\"].features[\"genre\"].int2str\n",
        "int2str(gtzan['train'][0]['genre'])"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8ad7dcda21efd670",
      "metadata": {
        "collapsed": false,
        "id": "8ad7dcda21efd670"
      },
      "source": [
        "## Prueba del modelo sin entrenamiento\n",
        "\n",
        "Antes de comenzar a entrenar el modelo, probaremos el modelo sin entrenamiento para ver cómo se comporta. Usaremos el modelo `distilhubert`, un modelo previamente entrenado para clasificar el audio y fácil de refinar.\n",
        "Para usar el modelo usaremos la clase `pipeline` de la librería Transformers."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "id": "b68cd849ec18fc4c",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-02-13T00:11:29.890682Z",
          "start_time": "2024-02-13T00:11:27.980985Z"
        },
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 186,
          "referenced_widgets": [
            "1884aaa82a5c4ac68861defc29f034b7",
            "5e73d668486047f6986980760b48c20b",
            "3ea227dd21ff4eccb442b0f44d237107",
            "606968009ff44f25adcefb2326626b8a",
            "f5898ae6dcee41d1b4a4e24665191c3c",
            "8440392bcac14bbdae67b26939b61b22",
            "67d4ddf8ff13475eac57833016fecff4",
            "8f732641b2544002bae26109c6b0da44",
            "9dd48220f31042caad5ed464ec1a1983",
            "d5817d662615440684aa1a73cc4c01ff",
            "135ade73497a490092afca8566a719a7",
            "020df5c315104528976b65c5945f5a66",
            "88c95bad28b04ebea98d22be8ce9592c",
            "0205a075f17540f2a8abff74d49f7732",
            "007905026ff54cf28ae641ee5751eb4f",
            "8e8bb5c570af4ebbbb52b9a3723cb465",
            "6433babb79d94133ba08e823291e23f7",
            "03a4591ef45548a7a42a461dc0a3cd5a",
            "59c4c7552a594488ac11fc6f29a0d5ea",
            "297083a7239c446882f1d17e0cecb078",
            "5eb0c90c722144a7abfc8b264e4c9740",
            "989efe091fb248eab48110244582894e",
            "db41012c12064cc5b5966ec4ca86df84",
            "828ce8c6dd484ba8bcdd3e3a9e3601dc",
            "b9f9a29496804c1eb545cc3e9c773bde",
            "c3184fb04eb540aa8b7d478ae99f3790",
            "5ac52c7dd0734682b9285fb34a9b80b6",
            "68ea13dd89104b55b77995a5d528e964",
            "b4575292669b4c039162d027e57ffbf0",
            "25f16ebd05bc4b4b814377cb842b14b4",
            "e4fc5ce5a1b543488287b173fb4787d1",
            "c208d4203b5e4d77bf72ab4b3fefcb51",
            "4585660795c94c1daae791350615ee18"
          ]
        },
        "id": "b68cd849ec18fc4c",
        "outputId": "2943d24d-9eef-4e2d-ec29-3db237e2630c"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "config.json: 0.00B [00:00, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "1884aaa82a5c4ac68861defc29f034b7"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "model.safetensors:   0%|          | 0.00/94.0M [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "020df5c315104528976b65c5945f5a66"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Some weights of HubertForSequenceClassification were not initialized from the model checkpoint at ntu-spml/distilhubert and are newly initialized: ['classifier.bias', 'classifier.weight', 'projector.bias', 'projector.weight']\n",
            "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "preprocessor_config.json:   0%|          | 0.00/214 [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "db41012c12064cc5b5966ec4ca86df84"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Device set to use cuda\n"
          ]
        }
      ],
      "source": [
        "from transformers import pipeline\n",
        "import numpy as np\n",
        "import torch\n",
        "\n",
        "device = 0 if torch.cuda.is_available() else -1\n",
        "\n",
        "classifier = pipeline(\n",
        "    \"audio-classification\", model=\"ntu-spml/distilhubert\",\n",
        "    batch_size=16,\n",
        "    device=device,\n",
        ")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "id": "9ed1ca5c21577c67",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-02-13T00:11:45.733054Z",
          "start_time": "2024-02-13T00:11:31.912228Z"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9ed1ca5c21577c67",
        "outputId": "7586c41e-441a-4070-f07c-994fd1ee1715"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 9,
          "data": {
            "text/plain": [
              "[{'score': 0.5040469765663147, 'label': 'LABEL_0'},\n {'score': 0.4959530234336853, 'label': 'LABEL_1'}]"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "classifier(np.array(gtzan['train'][0]['array'], dtype=\"float32\"))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5660a6feff1cbc09",
      "metadata": {
        "collapsed": false,
        "id": "5660a6feff1cbc09"
      },
      "source": [
        "Calcularemos la precisión del modelo sin entrenamiento. Para esto usaremos el conjunto de datos de prueba.\n",
        "\n",
        "Lo primero que haremos es calcular las predicciones del modelo para cada muestra del conjunto de datos de prueba.\n",
        "\n",
        "A continuación, mostraremos las predicciones del modelo para la primera muestra del conjunto de datos de prueba."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "id": "9996ed6fa22fb1b3",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-02-13T00:15:31.797991Z",
          "start_time": "2024-02-13T00:12:55.278581Z"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9996ed6fa22fb1b3",
        "outputId": "f0f10425-6a82-4d34-940e-39f17ab2d0b1"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 11,
          "data": {
            "text/plain": [
              "[{'score': 0.5014662742614746, 'label': 'LABEL_1'},\n {'score': 0.4985337555408478, 'label': 'LABEL_0'}]"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "predictions = [classifier(np.array(sample['array'], dtype=\"float32\")) for sample in gtzan['test']]\n",
        "predictions[0]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "bc6e997fc93f4610",
      "metadata": {
        "collapsed": false,
        "id": "bc6e997fc93f4610"
      },
      "source": [
        "Una vez que tengamos las predicciones del modelo, las compararemos con las etiquetas reales para calcular la precisión del modelo.\n",
        "\n",
        "A continuación, mostraremos la precisión del modelo."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "id": "9a761cfbb31d102a",
      "metadata": {
        "ExecuteTime": {
          "start_time": "2024-02-13T00:15:31.794357Z"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9a761cfbb31d102a",
        "outputId": "91cc752c-b04f-4db2-df68-fcd84a4daebe"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 12,
          "data": {
            "text/plain": [
              "0.11"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "from sklearn.metrics import accuracy_score\n",
        "\n",
        "y_true = [f\"LABEL_{sample['genre']}\" for sample in gtzan['test']]\n",
        "y_pred = [prediction[0]['label'] for prediction in predictions]\n",
        "\n",
        "accuracy_score(y_true, y_pred)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "MD9pqgNnautL",
      "metadata": {
        "id": "MD9pqgNnautL"
      },
      "source": [
        "\n",
        "## Entrenamiento del modelo\n",
        "\n",
        "Como podemos ver, el modelo sin entrenamiento tiene una precisión del 10%, muy poco. Esto se debe a que el modelo no ha sido entrenado con el conjunto de datos GTZAN.\n",
        "\n",
        "Para entrenar el modelo usaremos la clase `Trainer` de la librería Transformers. Esta clase nos permite entrenar modelos de una manera simple y eficiente.\n",
        "\n",
        "Mientras que con otros modelos necesitamos un `Tokenizer` en este caso usaremos un `feature_extractor`. Esta clase nos permitirá procesar muestras de audio para convertirlas en un formato que pueda procesar el modelo.\n",
        "\n",
        "Entonces crearemos el `feature_extractor` que usaremos para entrenar el modelo."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "id": "u6nryAw9bVhj",
      "metadata": {
        "id": "u6nryAw9bVhj"
      },
      "outputs": [],
      "source": [
        "from transformers import AutoFeatureExtractor\n",
        "\n",
        "model_id = \"ntu-spml/distilhubert\"\n",
        "feature_extractor = AutoFeatureExtractor.from_pretrained(\n",
        "    model_id, do_normalize=True, return_attention_mask=True\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "P-gx10S-bW6m",
      "metadata": {
        "id": "P-gx10S-bW6m"
      },
      "source": [
        "A continuación, procesaremos las muestras de audio, lo que las convierte en un formato que puede procesar el modelo. En nuestro caso, reduciremos las muestras de audio a 30 segundos utilizando las opciones `max_length` y `padding` del `feature_extractor` y eliminaremos los datos que no estamos interesados ​​en el conjunto de datos con el método `remove_columns`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "id": "MlSEREepdmx8",
      "metadata": {
        "id": "MlSEREepdmx8"
      },
      "outputs": [],
      "source": [
        "max_duration = 30.0\n",
        "\n",
        "\n",
        "def preprocess_function(examples):\n",
        "    audio_arrays = [x for x in examples[\"array\"]]\n",
        "    inputs = feature_extractor(\n",
        "        audio_arrays,\n",
        "        sampling_rate=feature_extractor.sampling_rate,\n",
        "        max_length=int(feature_extractor.sampling_rate * max_duration),\n",
        "        truncation=True,\n",
        "        return_attention_mask=True,\n",
        "    )\n",
        "    return inputs\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "tWfk8rnndpir",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 49,
          "referenced_widgets": [
            "3ae91c6084d84e7996a78765739ac0b9",
            "08ae3d7bb95147228a7f9c7634b2f351",
            "43f2ba737caa4ea7af84d73a23fd4673",
            "437adc5ea88c488abb51401d48c9f556",
            "a86d7d366038453897fab1cb87a5c32e",
            "b8f0e65bab2e414b94f108acb755ac51",
            "890176b983fa4b9bb8a890cfb08d8297",
            "4211768265ff4de99a17c0bcda1dc90f",
            "33aae161abc7456091be1c6523c0b3ec",
            "df1811a0e534412ea17b56fce40cdd19",
            "ffb3a3be52f94da1a114cdfd1f877c57"
          ]
        },
        "id": "tWfk8rnndpir",
        "outputId": "8964196f-4947-496d-e5bd-773bd79b5590"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 1,
          "data": {
            "text/plain": [
              "DatasetDict({\n    train: Dataset({\n        features: ['genre', 'input_values', 'attention_mask'],\n        num_rows: 899\n    })\n    test: Dataset({\n        features: ['genre', 'input_values', 'attention_mask'],\n        num_rows: 100\n    })\n})"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "gtzan_encoded = gtzan.map(\n",
        "    preprocess_function,\n",
        "    remove_columns=[\"array\", \"sampling_rate\", \"file\"],\n",
        "    batched=True,\n",
        "    batch_size=16,\n",
        "    num_proc=1,\n",
        ")\n",
        "gtzan_encoded"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3GwyFr-afH6l",
      "metadata": {
        "id": "3GwyFr-afH6l"
      },
      "source": [
        "Renombramos la columna `genre` a `label` para que el `Trainer` pueda identificarlo como una columna de etiquetas."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "Y6k6P7C9fI1Q",
      "metadata": {
        "id": "Y6k6P7C9fI1Q"
      },
      "outputs": [],
      "source": [
        "gtzan_encoded = gtzan_encoded.rename_column(\"genre\", \"label\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "jYU2_QHufKP5",
      "metadata": {
        "id": "jYU2_QHufKP5"
      },
      "source": [
        "Por último, antes de comenzar a entrenar el modelo, crearemos un diccionario en la correspondencia entre los nombres de los géneros y sus valores enteros, de modo que el `Trainer` pueda identificarlos y permitir un cambio rápido entre los dos formatos."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "utfX2v3OfMHo",
      "metadata": {
        "id": "utfX2v3OfMHo"
      },
      "outputs": [],
      "source": [
        "id2label = {\n",
        "    i: int2str(i)\n",
        "    for i in range(len(gtzan_encoded[\"train\"].features[\"label\"].names))\n",
        "}\n",
        "label2id = {v: k for k, v in id2label.items()}\n",
        "\n",
        "id2label[7]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "hhykhhi0l742",
      "metadata": {
        "id": "hhykhhi0l742"
      },
      "source": [
        "## Entrenamiento del modelo\n",
        "\n",
        "A continuación, crearemos el modelo que entrenaremos.\n",
        "\n",
        "!!! Este entrenamiento tarda bastante en CPU (varias horas con las 899 muestras y 3 épocas). Si\n",
        "no tienes GPU a mano, usa un entorno de Colab con GPU (`Entorno de ejecución` → `Cambiar tipo de\n",
        "entorno de ejecución` → `GPU`), o salta directamente a la sección **Uso del modelo entrenado** más\n",
        "abajo y usa la alternativa ya entrenada (`ihanif/distilhubert-music-gtzan-classification`).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "AhWwiJVFl-Kb",
      "metadata": {
        "id": "AhWwiJVFl-Kb"
      },
      "outputs": [],
      "source": [
        "from transformers import AutoModelForAudioClassification\n",
        "\n",
        "model = AutoModelForAudioClassification.from_pretrained(\n",
        "    model_id, num_labels=len(id2label), id2label=id2label, label2id=label2id\n",
        ")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "oxbzvCAgl_zq",
      "metadata": {
        "id": "oxbzvCAgl_zq"
      },
      "source": [
        "Entonces crearemos el `TrainerArguments`, que nos permitirá configurar el `Trainer` para entrenar el modelo."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "wbg2SGYnmBO-",
      "metadata": {
        "id": "wbg2SGYnmBO-"
      },
      "outputs": [],
      "source": [
        "from transformers import TrainingArguments\n",
        "\n",
        "model_name = model_id.split(\"/\")[-1]\n",
        "batch_size = 8\n",
        "gradient_accumulation_steps = 1\n",
        "num_train_epochs = 3\n",
        "\n",
        "training_args = TrainingArguments(\n",
        "    f\"{model_name}-finetuned-gtzan\",\n",
        "    eval_strategy=\"epoch\",\n",
        "    save_strategy=\"epoch\",\n",
        "    learning_rate=5e-5,\n",
        "    per_device_train_batch_size=batch_size,\n",
        "    gradient_accumulation_steps=gradient_accumulation_steps,\n",
        "    per_device_eval_batch_size=batch_size,\n",
        "    num_train_epochs=num_train_epochs,\n",
        "    warmup_ratio=0.1,\n",
        "    logging_steps=5,\n",
        "    load_best_model_at_end=True,\n",
        "    metric_for_best_model=\"accuracy\",\n",
        "    fp16=True\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "FpFv8k7RmFkP",
      "metadata": {
        "id": "FpFv8k7RmFkP"
      },
      "source": [
        "Entonces crearemos el `Trainer`, clase que estará a cargo de entrenar al modelo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "YrtInM-hr4u5",
      "metadata": {
        "id": "YrtInM-hr4u5"
      },
      "outputs": [],
      "source": [
        "import evaluate\n",
        "import numpy as np\n",
        "\n",
        "metric = evaluate.load(\"accuracy\")\n",
        "\n",
        "\n",
        "def compute_metrics(eval_pred):\n",
        "    \"\"\"Computes accuracy on a batch of predictions\"\"\"\n",
        "    predictions = np.argmax(eval_pred.predictions, axis=1)\n",
        "    return metric.compute(predictions=predictions, references=eval_pred.label_ids)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4st478IUmHUe",
      "metadata": {
        "id": "4st478IUmHUe"
      },
      "outputs": [],
      "source": [
        "from transformers import Trainer\n",
        "\n",
        "trainer = Trainer(\n",
        "    model,\n",
        "    training_args,\n",
        "    train_dataset=gtzan_encoded[\"train\"],\n",
        "    eval_dataset=gtzan_encoded[\"test\"],\n",
        "    processing_class=feature_extractor,\n",
        "    compute_metrics=compute_metrics,\n",
        ")\n",
        "\n",
        "trainer.train()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ogYCW16WuyMV",
      "metadata": {
        "id": "ogYCW16WuyMV"
      },
      "outputs": [],
      "source": [
        "trainer.evaluate()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6a95b52040d2fcb2",
      "metadata": {
        "collapsed": false,
        "id": "6a95b52040d2fcb2"
      },
      "source": [
        "## Uso del modelo entrenado\n",
        "\n",
        "Lo primero que haremos es crear la `pipeline` con el modelo que hemos entrenado para clasificar los géneros musicales."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e640544e7bbc58be",
      "metadata": {
        "id": "e640544e7bbc58be"
      },
      "outputs": [],
      "source": [
        "music_classifier = pipeline(\n",
        "    \"audio-classification\",\n",
        "    model=model,\n",
        "    feature_extractor=feature_extractor,\n",
        "    batch_size=16,\n",
        "    device=device,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9234FOTCcQGJ",
      "metadata": {
        "id": "9234FOTCcQGJ"
      },
      "source": [
        "Como alternativa, podemos usar un modelo similar al nuestro, ya preentrenado"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "Hvok3vlOcPTE",
      "metadata": {
        "id": "Hvok3vlOcPTE"
      },
      "outputs": [],
      "source": [
        "music_classifier = pipeline(\n",
        "    \"audio-classification\",\n",
        "    model=\"ihanif/distilhubert-music-gtzan-classification\",\n",
        "    batch_size=16,\n",
        "    device=device,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f108abc5cfedd69b",
      "metadata": {
        "collapsed": false,
        "id": "f108abc5cfedd69b"
      },
      "source": [
        "## Clasificar canciones\n",
        "\n",
        "Una vez creada la tubería, podemos usarla para clasificar una canción: recibe el audio (como\n",
        "matriz numpy) y devuelve el género.\n",
        "\n",
        "Si quieres explorar más música para probar por tu cuenta, aquí tienes enlaces para buscar y\n",
        "descargar (respeta la licencia de cada pista):\n",
        "\n",
        "- [Música clásica](https://freemusicarchive.org/genre/Classical)\n",
        "- [Música electrónica](https://freemusicarchive.org/genre/Electronic)\n",
        "- [Música pop](https://freemusicarchive.org/genre/Pop)\n",
        "- [Música rock](https://freemusicarchive.org/genre/Rock)\n",
        "- [Música jazz](https://freemusicarchive.org/genre/Jazz)\n",
        "\n",
        "Para que el cuaderno funcione **sin depender de un archivo que subas tú**, la siguiente celda\n",
        "descarga unas cuantas canciones de libre licencia de Wikimedia Commons y las clasifica.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3d849a9cd9cb9a2e",
      "metadata": {
        "id": "3d849a9cd9cb9a2e"
      },
      "outputs": [],
      "source": [
        "import requests\n",
        "\n",
        "CABECERAS = {\n",
        "    \"User-Agent\": \"MIA-IA-course-material/1.0 (material docente; sin animo de lucro)\"\n",
        "}\n",
        "\n",
        "# Canciones de licencia libre en Wikimedia Commons (no todas coinciden con el genero \"esperado\":\n",
        "# el propio modelo se equivoca en alguna, lo cual es una buena excusa para comentarlo en clase).\n",
        "canciones = {\n",
        "    \"clasica (Beethoven, Sinfonia 5)\": \"https://upload.wikimedia.org/wikipedia/commons/5/5b/Ludwig_van_Beethoven_-_Symphonie_5_c-moll_-_1._Allegro_con_brio.ogg\",\n",
        "    \"country (US Air Force Academy Band)\": \"https://upload.wikimedia.org/wikipedia/commons/b/b0/Free_Man_-_Wild_Blue_Country_-_United_States_Air_Force_Academy_Band.mp3\",\n",
        "    \"reggae (US Air Force Band of the West)\": \"https://upload.wikimedia.org/wikipedia/commons/b/b9/Say_No_-_Top_Flight_-_United_States_Air_Force_Band_of_the_West.mp3\",\n",
        "    \"blues (US Air Force Band of Mid-America)\": \"https://upload.wikimedia.org/wikipedia/commons/8/86/St._Louis_Blues_March_-_Shades_of_Blue_-_United_States_Air_Force_Band_of_Mid-America.mp3\",\n",
        "    \"rock (US Air Force Band of Flight)\": \"https://upload.wikimedia.org/wikipedia/commons/7/78/4th_Street_Exit_-_Systems_Go_-_United_States_Air_Force_Band_of_Flight.mp3\",\n",
        "}\n",
        "\n",
        "\n",
        "def cargar_cancion(url, duracion=30, intentos=3):\n",
        "    \"\"\"Descarga una URL de audio y devuelve ~duracion segundos del centro, a 16 kHz.\n",
        "\n",
        "    Wikimedia limita las descargas seguidas (HTTP 429): si pasa, esperamos un poco y\n",
        "    reintentamos.\n",
        "    \"\"\"\n",
        "    import time\n",
        "\n",
        "    for intento in range(intentos):\n",
        "        respuesta = requests.get(url, headers=CABECERAS, timeout=30)\n",
        "        if respuesta.status_code == 429 and intento < intentos - 1:\n",
        "            time.sleep(10 * (intento + 1))\n",
        "            continue\n",
        "        respuesta.raise_for_status()\n",
        "        break\n",
        "    datos, sr = sf.read(io.BytesIO(respuesta.content))\n",
        "    if datos.ndim > 1:\n",
        "        datos = datos.mean(axis=1)\n",
        "    datos = datos.astype(\"float32\")\n",
        "    duracion_total = len(datos) / sr\n",
        "    inicio = max(0, int((duracion_total / 2 - duracion / 2) * sr))\n",
        "    fragmento = datos[inicio:inicio + int(duracion * sr)]\n",
        "    if sr != TARGET_SR:\n",
        "        fragmento = librosa.resample(fragmento, orig_sr=sr, target_sr=TARGET_SR)\n",
        "    return fragmento\n",
        "\n",
        "\n",
        "# Si quieres probar con tu propia cancion (un mp3/ogg/wav local), descomenta y adapta:\n",
        "# datos, sr = librosa.load(\"mi_cancion.mp3\", sr=16000)\n",
        "# canciones[\"mi cancion\"] = datos  # ya en 16 kHz, no hace falta pasar por cargar_cancion\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5b3a829b89de65e4",
      "metadata": {
        "id": "5b3a829b89de65e4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "clasica (Beethoven, Sinfonia 5): classical (0.99)\ncountry (US Air Force Academy Band): country (0.96)\nreggae (US Air Force Band of the West): reggae (0.90)\nblues (US Air Force Band of Mid-America): jazz (0.80)\nrock (US Air Force Band of Flight): jazz (0.97)\n"
          ]
        }
      ],
      "source": [
        "for nombre, valor in canciones.items():\n",
        "    try:\n",
        "        audio = cargar_cancion(valor) if isinstance(valor, str) else valor\n",
        "        prediccion = music_classifier(audio)\n",
        "        print(f\"{nombre}: {prediccion[0]['label']} ({prediccion[0]['score']:.2f})\")\n",
        "    except requests.exceptions.RequestException as error:\n",
        "        print(f\"{nombre}: descarga fallida, omitida ({error})\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "83d11617ee34",
      "metadata": {
        "collapsed": false,
        "id": "83d11617ee34"
      },
      "source": [
        "## Alternativa: clasifica tus propias canciones desde Colab\n",
        "\n",
        "Si las descargas de Wikimedia fallan (limite de peticiones, codigo 429) o simplemente quieres\n",
        "probar con tu propia musica, puedes subirla directamente a Colab en vez de depender de una URL\n",
        "externa:\n",
        "\n",
        "1. En el panel izquierdo de Colab, abre la pestana de archivos (icono de carpeta).\n",
        "2. Crea una carpeta llamada `SAMPLES`.\n",
        "3. Sube ahi 3-5 canciones tuyas (`.mp3`, `.wav`, `.ogg` o `.flac`).\n",
        "4. Ejecuta la siguiente celda: buscara y clasificara todo lo que encuentre en `SAMPLES/`.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4ef9f24f958a",
      "metadata": {
        "id": "4ef9f24f958a"
      },
      "outputs": [],
      "source": [
        "from pathlib import Path\n",
        "\n",
        "\n",
        "def cargar_archivo_local(ruta, duracion=30):\n",
        "    \"\"\"Lee un audio local, lo pasa a mono y recorta unos duracion segundos del centro, a 16 kHz.\"\"\"\n",
        "    datos, sr = sf.read(ruta)\n",
        "    if datos.ndim > 1:\n",
        "        datos = datos.mean(axis=1)\n",
        "    datos = datos.astype(\"float32\")\n",
        "    duracion_total = len(datos) / sr\n",
        "    inicio = max(0, int((duracion_total / 2 - duracion / 2) * sr))\n",
        "    fragmento = datos[inicio:inicio + int(duracion * sr)]\n",
        "    if sr != TARGET_SR:\n",
        "        fragmento = librosa.resample(fragmento, orig_sr=sr, target_sr=TARGET_SR)\n",
        "    return fragmento\n",
        "\n",
        "\n",
        "SAMPLES_DIR = Path(\"SAMPLES\")\n",
        "EXTENSIONES = (\"*.mp3\", \"*.wav\", \"*.ogg\", \"*.flac\")\n",
        "archivos = sorted(p for patron in EXTENSIONES for p in SAMPLES_DIR.glob(patron)) if SAMPLES_DIR.is_dir() else []\n",
        "\n",
        "if not archivos:\n",
        "    print(\n",
        "        f\"No se encontraron audios en '{SAMPLES_DIR}/'. Crea esa carpeta en el panel de archivos \"\n",
        "        \"de Colab (icono de carpeta, a la izquierda) y sube ahi 3-5 canciones tuyas (mp3, wav, ogg o flac).\"\n",
        "    )\n",
        "\n",
        "for ruta in archivos:\n",
        "    try:\n",
        "        audio = cargar_archivo_local(ruta)\n",
        "        prediccion = music_classifier(audio)\n",
        "        print(f\"{ruta.name}: {prediccion[0]['label']} ({prediccion[0]['score']:.2f})\")\n",
        "    except Exception as error:\n",
        "        print(f\"{ruta.name}: no se pudo clasificar ({error})\")\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 2
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython2",
      "version": "2.7.6"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}