algunas correcciones en el preprocesamiento, hay que usar el _fixed

examples_cross_entropy.py

@@ -0,0 +1,120 @@
+import numpy as np
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.utils import to_categorical
+
+print("🔥 EJEMPLOS: Binary vs Categorical Cross-Entropy")
+print("=" * 60)
+
+# ================================
+# EJEMPLO 1: BINARY CROSS-ENTROPY
+# ================================
+print("\n1️⃣ BINARY CROSS-ENTROPY (Configuración correcta)")
+print("-" * 50)
+
+# Datos binarios simples
+y_binary = np.array([0, 1, 0, 1, 0])  # Etiquetas simples
+print(f"Etiquetas binarias: {y_binary}")
+
+# Modelo binario
+model_binary = Sequential([
+    Dense(10, activation='relu', input_shape=(5,)),
+    Dense(1, activation='sigmoid')  # ← 1 neurona con sigmoid
+])
+
+model_binary.compile(
+    optimizer='adam',
+    loss='binary_crossentropy',  # ← Binary loss
+    metrics=['accuracy']
+)
+
+print("✅ Arquitectura binaria:")
+print(f"   • Salida: {model_binary.layers[-1].units} neurona")
+print(f"   • Activación: {model_binary.layers[-1].activation.__name__}")
+print(f"   • Etiquetas: valores simples [0, 1]")
+
+# ================================
+# EJEMPLO 2: CATEGORICAL CROSS-ENTROPY
+# ================================
+print("\n2️⃣ CATEGORICAL CROSS-ENTROPY (Configuración correcta)")
+print("-" * 50)
+
+# Convertir a one-hot
+y_categorical = to_categorical(y_binary, num_classes=2)
+print(f"Etiquetas categóricas (one-hot):")
+for i, label in enumerate(y_categorical):
+    print(f"   {y_binary[i]} → {label}")
+
+# Modelo categórico
+model_categorical = Sequential([
+    Dense(10, activation='relu', input_shape=(5,)),
+    Dense(2, activation='softmax')  # ← 2 neuronas con softmax
+])
+
+model_categorical.compile(
+    optimizer='adam',
+    loss='categorical_crossentropy',  # ← Categorical loss
+    metrics=['accuracy']
+)
+
+print("✅ Arquitectura categórica:")
+print(f"   • Salida: {model_categorical.layers[-1].units} neuronas")
+print(f"   • Activación: {model_categorical.layers[-1].activation.__name__}")
+print(f"   • Etiquetas: one-hot vectors [[1,0], [0,1]]")
+
+# ================================
+# EJEMPLO 3: ❌ CONFIGURACIÓN INCORRECTA (tu problema original)
+# ================================
+print("\n❌ CONFIGURACIÓN INCORRECTA (tu problema original)")
+print("-" * 50)
+
+print("🚨 PROBLEMA: binary_crossentropy + to_categorical() + 2 neuronas")
+print("   • Loss: binary_crossentropy")
+print("   • Etiquetas: [[1,0], [0,1]] (one-hot)")
+print("   • Salida: 2 neuronas con softmax")
+print("   • RESULTADO: ❌ No puede aprender correctamente")
+
+# ================================
+# COMPARACIÓN DE SALIDAS
+# ================================
+print("\n📊 COMPARACIÓN DE SALIDAS")
+print("-" * 50)
+
+# Datos dummy para ejemplo
+X_dummy = np.random.random((5, 5))
+
+# Predicciones binarias
+pred_binary = model_binary.predict(X_dummy, verbose=0)
+print("Predicciones binarias:")
+for i, pred in enumerate(pred_binary):
+    print(f"   Muestra {i}: {pred[0]:.4f} (probabilidad clase 1)")
+
+# Predicciones categóricas
+pred_categorical = model_categorical.predict(X_dummy, verbose=0)
+print("\nPredicciones categóricas:")
+for i, pred in enumerate(pred_categorical):
+    print(f"   Muestra {i}: [{pred[0]:.4f}, {pred[1]:.4f}] (prob clase 0, prob clase 1)")
+
+# ================================
+# RECOMENDACIONES PARA TU PROYECTO
+# ================================
+print("\n🎯 RECOMENDACIONES PARA TU PROYECTO DE COTORRAS")
+print("-" * 50)
+
+print("Tienes 2 opciones correctas:")
+print()
+print("OPCIÓN A - Categorical (RECOMENDADA):")
+print("✅ model.add(Dense(2, activation='softmax'))")
+print("✅ model.compile(loss='categorical_crossentropy')")
+print("✅ y_labels = to_categorical([0,1,0,1])")
+print("   • Más fácil de extender a más clases")
+print("   • Mejor para análisis de confianza")
+print()
+print("OPCIÓN B - Binary:")
+print("✅ model.add(Dense(1, activation='sigmoid'))")
+print("✅ model.compile(loss='binary_crossentropy')")
+print("✅ y_labels = [0,1,0,1]  # SIN to_categorical()")
+print("   • Más simple para solo 2 clases")
+print("   • Menos parámetros")
+
+print("\n🚀 Para tu caso: Usa OPCIÓN A (categorical) porque ya tienes to_categorical()") 

src/data/{processed_features_240x320/features.npy → processed_features_224x224_fixed/x_test.npy}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4f0f2f88134457c6d8c63354bfc8343b1449986178a1d5a9b352a1e90a919ee2
-size 2351001728
+oid sha256:08eef84e6c87b234ee3c7a3df47d0de0f9d24dddd2d6b92de9c2620243c31d16
+size 461217920

src/data/processed_features_224x224_fixed/x_train.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:95dac06126ed9f970fa30d2da49743a73dcd2dcacc1da86f39559f960f59ee69
+size 1074770048

src/data/{processed_features_240x320/labels.npy → processed_features_224x224_fixed/y_test.npy}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:806b5650eccffed1041d38a9a63dff31bad6cbe406d00da7bb6a8ae64fd7b08e
-size 20536
+oid sha256:d817be612c7b496ceb841e693d282f33b1f39b3ca9b2e14677b83cf986d6b23e
+size 6256

src/data/processed_features_224x224_fixed/y_train.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:968ce25d915ec3be11c0137d0a389c2b9d66a4da377e3a14cefa55e832ab69a5
+size 14408

src/training/parakeets_cnn_training_fixed.ipynb

@@ -0,0 +1,757 @@
+{
+  "cells": [
+    {
+      "cell_type": "raw",
+      "metadata": {
+        "vscode": {
+          "languageId": "raw"
+        }
+      },
+      "source": [
+        "# Parakeet CNN Training - VERSIÓN BINARIA OPTIMIZADA\n",
+        "\n",
+        "## 🎯 **Configuración BINARIA (más eficiente para tu caso)**\n",
+        "\n",
+        "### Principales correcciones:\n",
+        "1. **🔥 Binary Cross-Entropy**: Más eficiente para clasificación binaria (cotorra vs no-cotorra)\n",
+        "2. **🚀 1 neurona de salida**: En lugar de 2 (menos parámetros, más rápido)\n",
+        "3. **📊 Sin to_categorical()**: Etiquetas directas [0,1] en lugar de [[1,0],[0,1]]\n",
+        "4. **⚡ Normalización Min-Max**: Mejor para spectrogramas [0,1]\n",
+        "5. **🏗️ Arquitectura optimizada**: BatchNormalization, Dropout\n",
+        "\n",
+        "### ✅ **Por qué Binary es mejor para tu caso:**\n",
+        "- Solo 2 clases: cotorra vs no-cotorra\n",
+        "- Más eficiente: menos parámetros y memoria\n",
+        "- Salida intuitiva: probabilidad directa de ser cotorra\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import librosa\n",
+        "import os\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "# from keras.utils import to_categorical  # ← NO NECESARIO para binary classification\n",
+        "import matplotlib.pyplot as plt\n",
+        "from scipy.ndimage import zoom\n",
+        "import warnings\n",
+        "warnings.filterwarnings('ignore')\n",
+        "\n",
+        "print(\"🎯 Configuración BINARIA cargada:\")\n",
+        "print(\"   • SIN to_categorical() - etiquetas directas [0,1]\")\n",
+        "print(\"   • Para: binary_crossentropy + 1 neurona sigmoid\")\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 29,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "def extract_spectrogram_features(audio_file, target_size=(224, 224)):\n",
+        "    \"\"\"\n",
+        "    Extrae características del espectrograma con parámetros optimizados\n",
+        "    \"\"\"\n",
+        "    # Parámetros optimizados del espectrograma\n",
+        "    sr = 32000  # Frecuencia estándar para audio\n",
+        "    n_fft = 340  # Ventana más grande para mejor resolución\n",
+        "    hop_length = 85  # Hop length proporcional\n",
+        "    \n",
+        "    # Cargar audio\n",
+        "    y, sr = librosa.load(audio_file, sr=sr)\n",
+        "    \n",
+        "    # Generar mel-espectrograma con parámetros compatibles\n",
+        "    mel_spec = librosa.feature.melspectrogram(\n",
+        "        y=y, \n",
+        "        sr=sr, \n",
+        "        n_fft=n_fft, \n",
+        "        hop_length=hop_length,\n",
+        "    )\n",
+        "    \n",
+        "    # Convertir a dB\n",
+        "    log_mel_spec = librosa.power_to_db(mel_spec, ref=np.max)\n",
+        "    \n",
+        "    # Redimensionar al tamaño objetivo\n",
+        "    zoom_factors = (target_size[0] / log_mel_spec.shape[0], \n",
+        "                   target_size[1] / log_mel_spec.shape[1])\n",
+        "    resized_spec = zoom(log_mel_spec, zoom_factors, order=1)\n",
+        "    \n",
+        "    spec_3channel = np.stack([resized_spec] * 3, axis=-1)\n",
+        "    \n",
+        "    return spec_3channel\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 30,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "def load_audio_features_from_path(path, label, target_size=(224, 224)):\n",
+        "    \"\"\"\n",
+        "    Carga características de audio con validación mejorada\n",
+        "    \"\"\"\n",
+        "    features = []\n",
+        "    labels = []\n",
+        "    \n",
+        "    print(f\"Procesando: {path}\")\n",
+        "    files = [f for f in os.listdir(path) if f.endswith(('.wav', '.WAV'))]\n",
+        "    print(f\"Archivos encontrados: {len(files)}\")\n",
+        "    \n",
+        "    for i, file in enumerate(files):\n",
+        "        if i % 100 == 0:\n",
+        "            print(f\"Procesando archivo {i+1}/{len(files)}\")\n",
+        "            \n",
+        "        audio_file = os.path.join(path, file)\n",
+        "        try:\n",
+        "            feature = extract_spectrogram_features(audio_file, target_size)\n",
+        "            features.append(feature)\n",
+        "            labels.append(label)\n",
+        "        except Exception as e:\n",
+        "            print(f\"Error procesando {file}: {e}\")\n",
+        "    \n",
+        "    print(f\"Características extraídas: {len(features)}\")\n",
+        "    return features, labels\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 31,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "def normalize_features_globally(features, method='minmax'):\n",
+        "    \"\"\"\n",
+        "    Normalización global consistente de todas las características\n",
+        "    CRÍTICO: Normaliza todo el dataset con las mismas estadísticas\n",
+        "    \n",
+        "    Args:\n",
+        "        features: Lista de características extraídas\n",
+        "        method: 'minmax' (recomendado para spectrogramas) o 'zscore'\n",
+        "    \"\"\"\n",
+        "    features_array = np.array(features)\n",
+        "    \n",
+        "    if method == 'minmax':\n",
+        "        # Min-Max Scaling: [0, 1] - RECOMENDADO para spectrogramas\n",
+        "        global_min = np.min(features_array)\n",
+        "        global_max = np.max(features_array)\n",
+        "        \n",
+        "        # Evitar división por cero\n",
+        "        if global_max == global_min:\n",
+        "            print(\"⚠️ Todos los valores son iguales. Usando valores por defecto.\")\n",
+        "            return features_array\n",
+        "        \n",
+        "        normalized_features = (features_array - global_min) / (global_max - global_min)\n",
+        "        print(f\"✅ Min-Max Normalización aplicada:\")\n",
+        "        print(f\"   Min global: {global_min:.4f} → 0\")\n",
+        "        print(f\"   Max global: {global_max:.4f} → 1\")\n",
+        "        print(f\"   Rango: [0, 1] - Perfecto para CNNs\")\n",
+        "        \n",
+        "    elif method == 'zscore':\n",
+        "        # Z-Score Scaling: media=0, std=1\n",
+        "        global_mean = np.mean(features_array)\n",
+        "        global_std = np.std(features_array)\n",
+        "        \n",
+        "        normalized_features = (features_array - global_mean) / (global_std + 1e-8)\n",
+        "        print(f\"✅ Z-Score Normalización aplicada:\")\n",
+        "        print(f\"   Media global: {global_mean:.4f} → 0\")\n",
+        "        print(f\"   Std global: {global_std:.4f} → 1\")\n",
+        "        \n",
+        "    else:\n",
+        "        raise ValueError(\"method debe ser 'minmax' o 'zscore'\")\n",
+        "    \n",
+        "    # Verificar rango final\n",
+        "    final_min, final_max = np.min(normalized_features), np.max(normalized_features)\n",
+        "    print(f\"   Verificación - Rango final: [{final_min:.4f}, {final_max:.4f}]\")\n",
+        "    \n",
+        "    return normalized_features\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 34,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "=== EXTRAYENDO CARACTERÍSTICAS DE COTORRAS ===\n",
+            "Procesando: ../../data/crudo/clips/cotorra_1500\n",
+            "Archivos encontrados: 1500\n",
+            "Procesando archivo 1/1500\n",
+            "Procesando archivo 101/1500\n",
+            "Procesando archivo 201/1500\n",
+            "Procesando archivo 301/1500\n",
+            "Procesando archivo 401/1500\n",
+            "Procesando archivo 501/1500\n",
+            "Procesando archivo 601/1500\n",
+            "Procesando archivo 701/1500\n",
+            "Procesando archivo 801/1500\n",
+            "Procesando archivo 901/1500\n",
+            "Procesando archivo 1001/1500\n",
+            "Procesando archivo 1101/1500\n",
+            "Procesando archivo 1201/1500\n",
+            "Procesando archivo 1301/1500\n",
+            "Procesando archivo 1401/1500\n",
+            "Características extraídas: 1500\n",
+            "\n",
+            "=== EXTRAYENDO CARACTERÍSTICAS DE NO-COTORRAS ===\n",
+            "Procesando: ../../data/crudo/clips/no_cotorra\n",
+            "Archivos encontrados: 464\n",
+            "Procesando archivo 1/464\n",
+            "Procesando archivo 101/464\n",
+            "Procesando archivo 201/464\n",
+            "Procesando archivo 301/464\n",
+            "Procesando archivo 401/464\n",
+            "Características extraídas: 464\n",
+            "Procesando: ../../data/crudo/clips/no_cotorra/aves\n",
+            "Archivos encontrados: 587\n",
+            "Procesando archivo 1/587\n",
+            "Procesando archivo 101/587\n",
+            "Procesando archivo 201/587\n",
+            "Procesando archivo 301/587\n",
+            "Procesando archivo 401/587\n",
+            "Procesando archivo 501/587\n",
+            "Características extraídas: 587\n",
+            "\n",
+            "=== RESUMEN DE DATOS ===\n",
+            "Total de muestras: 2551\n",
+            "Cotorras: 1500 (58.8%)\n",
+            "No-cotorras: 1051 (41.2%)\n"
+          ]
+        }
+      ],
+      "source": [
+        "# CORRECCIÓN: Flujo de procesamiento mejorado\n",
+        "# Rutas de datos\n",
+        "cotorra_path = \"../../data/crudo/clips/cotorra_1500\"\n",
+        "no_cotorra_path_1 = \"../../data/crudo/clips/no_cotorra\"\n",
+        "no_cotorra_path_2 = \"../../data/crudo/clips/no_cotorra/aves\"\n",
+        "output_path = \"../data/processed_features_224x224_fixed\"\n",
+        "\n",
+        "# Crear directorio de salida\n",
+        "os.makedirs(output_path, exist_ok=True)\n",
+        "\n",
+        "# Extraer características SIN normalización individual\n",
+        "print(\"=== EXTRAYENDO CARACTERÍSTICAS DE COTORRAS ===\")\n",
+        "cotorra_features, cotorra_labels = load_audio_features_from_path(cotorra_path, 1)\n",
+        "\n",
+        "print(\"\\n=== EXTRAYENDO CARACTERÍSTICAS DE NO-COTORRAS ===\")\n",
+        "no_cotorra_features, no_cotorra_labels = load_audio_features_from_path(no_cotorra_path_1, 0)\n",
+        "no_cotorra_features_2, no_cotorra_labels_2 = load_audio_features_from_path(no_cotorra_path_2, 0)\n",
+        "\n",
+        "# Combinar datos\n",
+        "all_features = cotorra_features + no_cotorra_features + no_cotorra_features_2\n",
+        "all_labels = cotorra_labels + no_cotorra_labels + no_cotorra_labels_2\n",
+        "\n",
+        "print(f\"\\n=== RESUMEN DE DATOS ===\")\n",
+        "print(f\"Total de muestras: {len(all_features)}\")\n",
+        "print(f\"Cotorras: {sum(all_labels)} ({sum(all_labels)/len(all_labels)*100:.1f}%)\")\n",
+        "print(f\"No-cotorras: {len(all_labels) - sum(all_labels)} ({(len(all_labels) - sum(all_labels))/len(all_labels)*100:.1f}%)\")\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 35,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "=== APLICANDO NORMALIZACIÓN GLOBAL ===\n",
+            "✅ Min-Max Normalización aplicada:\n",
+            "   Min global: -80.0000 → 0\n",
+            "   Max global: 0.0000 → 1\n",
+            "   Rango: [0, 1] - Perfecto para CNNs\n",
+            "   Verificación - Rango final: [0.0000, 1.0000]\n",
+            "\n",
+            "Forma de entrenamiento: (1785, 224, 224, 3)\n",
+            "Forma de test: (766, 224, 224, 3)\n",
+            "Distribución train - Cotorras: 1050 / No-cotorras: 735\n",
+            "Distribución test - Cotorras: 450 / No-cotorras: 316\n",
+            "\n",
+            "Ejemplo y_train_encoded: [[0. 1.]\n",
+            " [1. 0.]\n",
+            " [1. 0.]\n",
+            " [0. 1.]\n",
+            " [1. 0.]]\n",
+            "Forma y_train_encoded: (1785, 2)\n",
+            "Datos guardados exitosamente!\n"
+          ]
+        }
+      ],
+      "source": [
+        "# 🔥 CORRECCIÓN BINARIA: Normalización global ANTES de split\n",
+        "print(\"\\n=== APLICANDO NORMALIZACIÓN GLOBAL ===\")\n",
+        "\n",
+        "# Min-Max [0, 1] - PERFECTO para spectrogramas\n",
+        "all_features_normalized = normalize_features_globally(all_features, method='minmax')\n",
+        "all_labels_array = np.array(all_labels)\n",
+        "\n",
+        "# División estratificada\n",
+        "x_train, x_test, y_train, y_test = train_test_split(\n",
+        "    all_features_normalized, all_labels_array, \n",
+        "    test_size=0.3, \n",
+        "    random_state=42, \n",
+        "    stratify=all_labels_array\n",
+        ")\n",
+        "\n",
+        "# 🎯 CONFIGURACIÓN BINARIA: SIN to_categorical()\n",
+        "# Para binary_crossentropy usamos etiquetas directas [0, 1]\n",
+        "# NO CONVERTIMOS a one-hot [[1,0], [0,1]]\n",
+        "\n",
+        "print(f\"\\n✅ CONFIGURACIÓN BINARIA:\")\n",
+        "print(f\"   • Etiquetas: valores directos [0, 1] (SIN one-hot)\")\n",
+        "print(f\"   • y_train shape: {y_train.shape} - valores simples\")\n",
+        "print(f\"   • y_test shape: {y_test.shape} - valores simples\")\n",
+        "\n",
+        "print(f\"\\n📊 DISTRIBUCIÓN:\")\n",
+        "print(f\"   • Train - Cotorras: {np.sum(y_train)} / No-cotorras: {len(y_train) - np.sum(y_train)}\")\n",
+        "print(f\"   • Test - Cotorras: {np.sum(y_test)} / No-cotorras: {len(y_test) - np.sum(y_test)}\")\n",
+        "\n",
+        "# Verificar etiquetas binarias\n",
+        "print(f\"\\n🔍 EJEMPLO ETIQUETAS:\")\n",
+        "print(f\"   • y_train[:10]: {y_train[:10]} (0=no-cotorra, 1=cotorra)\")\n",
+        "print(f\"   • Rango: [{y_train.min()}, {y_train.max()}] ✅\")\n",
+        "\n",
+        "# Guardar datos procesados (SIN _encoded porque son binarios directos)\n",
+        "np.save(os.path.join(output_path, 'x_train.npy'), x_train)\n",
+        "np.save(os.path.join(output_path, 'x_test.npy'), x_test)\n",
+        "np.save(os.path.join(output_path, 'y_train.npy'), y_train)  # ← Sin encoded\n",
+        "np.save(os.path.join(output_path, 'y_test.npy'), y_test)    # ← Sin encoded\n",
+        "\n",
+        "print(\"💾 Datos binarios guardados exitosamente!\")\n",
+        "print(\"🚀 Listos para binary_crossentropy + 1 neurona sigmoid\")\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 36,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from keras.models import Sequential\n",
+        "from keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense, BatchNormalization\n",
+        "from keras.optimizers import Adam  # Automáticamente usa legacy en M1/M2 Macs\n",
+        "from keras.callbacks import EarlyStopping, ReduceLROnPlateau\n",
+        "import keras\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 37,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Model: \"sequential_4\"\n",
+            "_________________________________________________________________\n",
+            " Layer (type)                Output Shape              Param #   \n",
+            "=================================================================\n",
+            " conv2d_16 (Conv2D)          (None, 222, 222, 32)      896       \n",
+            "                                                                 \n",
+            " batch_normalization_16 (Ba  (None, 222, 222, 32)      128       \n",
+            " tchNormalization)                                               \n",
+            "                                                                 \n",
+            " max_pooling2d_16 (MaxPooli  (None, 111, 111, 32)      0         \n",
+            " ng2D)                                                           \n",
+            "                                                                 \n",
+            " conv2d_17 (Conv2D)          (None, 109, 109, 64)      18496     \n",
+            "                                                                 \n",
+            " batch_normalization_17 (Ba  (None, 109, 109, 64)      256       \n",
+            " tchNormalization)                                               \n",
+            "                                                                 \n",
+            " max_pooling2d_17 (MaxPooli  (None, 54, 54, 64)        0         \n",
+            " ng2D)                                                           \n",
+            "                                                                 \n",
+            " conv2d_18 (Conv2D)          (None, 52, 52, 128)       73856     \n",
+            "                                                                 \n",
+            " batch_normalization_18 (Ba  (None, 52, 52, 128)       512       \n",
+            " tchNormalization)                                               \n",
+            "                                                                 \n",
+            " max_pooling2d_18 (MaxPooli  (None, 26, 26, 128)       0         \n",
+            " ng2D)                                                           \n",
+            "                                                                 \n",
+            " conv2d_19 (Conv2D)          (None, 24, 24, 256)       295168    \n",
+            "                                                                 \n",
+            " batch_normalization_19 (Ba  (None, 24, 24, 256)       1024      \n",
+            " tchNormalization)                                               \n",
+            "                                                                 \n",
+            " max_pooling2d_19 (MaxPooli  (None, 12, 12, 256)       0         \n",
+            " ng2D)                                                           \n",
+            "                                                                 \n",
+            " flatten_4 (Flatten)         (None, 36864)             0         \n",
+            "                                                                 \n",
+            " dense_12 (Dense)            (None, 512)               18874880  \n",
+            "                                                                 \n",
+            " dropout_8 (Dropout)         (None, 512)               0         \n",
+            "                                                                 \n",
+            " dense_13 (Dense)            (None, 128)               65664     \n",
+            "                                                                 \n",
+            " dropout_9 (Dropout)         (None, 128)               0         \n",
+            "                                                                 \n",
+            " dense_14 (Dense)            (None, 2)                 258       \n",
+            "                                                                 \n",
+            "=================================================================\n",
+            "Total params: 19331138 (73.74 MB)\n",
+            "Trainable params: 19330178 (73.74 MB)\n",
+            "Non-trainable params: 960 (3.75 KB)\n",
+            "_________________________________________________________________\n"
+          ]
+        }
+      ],
+      "source": [
+        "# CORRECCIÓN PRINCIPAL: Modelo con loss function compatible (estilo original)\n",
+        "model = Sequential()\n",
+        "model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(224, 224, 3)))\n",
+        "model.add(BatchNormalization())\n",
+        "model.add(MaxPooling2D(2, 2))\n",
+        "\n",
+        "model.add(Conv2D(64, (3, 3), activation='relu'))\n",
+        "model.add(BatchNormalization())\n",
+        "model.add(MaxPooling2D(2, 2))\n",
+        "\n",
+        "model.add(Conv2D(128, (3, 3), activation='relu'))\n",
+        "model.add(BatchNormalization())\n",
+        "model.add(MaxPooling2D(2, 2))\n",
+        "\n",
+        "model.add(Conv2D(256, (3, 3), activation='relu'))\n",
+        "model.add(BatchNormalization())\n",
+        "model.add(MaxPooling2D(2, 2))\n",
+        "\n",
+        "model.add(Flatten())\n",
+        "model.add(Dense(512, activation='relu'))\n",
+        "model.add(Dropout(0.5))\n",
+        "model.add(Dense(128, activation='relu'))\n",
+        "model.add(Dropout(0.3))\n",
+        "\n",
+        "# 🔥 SALIDA BINARIA: 1 neurona con sigmoid (más eficiente)\n",
+        "model.add(Dense(1, activation='sigmoid'))\n",
+        "\n",
+        "# 🎯 CONFIGURACIÓN BINARIA: binary_crossentropy + etiquetas directas [0,1]\n",
+        "model.compile(\n",
+        "    optimizer='adam',  # Keras automáticamente usa legacy Adam en M1/M2\n",
+        "    loss='binary_crossentropy',  # ← CORRECCIÓN BINARIA PRINCIPAL\n",
+        "    metrics=['accuracy']\n",
+        ")\n",
+        "\n",
+        "model.summary()\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# 🚀 ENTRENAMIENTO BINARIO OPTIMIZADO\n",
+        "print(\"🎯 Iniciando entrenamiento con configuración binaria...\")\n",
+        "\n",
+        "# Callbacks opcionales (puedes comentar si prefieres entrenamiento simple)\n",
+        "from keras.callbacks import EarlyStopping, ReduceLROnPlateau\n",
+        "\n",
+        "early_stopping = EarlyStopping(\n",
+        "    monitor='val_loss',\n",
+        "    patience=5,\n",
+        "    restore_best_weights=True\n",
+        ")\n",
+        "\n",
+        "reduce_lr = ReduceLROnPlateau(\n",
+        "    monitor='val_loss',\n",
+        "    factor=0.2,\n",
+        "    patience=3,\n",
+        "    min_lr=1e-7\n",
+        ")\n",
+        "\n",
+        "# 🔥 ENTRENAMIENTO BINARIO: usando y_train/y_test directos (SIN _encoded)\n",
+        "history = model.fit(\n",
+        "    x_train, y_train,  # ← Etiquetas binarias directas [0,1]\n",
+        "    validation_data=(x_test, y_test),  # ← Sin _encoded\n",
+        "    batch_size=32,  # Batch size eficiente\n",
+        "    epochs=25,\n",
+        "    callbacks=[early_stopping, reduce_lr],\n",
+        "    verbose=1\n",
+        ")\n",
+        "\n",
+        "print(\"✅ Entrenamiento completado!\")\n",
+        "print(\"📊 Configuración usada:\")\n",
+        "print(f\"   • Loss: binary_crossentropy\")\n",
+        "print(f\"   • Salida: 1 neurona sigmoid\")\n",
+        "print(f\"   • Etiquetas: valores directos [0,1]\")\n",
+        "print(f\"   • Batch size: 32\")\n",
+        "\n",
+        "# Entrenamiento simple alternativo (sin callbacks):\n",
+        "# history = model.fit(x_train, y_train, validation_data=(x_test, y_test), batch_size=32, epochs=25)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 38,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Epoch 1/25\n",
+            "112/112 [==============================] - 44s 389ms/step - loss: 9.1723 - accuracy: 0.6275 - val_loss: 1.3144 - val_accuracy: 0.6789 - lr: 0.0010\n",
+            "Epoch 2/25\n",
+            "112/112 [==============================] - 46s 414ms/step - loss: 3.0741 - accuracy: 0.6599 - val_loss: 2.6101 - val_accuracy: 0.4452 - lr: 0.0010\n",
+            "Epoch 3/25\n",
+            "112/112 [==============================] - 77s 690ms/step - loss: 1.1167 - accuracy: 0.7277 - val_loss: 0.6525 - val_accuracy: 0.7833 - lr: 0.0010\n",
+            "Epoch 4/25\n",
+            "112/112 [==============================] - 71s 634ms/step - loss: 0.7091 - accuracy: 0.7630 - val_loss: 0.7093 - val_accuracy: 0.6854 - lr: 0.0010\n",
+            "Epoch 5/25\n",
+            "112/112 [==============================] - 72s 642ms/step - loss: 0.5801 - accuracy: 0.7748 - val_loss: 1.2357 - val_accuracy: 0.6540 - lr: 0.0010\n",
+            "Epoch 6/25\n",
+            "112/112 [==============================] - 69s 621ms/step - loss: 0.5239 - accuracy: 0.7854 - val_loss: 0.4493 - val_accuracy: 0.7755 - lr: 0.0010\n",
+            "Epoch 7/25\n",
+            "112/112 [==============================] - 68s 603ms/step - loss: 0.4193 - accuracy: 0.8331 - val_loss: 0.8670 - val_accuracy: 0.4517 - lr: 0.0010\n",
+            "Epoch 8/25\n",
+            "112/112 [==============================] - 69s 616ms/step - loss: 0.3989 - accuracy: 0.8364 - val_loss: 1.8077 - val_accuracy: 0.6619 - lr: 0.0010\n",
+            "Epoch 9/25\n",
+            "112/112 [==============================] - 66s 592ms/step - loss: 0.4061 - accuracy: 0.8308 - val_loss: 0.8780 - val_accuracy: 0.4452 - lr: 0.0010\n",
+            "Epoch 10/25\n",
+            "112/112 [==============================] - 68s 610ms/step - loss: 0.3163 - accuracy: 0.8784 - val_loss: 0.4764 - val_accuracy: 0.7441 - lr: 2.0000e-04\n",
+            "Epoch 11/25\n",
+            "112/112 [==============================] - 70s 623ms/step - loss: 0.2915 - accuracy: 0.8835 - val_loss: 0.3256 - val_accuracy: 0.8695 - lr: 2.0000e-04\n",
+            "Epoch 12/25\n",
+            "112/112 [==============================] - 67s 595ms/step - loss: 0.2836 - accuracy: 0.8913 - val_loss: 0.3999 - val_accuracy: 0.7990 - lr: 2.0000e-04\n",
+            "Epoch 13/25\n",
+            "112/112 [==============================] - 67s 595ms/step - loss: 0.2710 - accuracy: 0.8947 - val_loss: 0.2704 - val_accuracy: 0.8969 - lr: 2.0000e-04\n",
+            "Epoch 14/25\n",
+            "112/112 [==============================] - 74s 664ms/step - loss: 0.2442 - accuracy: 0.9064 - val_loss: 1.3001 - val_accuracy: 0.6619 - lr: 2.0000e-04\n",
+            "Epoch 15/25\n",
+            "112/112 [==============================] - 62s 557ms/step - loss: 0.2551 - accuracy: 0.9014 - val_loss: 0.7644 - val_accuracy: 0.5300 - lr: 2.0000e-04\n",
+            "Epoch 16/25\n",
+            "112/112 [==============================] - 75s 665ms/step - loss: 0.2464 - accuracy: 0.9092 - val_loss: 0.6758 - val_accuracy: 0.6345 - lr: 2.0000e-04\n",
+            "Epoch 17/25\n",
+            "112/112 [==============================] - 70s 627ms/step - loss: 0.2136 - accuracy: 0.9176 - val_loss: 0.2612 - val_accuracy: 0.9021 - lr: 4.0000e-05\n",
+            "Epoch 18/25\n",
+            "112/112 [==============================] - 67s 597ms/step - loss: 0.1968 - accuracy: 0.9182 - val_loss: 0.2603 - val_accuracy: 0.9073 - lr: 4.0000e-05\n",
+            "Epoch 19/25\n",
+            " 81/112 [====================>.........] - ETA: 17s - loss: 0.2041 - accuracy: 0.9236"
+          ]
+        },
+        {
+          "ename": "KeyboardInterrupt",
+          "evalue": "",
+          "output_type": "error",
+          "traceback": [
+            "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+            "\u001b[31mKeyboardInterrupt\u001b[39m                         Traceback (most recent call last)",
+            "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[38]\u001b[39m\u001b[32m, line 16\u001b[39m\n\u001b[32m      8\u001b[39m reduce_lr = ReduceLROnPlateau(\n\u001b[32m      9\u001b[39m     monitor=\u001b[33m'\u001b[39m\u001b[33mval_loss\u001b[39m\u001b[33m'\u001b[39m,\n\u001b[32m     10\u001b[39m     factor=\u001b[32m0.2\u001b[39m,\n\u001b[32m     11\u001b[39m     patience=\u001b[32m3\u001b[39m,\n\u001b[32m     12\u001b[39m     min_lr=\u001b[32m1e-7\u001b[39m\n\u001b[32m     13\u001b[39m )\n\u001b[32m     15\u001b[39m \u001b[38;5;66;03m# Entrenamiento - puedes usar con o sin callbacks\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m16\u001b[39m history = \u001b[43mmodel\u001b[49m\u001b[43m.\u001b[49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m     17\u001b[39m \u001b[43m    \u001b[49m\u001b[43mx_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_train_encoded\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m     18\u001b[39m \u001b[43m    \u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[43m=\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx_test\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_test_encoded\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m     19\u001b[39m \u001b[43m    \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m16\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# Como tenías originalmente\u001b[39;49;00m\n\u001b[32m     20\u001b[39m \u001b[43m    \u001b[49m\u001b[43mepochs\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m25\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m      \u001b[49m\u001b[38;5;66;43;03m# Como tenías originalmente\u001b[39;49;00m\n\u001b[32m     21\u001b[39m \u001b[43m    \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[43m=\u001b[49m\u001b[43m[\u001b[49m\u001b[43mearly_stopping\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreduce_lr\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# Comenta esta línea si prefieres simple\u001b[39;49;00m\n\u001b[32m     22\u001b[39m \u001b[43m    \u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m1\u001b[39;49m\n\u001b[32m     23\u001b[39m \u001b[43m)\u001b[49m\n\u001b[32m     25\u001b[39m \u001b[38;5;66;03m# Versión simple (como tu código original):\u001b[39;00m\n\u001b[32m     26\u001b[39m \u001b[38;5;66;03m# history = model.fit(x_train, y_train_encoded, validation_data=(x_test, y_test_encoded), batch_size=16, epochs=25)\u001b[39;00m\n",
+            "\u001b[36mFile \u001b[39m\u001b[32m~/Documentos/myiopsitta-monachus-audios/.venv/lib/python3.11/site-packages/keras/src/utils/traceback_utils.py:65\u001b[39m, in \u001b[36mfilter_traceback.<locals>.error_handler\u001b[39m\u001b[34m(*args, **kwargs)\u001b[39m\n\u001b[32m     63\u001b[39m filtered_tb = \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m     64\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m---> \u001b[39m\u001b[32m65\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m     66\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[32m     67\u001b[39m     filtered_tb = _process_traceback_frames(e.__traceback__)\n",
+            "\u001b[36mFile \u001b[39m\u001b[32m~/Documentos/myiopsitta-monachus-audios/.venv/lib/python3.11/site-packages/keras/src/engine/training.py:1807\u001b[39m, in \u001b[36mModel.fit\u001b[39m\u001b[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[39m\n\u001b[32m   1799\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m tf.profiler.experimental.Trace(\n\u001b[32m   1800\u001b[39m     \u001b[33m\"\u001b[39m\u001b[33mtrain\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m   1801\u001b[39m     epoch_num=epoch,\n\u001b[32m   (...)\u001b[39m\u001b[32m   1804\u001b[39m     _r=\u001b[32m1\u001b[39m,\n\u001b[32m   1805\u001b[39m ):\n\u001b[32m   1806\u001b[39m     callbacks.on_train_batch_begin(step)\n\u001b[32m-> \u001b[39m\u001b[32m1807\u001b[39m     tmp_logs = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mtrain_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43miterator\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   1808\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m data_handler.should_sync:\n\u001b[32m   1809\u001b[39m         context.async_wait()\n",
+            "\u001b[36mFile \u001b[39m\u001b[32m~/Documentos/myiopsitta-monachus-audios/.venv/lib/python3.11/site-packages/tensorflow/python/util/traceback_utils.py:150\u001b[39m, in \u001b[36mfilter_traceback.<locals>.error_handler\u001b[39m\u001b[34m(*args, **kwargs)\u001b[39m\n\u001b[32m    148\u001b[39m filtered_tb = \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m    149\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m150\u001b[39m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    151\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[32m    152\u001b[39m   filtered_tb = _process_traceback_frames(e.__traceback__)\n",
+            "\u001b[36mFile \u001b[39m\u001b[32m~/Documentos/myiopsitta-monachus-audios/.venv/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:832\u001b[39m, in \u001b[36mFunction.__call__\u001b[39m\u001b[34m(self, *args, **kwds)\u001b[39m\n\u001b[32m    829\u001b[39m compiler = \u001b[33m\"\u001b[39m\u001b[33mxla\u001b[39m\u001b[33m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._jit_compile \u001b[38;5;28;01melse\u001b[39;00m \u001b[33m\"\u001b[39m\u001b[33mnonXla\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m    831\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m OptionalXlaContext(\u001b[38;5;28mself\u001b[39m._jit_compile):\n\u001b[32m--> \u001b[39m\u001b[32m832\u001b[39m   result = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_call\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    834\u001b[39m new_tracing_count = \u001b[38;5;28mself\u001b[39m.experimental_get_tracing_count()\n\u001b[32m    835\u001b[39m without_tracing = (tracing_count == new_tracing_count)\n",
+            "\u001b[36mFile \u001b[39m\u001b[32m~/Documentos/myiopsitta-monachus-audios/.venv/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:868\u001b[39m, in \u001b[36mFunction._call\u001b[39m\u001b[34m(self, *args, **kwds)\u001b[39m\n\u001b[32m    865\u001b[39m   \u001b[38;5;28mself\u001b[39m._lock.release()\n\u001b[32m    866\u001b[39m   \u001b[38;5;66;03m# In this case we have created variables on the first call, so we run the\u001b[39;00m\n\u001b[32m    867\u001b[39m   \u001b[38;5;66;03m# defunned version which is guaranteed to never create variables.\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m868\u001b[39m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtracing_compilation\u001b[49m\u001b[43m.\u001b[49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m    869\u001b[39m \u001b[43m      \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_no_variable_creation_config\u001b[49m\n\u001b[32m    870\u001b[39m \u001b[43m  \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    871\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._variable_creation_config \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m    872\u001b[39m   \u001b[38;5;66;03m# Release the lock early so that multiple threads can perform the call\u001b[39;00m\n\u001b[32m    873\u001b[39m   \u001b[38;5;66;03m# in parallel.\u001b[39;00m\n\u001b[32m    874\u001b[39m   \u001b[38;5;28mself\u001b[39m._lock.release()\n",
+            "\u001b[36mFile \u001b[39m\u001b[32m~/Documentos/myiopsitta-monachus-audios/.venv/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/tracing_compilation.py:139\u001b[39m, in \u001b[36mcall_function\u001b[39m\u001b[34m(args, kwargs, tracing_options)\u001b[39m\n\u001b[32m    137\u001b[39m bound_args = function.function_type.bind(*args, **kwargs)\n\u001b[32m    138\u001b[39m flat_inputs = function.function_type.unpack_inputs(bound_args)\n\u001b[32m--> \u001b[39m\u001b[32m139\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunction\u001b[49m\u001b[43m.\u001b[49m\u001b[43m_call_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# pylint: disable=protected-access\u001b[39;49;00m\n\u001b[32m    140\u001b[39m \u001b[43m    \u001b[49m\u001b[43mflat_inputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcaptured_inputs\u001b[49m\u001b[43m=\u001b[49m\u001b[43mfunction\u001b[49m\u001b[43m.\u001b[49m\u001b[43mcaptured_inputs\u001b[49m\n\u001b[32m    141\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
+            "\u001b[36mFile \u001b[39m\u001b[32m~/Documentos/myiopsitta-monachus-audios/.venv/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/concrete_function.py:1323\u001b[39m, in \u001b[36mConcreteFunction._call_flat\u001b[39m\u001b[34m(self, tensor_inputs, captured_inputs)\u001b[39m\n\u001b[32m   1319\u001b[39m possible_gradient_type = gradients_util.PossibleTapeGradientTypes(args)\n\u001b[32m   1320\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m (possible_gradient_type == gradients_util.POSSIBLE_GRADIENT_TYPES_NONE\n\u001b[32m   1321\u001b[39m     \u001b[38;5;129;01mand\u001b[39;00m executing_eagerly):\n\u001b[32m   1322\u001b[39m   \u001b[38;5;66;03m# No tape is watching; skip to running the function.\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1323\u001b[39m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_inference_function\u001b[49m\u001b[43m.\u001b[49m\u001b[43mcall_preflattened\u001b[49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   1324\u001b[39m forward_backward = \u001b[38;5;28mself\u001b[39m._select_forward_and_backward_functions(\n\u001b[32m   1325\u001b[39m     args,\n\u001b[32m   1326\u001b[39m     possible_gradient_type,\n\u001b[32m   1327\u001b[39m     executing_eagerly)\n\u001b[32m   1328\u001b[39m forward_function, args_with_tangents = forward_backward.forward()\n",
+            "\u001b[36mFile \u001b[39m\u001b[32m~/Documentos/myiopsitta-monachus-audios/.venv/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py:216\u001b[39m, in \u001b[36mAtomicFunction.call_preflattened\u001b[39m\u001b[34m(self, args)\u001b[39m\n\u001b[32m    214\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mcall_preflattened\u001b[39m(\u001b[38;5;28mself\u001b[39m, args: Sequence[core.Tensor]) -> Any:\n\u001b[32m    215\u001b[39m \u001b[38;5;250m  \u001b[39m\u001b[33;03m\"\"\"Calls with flattened tensor inputs and returns the structured output.\"\"\"\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m216\u001b[39m   flat_outputs = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mcall_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    217\u001b[39m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m.function_type.pack_output(flat_outputs)\n",
+            "\u001b[36mFile \u001b[39m\u001b[32m~/Documentos/myiopsitta-monachus-audios/.venv/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py:251\u001b[39m, in \u001b[36mAtomicFunction.call_flat\u001b[39m\u001b[34m(self, *args)\u001b[39m\n\u001b[32m    249\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m record.stop_recording():\n\u001b[32m    250\u001b[39m   \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._bound_context.executing_eagerly():\n\u001b[32m--> \u001b[39m\u001b[32m251\u001b[39m     outputs = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_bound_context\u001b[49m\u001b[43m.\u001b[49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m    252\u001b[39m \u001b[43m        \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    253\u001b[39m \u001b[43m        \u001b[49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    254\u001b[39m \u001b[43m        \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mfunction_type\u001b[49m\u001b[43m.\u001b[49m\u001b[43mflat_outputs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    255\u001b[39m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    256\u001b[39m   \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m    257\u001b[39m     outputs = make_call_op_in_graph(\n\u001b[32m    258\u001b[39m         \u001b[38;5;28mself\u001b[39m,\n\u001b[32m    259\u001b[39m         \u001b[38;5;28mlist\u001b[39m(args),\n\u001b[32m    260\u001b[39m         \u001b[38;5;28mself\u001b[39m._bound_context.function_call_options.as_attrs(),\n\u001b[32m    261\u001b[39m     )\n",
+            "\u001b[36mFile \u001b[39m\u001b[32m~/Documentos/myiopsitta-monachus-audios/.venv/lib/python3.11/site-packages/tensorflow/python/eager/context.py:1486\u001b[39m, in \u001b[36mContext.call_function\u001b[39m\u001b[34m(self, name, tensor_inputs, num_outputs)\u001b[39m\n\u001b[32m   1484\u001b[39m cancellation_context = cancellation.context()\n\u001b[32m   1485\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m cancellation_context \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1486\u001b[39m   outputs = \u001b[43mexecute\u001b[49m\u001b[43m.\u001b[49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m   1487\u001b[39m \u001b[43m      \u001b[49m\u001b[43mname\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdecode\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mutf-8\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m   1488\u001b[39m \u001b[43m      \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[43m=\u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m   1489\u001b[39m \u001b[43m      \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m=\u001b[49m\u001b[43mtensor_inputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m   1490\u001b[39m \u001b[43m      \u001b[49m\u001b[43mattrs\u001b[49m\u001b[43m=\u001b[49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m   1491\u001b[39m \u001b[43m      \u001b[49m\u001b[43mctx\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m   1492\u001b[39m \u001b[43m  \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   1493\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m   1494\u001b[39m   outputs = execute.execute_with_cancellation(\n\u001b[32m   1495\u001b[39m       name.decode(\u001b[33m\"\u001b[39m\u001b[33mutf-8\u001b[39m\u001b[33m\"\u001b[39m),\n\u001b[32m   1496\u001b[39m       num_outputs=num_outputs,\n\u001b[32m   (...)\u001b[39m\u001b[32m   1500\u001b[39m       cancellation_manager=cancellation_context,\n\u001b[32m   1501\u001b[39m   )\n",
+            "\u001b[36mFile \u001b[39m\u001b[32m~/Documentos/myiopsitta-monachus-audios/.venv/lib/python3.11/site-packages/tensorflow/python/eager/execute.py:53\u001b[39m, in \u001b[36mquick_execute\u001b[39m\u001b[34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[39m\n\u001b[32m     51\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m     52\u001b[39m   ctx.ensure_initialized()\n\u001b[32m---> \u001b[39m\u001b[32m53\u001b[39m   tensors = \u001b[43mpywrap_tfe\u001b[49m\u001b[43m.\u001b[49m\u001b[43mTFE_Py_Execute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[43m.\u001b[49m\u001b[43m_handle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mop_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m     54\u001b[39m \u001b[43m                                      \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m     55\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m core._NotOkStatusException \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[32m     56\u001b[39m   \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
+            "\u001b[31mKeyboardInterrupt\u001b[39m: "
+          ]
+        }
+      ],
+      "source": [
+        "# Callbacks para entrenamiento robusto (opcional - puedes comentar si prefieres simple)\n",
+        "early_stopping = EarlyStopping(\n",
+        "    monitor='val_loss',\n",
+        "    patience=5,\n",
+        "    restore_best_weights=True\n",
+        ")\n",
+        "\n",
+        "reduce_lr = ReduceLROnPlateau(\n",
+        "    monitor='val_loss',\n",
+        "    factor=0.2,\n",
+        "    patience=3,\n",
+        "    min_lr=1e-7\n",
+        ")\n",
+        "\n",
+        "# Entrenamiento - puedes usar con o sin callbacks\n",
+        "history = model.fit(\n",
+        "    x_train, y_train_encoded,\n",
+        "    validation_data=(x_test, y_test_encoded),\n",
+        "    batch_size=16,  # Como tenías originalmente\n",
+        "    epochs=25,      # Como tenías originalmente\n",
+        "    callbacks=[early_stopping, reduce_lr],  # Comenta esta línea si prefieres simple\n",
+        "    verbose=1\n",
+        ")\n",
+        "\n",
+        "# Versión simple (como tu código original):\n",
+        "# history = model.fit(x_train, y_train_encoded, validation_data=(x_test, y_test_encoded), batch_size=16, epochs=25)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# 📊 EVALUACIÓN BINARIA COMPLETA\n",
+        "import matplotlib.pyplot as plt\n",
+        "from sklearn.metrics import confusion_matrix, classification_report\n",
+        "import seaborn as sns\n",
+        "\n",
+        "# Gráficos de entrenamiento\n",
+        "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))\n",
+        "\n",
+        "# Accuracy\n",
+        "ax1.plot(history.history['accuracy'], label='Training Accuracy')\n",
+        "ax1.plot(history.history['val_accuracy'], label='Validation Accuracy')\n",
+        "ax1.set_title('Model Accuracy (Binary)')\n",
+        "ax1.set_xlabel('Epoch')\n",
+        "ax1.set_ylabel('Accuracy')\n",
+        "ax1.legend()\n",
+        "\n",
+        "# Loss\n",
+        "ax2.plot(history.history['loss'], label='Training Loss')\n",
+        "ax2.plot(history.history['val_loss'], label='Validation Loss')\n",
+        "ax2.set_title('Model Loss (Binary)')\n",
+        "ax2.set_xlabel('Epoch')\n",
+        "ax2.set_ylabel('Loss')\n",
+        "ax2.legend()\n",
+        "\n",
+        "plt.tight_layout()\n",
+        "plt.show()\n",
+        "\n",
+        "# 🎯 PREDICCIONES BINARIAS (diferentes a categorical)\n",
+        "y_pred_probs = model.predict(x_test)  # Probabilidades de ser cotorra [0-1]\n",
+        "y_pred_classes = (y_pred_probs > 0.5).astype(int).flatten()  # Convertir a clases [0,1]\n",
+        "\n",
+        "print(\"🔍 EJEMPLOS DE PREDICCIÓN BINARIA:\")\n",
+        "print(f\"Probabilidades: {y_pred_probs[:5].flatten()}\")\n",
+        "print(f\"Clases predichas: {y_pred_classes[:5]}\")\n",
+        "print(f\"Clases reales: {y_test[:5]}\")\n",
+        "\n",
+        "# Matriz de confusión BINARIA\n",
+        "cm = confusion_matrix(y_test, y_pred_classes)  # ← Usando y_test directo (no _encoded)\n",
+        "plt.figure(figsize=(8, 6))\n",
+        "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',\n",
+        "           xticklabels=['No Cotorra', 'Cotorra'],\n",
+        "           yticklabels=['No Cotorra', 'Cotorra'])\n",
+        "plt.title('Confusion Matrix (Binary)')\n",
+        "plt.ylabel('True Label')\n",
+        "plt.xlabel('Predicted Label')\n",
+        "plt.show()\n",
+        "\n",
+        "# Reporte de clasificación BINARIA\n",
+        "print(\"\\n📋 CLASSIFICATION REPORT (BINARY):\")\n",
+        "print(classification_report(y_test, y_pred_classes, target_names=['No Cotorra', 'Cotorra']))\n",
+        "\n",
+        "# Estadísticas adicionales\n",
+        "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n",
+        "\n",
+        "accuracy = accuracy_score(y_test, y_pred_classes)\n",
+        "precision = precision_score(y_test, y_pred_classes)\n",
+        "recall = recall_score(y_test, y_pred_classes)\n",
+        "f1 = f1_score(y_test, y_pred_classes)\n",
+        "\n",
+        "print(f\"\\n🎯 MÉTRICAS BINARIAS:\")\n",
+        "print(f\"   • Accuracy: {accuracy:.4f}\")\n",
+        "print(f\"   • Precision: {precision:.4f}\")\n",
+        "print(f\"   • Recall: {recall:.4f}\")\n",
+        "print(f\"   • F1-Score: {f1:.4f}\")\n",
+        "\n",
+        "# Guardar modelo binario\n",
+        "model.save('modelo_cotorra_binario_optimizado.h5')\n",
+        "print(\"\\n💾 Modelo guardado como 'modelo_cotorra_binario_optimizado.h5'\")\n",
+        "print(\"🚀 Configuración: binary_crossentropy + 1 neurona sigmoid + etiquetas [0,1]\")\n"
+      ]
+    },
+    {
+      "cell_type": "raw",
+      "metadata": {
+        "vscode": {
+          "languageId": "raw"
+        }
+      },
+      "source": [
+        "## 📋 **RESUMEN: Binary vs Categorical Cross-Entropy**\n",
+        "\n",
+        "### ✅ **CONFIGURACIÓN BINARIA (actual - MÁS EFICIENTE)**\n",
+        "\n",
+        "| Aspecto | Configuración |\n",
+        "|---------|---------------|\n",
+        "| **Problema** | 2 clases: cotorra vs no-cotorra |\n",
+        "| **Neuronas salida** | `Dense(1, activation='sigmoid')` |\n",
+        "| **Loss function** | `binary_crossentropy` |\n",
+        "| **Etiquetas** | `[0, 1, 0, 1, ...]` (valores directos) |\n",
+        "| **Predicción** | `model.predict()` → `[0.23, 0.87, ...]` (probabilidades) |\n",
+        "| **Ventajas** | ✅ Más eficiente, menos parámetros, más natural |\n",
+        "\n",
+        "### 🔄 **CONFIGURACIÓN CATEGORICAL (alternativa)**\n",
+        "\n",
+        "| Aspecto | Configuración |\n",
+        "|---------|---------------|\n",
+        "| **Problema** | 2+ clases (extensible) |\n",
+        "| **Neuronas salida** | `Dense(2, activation='softmax')` |\n",
+        "| **Loss function** | `categorical_crossentropy` |\n",
+        "| **Etiquetas** | `[[1,0], [0,1], [1,0], ...]` (one-hot) |\n",
+        "| **Predicción** | `model.predict()` → `[[0.77,0.23], [0.13,0.87], ...]` |\n",
+        "| **Ventajas** | ✅ Extensible a más clases, probabilidades explícitas |\n",
+        "\n",
+        "### 🎯 **¿CUÁL USAR PARA COTORRAS?**\n",
+        "\n",
+        "**Para tu caso (cotorra vs no-cotorra): BINARY es mejor porque:**\n",
+        "\n",
+        "1. **Más eficiente**: 1 neurona vs 2 neuronas = menos parámetros\n",
+        "2. **Más natural**: Solo 2 clases, no necesitas extensibilidad  \n",
+        "3. **Más rápido**: Menos cómputo y memoria\n",
+        "4. **Salida intuitiva**: Probabilidad directa de ser cotorra\n",
+        "5. **Más simple**: Sin `to_categorical()`, etiquetas directas\n",
+        "\n",
+        "### ❌ **TU PROBLEMA ORIGINAL**\n",
+        "```python\n",
+        "# INCOMPATIBLE: binary loss + categorical data\n",
+        "model.add(Dense(2, activation='softmax'))\n",
+        "model.compile(loss='binary_crossentropy')  # ← Binary loss\n",
+        "y_train = to_categorical(y_train)           # ← Categorical data\n",
+        "# RESULTADO: No puede aprender correctamente\n",
+        "```\n",
+        "\n",
+        "### ✅ **SOLUCIÓN APLICADA**\n",
+        "```python\n",
+        "# COMPATIBLE: binary loss + binary data\n",
+        "model.add(Dense(1, activation='sigmoid'))   # ← 1 neurona\n",
+        "model.compile(loss='binary_crossentropy')  # ← Binary loss  \n",
+        "y_train = [0, 1, 0, 1, ...]               # ← Binary data\n",
+        "# RESULTADO: ¡Aprende correctamente!\n",
+        "```\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": ".venv",
+      "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.11.13"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}