{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Tarea: Selección de Modelos e Hyper-parameter Tuning\n", "\n", "**Universidad Galileo — IA para Aplicaciones del Mundo Real**\n", "**Tarea — Unidad de Buenas Prácticas (Cross-validation, Selección de Modelos y Tuning)**\n", "\n", "## Contexto\n", "\n", "Una empresa de servicios públicos digitaliza las **lecturas de medidores** que sus inspectores\n", "anotan a mano en boletas de papel. Hoy una persona teclea cada dígito, y el proceso es lento y\n", "caro. Quieren un modelo que lea esos dígitos automáticamente.\n", "\n", "El área de tecnología te dio una instrucción clara:\n", "\n", "> \"No queremos que nos traigas *un* modelo. Queremos que compares varias opciones de forma\n", "> ordenada, que dejes registrado **cada experimento que corriste** —con su configuración y sus\n", "> resultados— y que al final nos digas cuál elegiste y **por qué**, con un número honesto de qué\n", "> tan bien va a funcionar en producción. Si dentro de seis meses alguien pregunta por qué se eligió\n", "> ese modelo, la bitácora tiene que poder responderlo.\"\n", "\n", "## Tu tarea\n", "\n", "Vas a comparar **tres arquitecturas** implementadas en **tres frameworks distintos**\n", "(scikit-learn, TensorFlow y PyTorch), ajustar sus hiper-parámetros con **tres estrategias de\n", "búsqueda** distintas, registrar todo en una bitácora `.csv` y entregar un reporte final del modelo\n", "elegido.\n", "\n", "### El método que vas a seguir\n", "\n", "Usaremos el **split de tres vías** con un único conjunto de cross-validation\n", "(*holdout validation*), que es la forma tradicional:\n", "\n", "| Conjunto | Para qué sirve | Cuántas veces se usa |\n", "|---|---|---|\n", "| **train** | entrenar los parámetros del modelo | muchas |\n", "| **cross-validation** | comparar arquitecturas y elegir hiper-parámetros | muchas |\n", "| **test** | estimar el desempeño real | **una sola vez, al final** |\n", "\n", "> **Nota.** En el notebook 09 vimos que un solo cv-set es frágil y que **k-fold** promedia varios\n", "> para reducir esa varianza. Aquí trabajamos a propósito con el cv-set tradicional: es más simple,\n", "> es lo que se usa cuando entrenar es caro (como con redes neuronales), y deja ver con claridad\n", "> el flujo completo. En la conclusión te vamos a preguntar justamente por esa limitación.\n", "\n", "### Lo que ya está implementado para ti\n", "\n", "- Carga y exploración del dataset\n", "- El preprocesamiento (escalado), con el detalle de **dónde** se ajusta\n", "- Los constructores y entrenadores de los tres frameworks, con una interfaz común\n", "- La **bitácora**: una función que registra cada experimento en `experimentos.csv`\n", "- Todas las gráficas y el formato del reporte final\n", "\n", "### Lo que tienes que implementar tú\n", "\n", "1. El **split de tres vías**\n", "2. La **función de métricas** de evaluación\n", "3. **Grid Search**\n", "4. **Random Search**\n", "5. **Optimización Bayesiana** (Optuna)\n", "6. La **selección del modelo final** y su evaluación en el test-set\n", "7. Tu **conclusión** escrita\n", "\n", "Las celdas que te tocan están marcadas con `# TU CÓDIGO AQUÍ` y lanzan un `NotImplementedError`\n", "hasta que las completes. Después de cada una hay una celda de **verificación** que revisa el\n", "formato de lo que produjiste: si pasa, puedes seguir con confianza." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 0. Setup\n", "\n", "`optuna` no viene preinstalado en Colab, así que lo instalamos solo si hace falta.\n", "TensorFlow y PyTorch sí vienen incluidos." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager, possibly rendering your system unusable. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv. Use the --root-user-action option if you know what you are doing and want to suppress this warning.\u001b[0m\u001b[33m\n", "\u001b[0mNote: you may need to restart the kernel to use updated packages.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.12/dist-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", " from .autonotebook import tqdm as notebook_tqdm\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "numpy 2.1.0\n", "pandas 2.3.3\n", "tensorflow 2.21.0\n", "torch 2.10.0a0+b4e4ee81d3.nv25.12\n", "optuna 4.9.0\n" ] } ], "source": [ "try:\n", " import optuna\n", "except ImportError:\n", " %pip install -q optuna\n", " import optuna\n", "\n", "import os, json, random, time, itertools, warnings\n", "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "\n", "from sklearn.datasets import load_digits\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.preprocessing import StandardScaler\n", "from sklearn.ensemble import RandomForestClassifier\n", "\n", "import tensorflow as tf\n", "import torch\n", "import torch.nn as nn\n", "\n", "warnings.filterwarnings(\"ignore\")\n", "optuna.logging.set_verbosity(optuna.logging.WARNING)\n", "tf.get_logger().setLevel(\"ERROR\")\n", "\n", "# Semillas: que la tarea sea reproducible para ti y para quien la revise\n", "SEED = 42\n", "random.seed(SEED); np.random.seed(SEED)\n", "tf.random.set_seed(SEED); torch.manual_seed(SEED)\n", "\n", "# Paleta Okabe-Ito (segura para daltonismo), en el orden fijo del curso\n", "OKABE = [\"#0072B2\", \"#E69F00\", \"#009E73\", \"#CC79A7\", \"#D55E00\", \"#56B4E9\", \"#F0E442\"]\n", "\n", "print(\"numpy \", np.__version__)\n", "print(\"pandas \", pd.__version__)\n", "print(\"tensorflow \", tf.__version__)\n", "print(\"torch \", torch.__version__)\n", "print(\"optuna \", optuna.__version__)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Los datos (ya implementado)\n", "\n", "`load_digits` de scikit-learn: **1,797 imágenes** de dígitos escritos a mano, de 8×8 píxeles en\n", "escala de grises (valores de 0 a 16). Cada imagen se aplana en un vector de **64 características**,\n", "y la etiqueta es el dígito que representa (0 a 9).\n", "\n", "Es un dataset chico a propósito: permite correr decenas de experimentos en minutos, que es\n", "justo lo que necesita esta tarea." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "X: (1797, 64) (1,797 imágenes de 8x8 = 64 píxeles)\n", "y: (1797,) clases: [0 1 2 3 4 5 6 7 8 9]\n", "Rango de los píxeles: 0 a 16\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABC8AAAE9CAYAAAArl0gKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAQHJJREFUeJzt3XlcVnX+///nJciispnimoBYLriQqKRWUm6ZqZRp2iJoizWYYcuk35kUyzKnKXE0TfuUOLaNS6I5mamJtuikJo5ZmSlYWrlDLqkF5/dHN66fF4vyvhLOcXjcbzduNzm+X+f9us7yPud6cRaXZVmWAAAAAAAAHKqa3QkAAAAAAACcD8ULAAAAAADgaBQvAAAAAACAo1G8AAAAAAAAjkbxAgAAAAAAOBrFCwAAAAAA4GgULwAAAAAAgKNRvAAAAAAAAI5G8QIAAAAAADgaxQsAjuRyuZSWlmZ3GueVkZEhl8ul3Nxcu1NRQkKCEhISvIqNjIxUcnKyV7G5ublyuVzKyMjwKh6eWJ7eycrKksvlUlZWlt2pXDTF92mTbSM5OVmRkZEVlptT/ZFxEADgfBQvAFSaoi/7Zf1s3LjR7hRRiT799FOlpaUpLy/P7lQkSTNnzvyfLxr88MMPSktLU3Z2tt2pABWO7R0A/rf42p0AgKrnqaeeUlRUVInpzZo1c//7l19+ka8vQ9T/sk8//VQTJ05UcnKyQkND7U5HM2fOVJ06dby+CuVS8MMPP2jixImKjIxUbGys3enAQEREhH755RdVr17d7lQc64MPPvD4ne0dAP638M0AQKXr06ePOnTocN42AQEBlZQNgD/q9OnT8vPzU7VqXNBZUVwuly3jYmFhoc6ePevoMfnUqVOqUaOG/Pz87E4FAFCBOMsA4EilPfNi//79GjFihOrVqyd/f3/FxMTotdde82hTdO/7ggULNHHiRDVq1EhBQUG67bbblJ+frzNnzig1NVXh4eGqVauWhg8frjNnzpToe9SoUXrjjTfUvHlzBQQEKC4uTuvXry9X7jNnzlRMTIz8/f3VsGFDpaSklLg1YteuXRo4cKDq16+vgIAANW7cWEOGDFF+fv4F5z9nzhxFR0crMDBQnTp10kcffVRquzNnzmjChAlq1qyZ/P39dfnll+vPf/5zic9bXnl5eUpOTlZISIhCQ0OVlJRU6i0f//3vf5WcnKymTZsqICBA9evX14gRI3TkyBF3m7S0ND3++OOSpKioKPetQ0XPD5k7d65uuOEGhYeHy9/fX61atdKsWbNK9LV582b17t1bderUUWBgoKKiojRixAiPNoWFhUpPT1dMTIwCAgJUr149jRw5UseOHXO3iYyM1I4dO7Ru3Tp3Lk66d/7rr7/Wbbfdptq1aysgIEAdOnTQsmXLSrTLy8vTmDFjFBkZKX9/fzVu3FjDhg3T4cOHlZWVpY4dO0qShg8f7v6cRbfKlPXsk+LPESjax95++2399a9/VaNGjVSjRg39/PPPOnr0qB577DG1adNGtWrVUnBwsPr06aNt27aVmO/06dMVExOjGjVqKCwsTB06dNCbb755wWWxb98+JSYmqmbNmgoPD9eYMWPK3Kb/85//6MYbb1RISIhq1Kihbt266ZNPPrlgHxdjHJGk119/XXFxcQoMDFTt2rU1ZMgQff/99yXalWefLuuZF5mZmWrdurUCAgLUunVrLVmypNTPdPLkST366KO6/PLL5e/vr+bNm+vvf/+7LMvyaHfu+Fc0jr3//vvnXV4rVqzQtddeq5o1ayooKEh9+/bVjh07PNr89NNPGj58uBo3bix/f381aNBAAwYMKPHMoBUrVqhbt24KCgpScHCwOnbs6LFdJCQkqHXr1tqyZYuuu+461ahRQ//v//0/9/8VbasX2t4/+ugjDRo0SE2aNHGPj2PGjNEvv/ziVd7FlWccLMvF2P7KO4ZGRkbq5ptv1scff6xOnTopICBATZs21T//+c8Sbffs2aNBgwapdu3aqlGjhq6++mr9+9//vuDnAYCLhSsvAFS6/Px8HT582GOay+XSZZddVmbMgQMHdPXVV7tPrOvWrasVK1bonnvu0c8//6zU1FSP9pMnT1ZgYKDGjh2rb7/9VtOnT1f16tVVrVo1HTt2TGlpadq4caMyMjIUFRWl8ePHe8SvW7dO//rXvzR69Gj5+/tr5syZuvHGG/XZZ5+pdevWZeaZlpamiRMnqkePHnrwwQe1c+dOzZo1S5s2bdInn3yi6tWr6+zZs+rdu7fOnDmjhx56SPXr19f+/fu1fPly5eXlKSQkpMz5v/rqqxo5cqS6dOmi1NRU7dmzR/3791ft2rV1+eWXu9sVFhaqf//++vjjj3X//ferZcuW2r59u6ZOnapvvvlGmZmZZfZRGsuyNGDAAH388cd64IEH1LJlSy1ZskRJSUkl2q5atUp79uzR8OHDVb9+fe3YsUNz5szRjh07tHHjRrlcLt1666365ptv9NZbb2nq1KmqU6eOJKlu3bqSpFmzZikmJkb9+/eXr6+v3n33Xf3pT39SYWGhUlJSJEkHDx5Ur169VLduXY0dO1ahoaHKzc3VO++845HPyJEjlZGRoeHDh2v06NHKycnRjBkztHXrVvc6SU9P10MPPaRatWrpL3/5iySpXr16RsuoouzYsUNdu3ZVo0aNNHbsWNWsWVMLFixQYmKiFi9erFtuuUWSdOLECV177bX66quvNGLECLVv316HDx/WsmXLtG/fPrVs2VJPPfWUxo8fr/vvv1/XXnutJKlLly5e5fX000/Lz89Pjz32mM6cOSM/Pz99+eWXyszM1KBBgxQVFaUDBw5o9uzZ6tatm7788ks1bNhQkvTKK69o9OjRuu222/Twww/r9OnT+u9//6v//Oc/uuOOO8rs85dfflH37t313XffafTo0WrYsKHmz5+vDz/8sETbDz/8UH369FFcXJwmTJigatWqub/QffTRR+rUqdMFP+MfGUeeeeYZPfnkkxo8eLDuvfdeHTp0SNOnT9d1112nrVu3um+VKu8+XZoPPvhAAwcOVKtWrTR58mQdOXLE/UX7XJZlqX///lq7dq3uuecexcbGauXKlXr88ce1f/9+TZ06tcSyW7BggUaNGqU6deqc9+Gf8+fPV1JSknr37q0pU6bo1KlTmjVrlq655hpt3brVHTtw4EDt2LFDDz30kCIjI3Xw4EGtWrVK3333nbtNRkaGRowYoZiYGI0bN06hoaHaunWr3n//fY/t4siRI+rTp4+GDBmiu+66q9R99ULb+8KFC3Xq1Ck9+OCDuuyyy/TZZ59p+vTp2rdvnxYuXOieT3nyLk15xsEL+SPbX3nG0CLffvutbrvtNt1zzz1KSkrSa6+9puTkZMXFxSkmJkbS78fgLl266NSpUxo9erQuu+wyzZs3T/3799eiRYvc4xAAVCgLACrJ3LlzLUml/vj7+3u0lWRNmDDB/fs999xjNWjQwDp8+LBHuyFDhlghISHWqVOnLMuyrLVr11qSrNatW1tnz551txs6dKjlcrmsPn36eMR37tzZioiIKNG3JGvz5s3uaXv37rUCAgKsW265pcTnycnJsSzLsg4ePGj5+flZvXr1sgoKCtztZsyYYUmyXnvtNcuyLGvr1q2WJGvhwoXlXHK/O3v2rBUeHm7FxsZaZ86ccU+fM2eOJcnq1q2be9r8+fOtatWqWR999JHHPF5++WVLkvXJJ5+4p0VERFhJSUnn7TszM9OSZP3tb39zT/vtt9+sa6+91pJkzZ071z29aF2c66233rIkWevXr3dPe/755z2W37lKm0fv3r2tpk2bun9fsmSJJcnatGlTmXl/9NFHliTrjTfe8Jj+/vvvl5geExPjsQztkJOTU2J5du/e3WrTpo11+vRp97TCwkKrS5cu1hVXXOGeNn78eEuS9c4775SYb2FhoWVZlrVp06YS8y9S1nbQrVs3j+VStI81bdq0xHo6ffq0x7Zf9Jn8/f2tp556yj1twIABVkxMTKnL4HzS09MtSdaCBQvc006ePGk1a9bMkmStXbvWsqzfP+8VV1xh9e7d2/3ZLev37SoqKsrq2bPnefv5o+NIbm6u5ePjYz3zzDMe7bZv3275+vq6p5vs06VtG7GxsVaDBg2svLw897QPPvjAkuSRT9H+O2nSJI98brvtNsvlclnffvute5okq1q1ataOHTvOu4wsy7KOHz9uhYaGWvfdd5/H9J9++skKCQlxTz927JglyXr++efLnFdeXp4VFBRkxcfHW7/88ovH/527Drt162ZJsl5++eUS8yi+rZ5vey9tjJk8ebLlcrmsvXv3ljvvspR3HCzNxTiOlWcMtazf9/viOR08eNDy9/e3Hn30Ufe01NRUS5LHMeX48eNWVFSUFRkZWWK/B4CKwG0jACrdSy+9pFWrVnn8rFixosz2lmVp8eLF6tevnyzL0uHDh90/vXv3Vn5+vj7//HOPmGHDhnk82C4+Pl6WZZW4pSA+Pl7ff/+9fvvtN4/pnTt3VlxcnPv3Jk2aaMCAAVq5cqUKCgpKzXP16tU6e/asUlNTPe79v++++xQcHOy+vLboyoqVK1fq1KlT51tUHjZv3qyDBw/qgQce8Li3u+hWjnMtXLhQLVu2VIsWLTyW1w033CBJWrt2bbn7laT33ntPvr6+evDBB93TfHx89NBDD5VoGxgY6P736dOndfjwYV199dWSVGI9leXceRRdqdOtWzft2bPHfWtN0V+uly9frl9//bXU+SxcuFAhISHq2bOnx3KIi4tTrVq1jJdDZTt69Kg+/PBDDR48WMePH3fnf+TIEfXu3Vu7du3S/v37JUmLFy9Wu3btSv0LaHn+ymsqKSnJYz1Jkr+/v3vbLygo0JEjR1SrVi01b97cY92HhoZq37592rRpk1Gf7733nho0aKDbbrvNPa1GjRq6//77PdplZ2dr165duuOOO3TkyBH3cjt58qS6d++u9evXq7Cw8IL9eTuOvPPOOyosLNTgwYM9trv69evriiuucG93Jvt0cT/++KOys7OVlJTk0bZnz55q1apVieXm4+Oj0aNHe0x/9NFHZVlWifG3W7duJeZRmlWrVikvL09Dhw71+Jw+Pj6Kj493f87AwED5+fkpKyvL43at4vM6fvy4xo4dW+L5GsW3X39/fw0fPvyC+Z3PudvuyZMndfjwYXXp0kWWZWnr1q3lzrs88/d2HPwjx7HyjKFFWrVq5b4yRfr9CrjmzZtrz5497mnvvfeeOnXqpGuuucY9rVatWrr//vuVm5urL7/8slyfCQD+CG4bAVDpOnXqdMEHdp7r0KFDysvL05w5czRnzpxS2xw8eNDj9yZNmnj8XnRyX/wy7JCQEBUWFio/P9/jtpUrrriiRB9XXnmlTp06pUOHDql+/fol/n/v3r2SpObNm3tM9/PzU9OmTd3/HxUVpUceeUQvvvii3njjDV177bXq37+/7rrrrvN+YSmKL55b9erV1bRpU49pu3bt0ldffeW+DaO44svrQvbu3asGDRqoVq1aHtOLf1bp9y/cEydO1Ntvv12in/I800OSPvnkE02YMEEbNmwoUeDJz89XSEiIunXrpoEDB2rixImaOnWqEhISlJiYqDvuuEP+/v6Sfl8O+fn5Cg8PL7Uf0+VQ5NChQ2UWsS6kbt268vHxKVfbb7/9VpZl6cknn9STTz5ZapuDBw+qUaNG2r17twYOHOhVTt4o7Y1BhYWFmjZtmmbOnKmcnByPZXTu/vXEE09o9erV6tSpk5o1a6ZevXrpjjvuUNeuXc/b5969e9WsWbMSX2aLb4e7du2SpFJvayqSn5+vsLCw8/bn7Tiya9cuWZZV6jgiyf2F1GSfLq6sWEklikV79+5Vw4YNFRQU5NGuZcuWHvMqUtq6LU3Rci4qihYXHBws6fdiw5QpU/Too4+qXr16uvrqq3XzzTdr2LBh7rF09+7dknTe2/KKNGrU6A8/nPO7777T+PHjtWzZshKFiaJxqjx5l+VijIN/5DhWnjG0rH4kKSwszGO57N27V/Hx8SXanbsNlWfdAcAfQfECgOMV/YX0rrvuKvPLSNu2bT1+L+vLYVnTrWIPratoL7zwgpKTk7V06VJ98MEHGj16tCZPnqyNGzeWuF/dG4WFhWrTpo1efPHFUv//QvfS/xGDBw/Wp59+qscff1yxsbGqVauWCgsLdeONN5brr927d+9W9+7d1aJFC7344ou6/PLL5efnp/fee09Tp051z8PlcmnRokXauHGj3n33Xa1cuVIjRozQCy+8oI0bN7r7DQ8P1xtvvFFqX2UVdy6kY8eOJb7wlVdOTs5575U/V9Fnfeyxx9S7d+9S25z7iuE/oqyrMwoKCkrdb4pfdSFJzz77rJ588kmNGDFCTz/9tGrXrq1q1aopNTXVY923bNlSO3fu1PLly/X+++9r8eLFmjlzpsaPH6+JEyf+4c9S1Nfzzz9f5isyixfiSuPtOFJYWCiXy6UVK1aU2rY8fduptHVbmqLlPH/+/FK/zJ/7uuvU1FT169dPmZmZWrlypZ588klNnjxZH374oa666qoKya8sBQUF6tmzp44ePaonnnhCLVq0UM2aNbV//34lJyd7bKve5v1Hx0HJ++2vvGNoeecHAE5B8QKA49WtW1dBQUEqKChQjx49KqXPor8onuubb75RjRo1yvzCGxERIUnauXOnx19Nz549q5ycnBK5t2nTRm3atNFf//pXffrpp+ratatefvllTZo06bzz37Vrl8dfOn/99Vfl5OSoXbt27mnR0dHatm2bunfvflFuGYiIiNCaNWt04sQJjy9eO3fu9Gh37NgxrVmzRhMnTvR4eFxpy7OsvN59912dOXNGy5Yt8/iLYFm3eFx99dW6+uqr9cwzz+jNN9/UnXfeqbffflv33nuvoqOjtXr1anXt2vWCX3hMltMbb7xR4q0E5XWhv9ieq2g7ql69+gW3/ejoaH3xxRfnbXO+zxgWFlbq22P27t17wasAiixatEjXX3+9Xn31VY/peXl57oeyFqlZs6Zuv/123X777Tp79qxuvfVWPfPMMxo3blyZr+WMiIjQF198IcuyPD5L8e0wOjpa0u9/+a+sMaN4/5ZlKSoqSldeeWWZ7Uz26fPFFld8eURERGj16tU6fvy4x9UXX3/9tce8TBUt5/Dw8HIt5+joaD366KN69NFHtWvXLsXGxuqFF17Q66+/7p7XF198UeEFue3bt+ubb77RvHnzNGzYMPf0VatWGeddGpNxsCKYjqHlERERUWK7kv74NgQAJnjmBQDH8/Hx0cCBA7V48eJSv5wdOnToove5YcMGj8uuv//+ey1dulS9evUq869UPXr0kJ+fn/7xj394/MXq1VdfVX5+vvr27StJ+vnnn0s8Y6NNmzaqVq3aeV9j2qFDB9WtW1cvv/yyzp49656ekZFR4kvn4MGDtX//fr3yyisl5vPLL7/o5MmTZX/4Utx000367bffPF61V1BQoOnTp3u0K1o2xf9il56eXmKeNWvWlKQSuZc2j/z8fM2dO9ej3bFjx0r0U/RX9qLlOHjwYBUUFOjpp58u0f9vv/3m0XfNmjVL/fJemq5du6pHjx5e/ZT1xbw04eHhSkhI0OzZs/Xjjz+W+P9zt/2BAwdq27Ztpb4qs2g5lbXMpd+/oG3cuNFj21q+fHmpr/Ysi4+PT4l1snDhQvdzOYoUf12kn5+fWrVqJcuyynx+ifT7dvjDDz9o0aJF7mmnTp0qcTtZXFycoqOj9fe//10nTpwoMZ+KGDPOdeutt8rHx0cTJ04ssTwsy3J/fpN9urgGDRooNjZW8+bN87gNYdWqVSWeP3DTTTepoKBAM2bM8Jg+depUuVwu9enTx5uPqd69eys4OFjPPvtsqeutaDmfOnVKp0+f9vi/6OhoBQUFuffVXr16KSgoSJMnTy7R1tsrAEzGGMuyNG3aNI925cm7NCbjYEUo7xhq4qabbtJnn32mDRs2uKedPHlSc+bMUWRkZLmekQIAfxRXXgCodCtWrHD/teZcXbp0KfMvvM8995zWrl2r+Ph43XfffWrVqpWOHj2qzz//XKtXr9bRo0cvao6tW7dW7969PV6VKum8l7TXrVtX48aN08SJE3XjjTeqf//+2rlzp2bOnKmOHTvqrrvukvT7awhHjRqlQYMG6corr9Rvv/2m+fPnu4s0ZalevbomTZqkkSNH6oYbbtDtt9+unJwczZ07t8Ryu/vuu7VgwQI98MADWrt2rbp27aqCggJ9/fXXWrBggVauXGn03JF+/fqpa9euGjt2rHJzc9WqVSu98847Je7dDg4O1nXXXae//e1v+vXXX9WoUSN98MEHysnJKTHPogei/uUvf9GQIUNUvXp19evXT7169ZKfn5/69eunkSNH6sSJE3rllVcUHh7u8QV+3rx5mjlzpm655RZFR0fr+PHjeuWVVxQcHKybbrpJ0u8PHhw5cqQmT56s7Oxs9erVS9WrV9euXbu0cOFCTZs2zf3wx7i4OM2aNUuTJk1Ss2bNFB4eXua9/JXppZde0jXXXKM2bdrovvvuU9OmTXXgwAFt2LBB+/bt07Zt2yRJjz/+uBYtWqRBgwZpxIgRiouL09GjR7Vs2TK9/PLLateunaKjoxUaGqqXX35ZQUFBqlmzpuLj4xUVFaV7771XixYt0o033qjBgwdr9+7dHn8RL4+bb75ZTz31lIYPH64uXbpo+/bteuONN0psn7169VL9+vXVtWtX1atXT1999ZVmzJihvn37lnguw7nuu+8+zZgxQ8OGDdOWLVvUoEEDzZ8/XzVq1PBoV61aNf3f//2f+vTpo5iYGA0fPlyNGjXS/v37tXbtWgUHB+vdd981WAtmoqOjNWnSJI0bN065ublKTExUUFCQcnJytGTJEt1///167LHHjPbp0kyePFl9+/bVNddcoxEjRujo0aOaPn26YmJiPIo2/fr10/XXX6+//OUvys3NVbt27fTBBx9o6dKlSk1NNVrH5woODtasWbN09913q3379hoyZIjq1q2r7777Tv/+97/VtWtXzZgxQ9988426d++uwYMHq1WrVvL19dWSJUt04MABDRkyxD2vqVOn6t5771XHjh11xx13KCwsTNu2bdOpU6c0b9484/zK2t5btGih6OhoPfbYY9q/f7+Cg4O1ePHiEs++KE/eZS2X8o6DFaG8Y6iJsWPH6q233lKfPn00evRo1a5dW/PmzVNOTo4WL17s8ZBqAKgwlfJOEwCwzv+qVBV7nZ2KvSrVsizrwIEDVkpKinX55Zdb1atXt+rXr291797dmjNnjrtN0Svmir+GtKjv4q/VnDBhgiXJOnTokEffKSkp1uuvv25dccUVlr+/v3XVVVe5X8NYfJ7FX/U5Y8YMq0WLFlb16tWtevXqWQ8++KB17Ngx9//v2bPHGjFihBUdHW0FBARYtWvXtq6//npr9erV5VqOM2fOtKKioix/f3+rQ4cO1vr160u8ItCyfn8N45QpU6yYmBjL39/fCgsLs+Li4qyJEyda+fn57nbleVWqZVnWkSNHrLvvvtsKDg62QkJCrLvvvtv92tdz192+ffusW265xQoNDbVCQkKsQYMGWT/88EOp6/Tpp5+2GjVqZFWrVs1jWS5btsxq27atFRAQYEVGRlpTpkyxXnvtNY82n3/+uTV06FCrSZMmlr+/vxUeHm7dfPPNHq+4LTJnzhwrLi7OCgwMtIKCgqw2bdpYf/7zn60ffvjB3eann36y+vbtawUFBZV4TWVlKe11mJZlWbt377aGDRtm1a9f36pevbrVqFEj6+abb7YWLVrk0e7IkSPWqFGjrEaNGll+fn5W48aNraSkJI9XDC9dutRq1aqV5evrW6KvF154wWrUqJHl7+9vde3a1dq8eXOZr0ot7VW/p0+fth599FGrQYMGVmBgoNW1a1drw4YNJeYxe/Zs67rrrrMuu+wyy9/f34qOjrYef/xxj+2yLHv37rX69+9v1ahRw6pTp4718MMPu199W3wf3bp1q3Xrrbe6+4mIiLAGDx5srVmz5rx9XIxxxLIsa/HixdY111xj1axZ06pZs6bVokULKyUlxdq5c6dHu/Ls02VtG4sXL7Zatmxp+fv7W61atbLeeecdKykpqcSrM48fP26NGTPGatiwoVW9enXriiuusJ5//nmP15Ba1v8//plYu3at1bt3byskJMQKCAiwoqOjreTkZPe+ePjwYSslJcVq0aKFVbNmTSskJMSKj4/3eOVtkWXLllldunSxAgMDreDgYKtTp07WW2+95f7/bt26lfma3dLGwbK29y+//NLq0aOHVatWLatOnTrWfffdZ23bts2jjUnexZmMg6Utzz+6/ZVnDLWs38f/vn37lsihtGW5e/du67bbbrNCQ0OtgIAAq1OnTtby5csvuCwA4GJxWRZP4wHgLAUFBfL19dXTTz+tv/71r5Xev8vlUkpKSolLrAEAAADYg2u8ADhO0WWtxR/wBwAAAKBq4pkXABxl0aJF+uc//ymXy6Xrr7/e7nQAAAAAOADFCwCO8uc//1kul0uvvvqqmjdvbnc6AAAAAByAZ14AAAAAAABH45kXAAAAAADA0SheAAAAAAAAR6N4AQAAAAAAHI3iBQAAAAAAcDSKFwAAAAAAwNEoXgAAAAAAAEejeAEAAAAAAByN4gUAAAAAAHA0ihcAAAAAAMDRKF4AAAAAAABHo3gBAAAAAAAcjeIFAAAAAABwNIoXAAAAAADA0SheAAAAAAAAR6N4AQAAAAAAHI3iBQAAAAAAcDSKFwAAAAAAwNEoXgAAAAAAAEejeAEAAAAAAByN4gUAAAAAAHA0ihcAAAAAAMDRKF4AAAAAAABHo3gBAAAAAAAcjeIFAAAAAABwNIoXAAAAAADA0SheAAAAAAAAR6N4AQAAAAAAHI3iBQAAAAAAcDSKFwAAAAAAwNEoXgAAAAAAAEejeAEAAAAAAByN4gUAAAAAAHA0ihcAAAAAAMDRKF4AAAAAAABHo3gBAAAAAAAcrcoVL1566SVFRkYqICBA8fHx+uyzz+xOCQ6wfv169evXTw0bNpTL5VJmZqbdKcEhJk+erI4dOyooKEjh4eFKTEzUzp077U4LDjFr1iy1bdtWwcHBCg4OVufOnbVixQq704IDPffcc3K5XEpNTbU7FThAWlqaXC6Xx0+LFi3sTgsOsn//ft1111267LLLFBgYqDZt2mjz5s12pwWbRUZGlhg7XC6XUlJS7E6tUlSp4sW//vUvPfLII5owYYI+//xztWvXTr1799bBgwftTg02O3nypNq1a6eXXnrJ7lTgMOvWrVNKSoo2btyoVatW6ddff1WvXr108uRJu1ODAzRu3FjPPfectmzZos2bN+uGG27QgAEDtGPHDrtTg4Ns2rRJs2fPVtu2be1OBQ4SExOjH3/80f3z8ccf250SHOLYsWPq2rWrqlevrhUrVujLL7/UCy+8oLCwMLtTg802bdrkMW6sWrVKkjRo0CCbM6scLsuyLLuTqCzx8fHq2LGjZsyYIUkqLCzU5Zdfroceekhjx461OTs4hcvl0pIlS5SYmGh3KnCgQ4cOKTw8XOvWrdN1111ndzpwoNq1a+v555/XPffcY3cqcIATJ06offv2mjlzpiZNmqTY2Filp6fbnRZslpaWpszMTGVnZ9udChxo7Nix+uSTT/TRRx/ZnQocLjU1VcuXL9euXbvkcrnsTqfCVZkrL86ePastW7aoR48e7mnVqlVTjx49tGHDBhszA3Apyc/Pl/T7F1TgXAUFBXr77bd18uRJde7c2e504BApKSnq27evx/kHIEm7du1Sw4YN1bRpU91555367rvv7E4JDrFs2TJ16NBBgwYNUnh4uK666iq98sordqcFhzl79qxef/11jRgxokoULqQqVLw4fPiwCgoKVK9ePY/p9erV008//WRTVgAuJYWFhUpNTVXXrl3VunVru9OBQ2zfvl21atWSv7+/HnjgAS1ZskStWrWyOy04wNtvv63PP/9ckydPtjsVOEx8fLwyMjL0/vvva9asWcrJydG1116r48eP250aHGDPnj2aNWuWrrjiCq1cuVIPPvigRo8erXnz5tmdGhwkMzNTeXl5Sk5OtjuVSuNrdwIAcKlISUnRF198wX3J8NC8eXNlZ2crPz9fixYtUlJSktatW0cBo4r7/vvv9fDDD2vVqlUKCAiwOx04TJ8+fdz/btu2reLj4xUREaEFCxZwyxlUWFioDh066Nlnn5UkXXXVVfriiy/08ssvKykpyebs4BSvvvqq+vTpo4YNG9qdSqWpMlde1KlTRz4+Pjpw4IDH9AMHDqh+/fo2ZQXgUjFq1CgtX75ca9euVePGje1OBw7i5+enZs2aKS4uTpMnT1a7du00bdo0u9OCzbZs2aKDBw+qffv28vX1la+vr9atW6d//OMf8vX1VUFBgd0pwkFCQ0N15ZVX6ttvv7U7FThAgwYNShTAW7Zsya1FcNu7d69Wr16te++91+5UKlWVKV74+fkpLi5Oa9ascU8rLCzUmjVruDcZQJksy9KoUaO0ZMkSffjhh4qKirI7JThcYWGhzpw5Y3casFn37t21fft2ZWdnu386dOigO++8U9nZ2fLx8bE7RTjIiRMntHv3bjVo0MDuVOAAXbt2LfFa9m+++UYRERE2ZQSnmTt3rsLDw9W3b1+7U6lUVeq2kUceeURJSUnq0KGDOnXqpPT0dJ08eVLDhw+3OzXY7MSJEx5/7cjJyVF2drZq166tJk2a2JgZ7JaSkqI333xTS5cuVVBQkPsZOSEhIQoMDLQ5O9ht3Lhx6tOnj5o0aaLjx4/rzTffVFZWllauXGl3arBZUFBQiWfj1KxZU5dddhnPzIEee+wx9evXTxEREfrhhx80YcIE+fj4aOjQoXanBgcYM2aMunTpomeffVaDBw/WZ599pjlz5mjOnDl2pwYHKCws1Ny5c5WUlCRf3yr1db5qFS9uv/12HTp0SOPHj9dPP/2k2NhYvf/++yUe4omqZ/Pmzbr++uvdvz/yyCOSpKSkJGVkZNiUFZxg1qxZkqSEhASP6XPnzq1SD0hC6Q4ePKhhw4bpxx9/VEhIiNq2bauVK1eqZ8+edqcGwMH27dunoUOH6siRI6pbt66uueYabdy4UXXr1rU7NThAx44dtWTJEo0bN05PPfWUoqKilJ6erjvvvNPu1OAAq1ev1nfffacRI0bYnUqlc1mWZdmdBAAAAAAAQFmqzDMvAAAAAADApYniBQAAAAAAcDSKFwAAAAAAwNEoXgAAAAAAAEejeAEAAAAAAByN4gUAAAAAAHA0ihcAAAAAAMDRfO1OoLiFCxcaxzzxxBNG7Xv27Gncx3PPPWccExYWZhyDiy8hIcGofV5ennEfaWlpxjGJiYnGMbi4srKyjNp7s85iY2ONY0zzwoVNmTLFOGbs2LFG7aOiooz72LJli3EMxxZnMD1WJCcnG/eRmZlpHIOLy/QcQpIiIyON2mdkZBj3gUtXZZyXZmdnG8fg4kpPTzeOMV3X3hwjtm3bZhwTEhJiHJObm2scExoaesE2XHkBAAAAAAAcjeIFAAAAAABwNIoXAAAAAADA0SheAAAAAAAAR6N4AQAAAAAAHI3iBQAAAAAAcDSKFwAAAAAAwNEoXgAAAAAAAEejeAEAAAAAAByN4gUAAAAAAHA0ihcAAAAAAMDRKF4AAAAAAABH87U7geKeeOIJ45icnByj9seOHTPuo3bt2sYxCxYsMI4ZNGiQcQzOLzQ01Kj9unXrjPvIysoyjklMTDSOQdmys7ONY66//nqj9iEhIcZ95ObmGsfg/MaOHWsc4814PHv2bKP2I0eONO5jy5YtxjE9evQwjsHFl5GRYdQ+Nja2QvJAxfJmDDc9j5g3b55xHxEREcYxHI8uvszMTOMY0+1jwoQJxn3g0mT6nSU9Pd24D29i8vLyjGNMP0t5ceUFAAAAAABwNIoXAAAAAADA0SheAAAAAAAAR6N4AQAAAAAAHI3iBQAAAAAAcDSKFwAAAAAAwNEoXgAAAAAAAEejeAEAAAAAAByN4gUAAAAAAHA0ihcAAAAAAMDRKF4AAAAAAABHo3gBAAAAAAAczbciZ75lyxbjmJycHOOY3bt3G7Vv2rSpcR89e/Y0jvHm8w8aNMg4pirJzs42jsnKyrroeRQXGxtb4X3g/DIzM41j2rVrZ9Q+MTHRuI+JEycax+D87r//fuOYJ554wjgmLi7OqH1UVJRxHz169DCOwcWXl5dnHJORkWHUPjU11biP3Nxc4xhvREZGVko/l6LQ0FDjmL179xq1DwkJMe4jISHBOMab7dybz1+VpKWlVXgf3px7wH7ejPmmvNn+vDmuVMZ3qfLiygsAAAAAAOBoFC8AAAAAAICjUbwAAAAAAACORvECAAAAAAA4GsULAAAAAADgaBQvAAAAAACAo1G8AAAAAAAAjkbxAgAAAAAAOBrFCwAAAAAA4GgULwAAAAAAgKNRvAAAAAAAAI5G8QIAAAAAADiab0XO/NixY8Yx7du3N45p2rSpcYypuLi4Cu+jqklPTzeOSUtLM47Jz883jjGVkJBQ4X3g/FJTU41jIiMjK7yPAQMGGMfg/LwZ8/fs2WMck5OTY9S+R48exn14c5wMCwszjsH5ZWRkGMfk5uYatU9OTjbuw5sxJzQ01DjGm2NrVWF6nJCkbdu2GbX35jwlNjbWOMabbQPnl5eXZxzTrl07o/berGtcXFlZWZUSY8qb71LeyMzMNI7x5phXHlx5AQAAAAAAHI3iBQAAAAAAcDSKFwAAAAAAwNEoXgAAAAAAAEejeAEAAAAAAByN4gUAAAAAAHA0ihcAAAAAAMDRKF4AAAAAAABHo3gBAAAAAAAcjeIFAAAAAABwNIoXAAAAAADA0XwrcubHjh0zjunZs2cFZPLHefNZwsLCKiCT/x2pqanGMcnJycYxlbEe8vLyKryPqsSb5Zmenm4ck5mZaRxjKiMjo8L7wIU1bdrUOObo0aNG7Xv06GHchzcxq1evNo6pSscjb/brMWPGGMckJSUZx5iaNm2acczcuXMrIJOqy5vtKSsry6h9dna2cR/ebLPe8OZcrSrx5nwlMjLSqL035zeJiYnGMaZ5VSXeLBtv9mvTscMb3oxpCQkJFz0Pb3HlBQAAAAAAcDSKFwAAAAAAwNEoXgAAAAAAAEejeAEAAAAAAByN4gUAAAAAAHA0ihcAAAAAAMDRKF4AAAAAAABHo3gBAAAAAAAcjeIFAAAAAABwNIoXAAAAAADA0SheAAAAAAAAR6N4AQAAAAAAHM23ImceFhZmHLNly5YKyMTTsWPHjGM2b95sHDN48GDjGFyasrOzjWNiY2Mveh7/K9LS0oxjpk2bdvETKWbJkiXGMaGhoRc/EVQK02PY6tWrjfsYOXKkccyUKVOMY5577jnjmEuVN/tcSEiIccy8efOM2ntznPBGYmJipfSDsiUkJNidQqlyc3PtTuF/TmRkpHHMunXrjNrn5eUZ9zFmzBjjmK1btxrHVJVzWW/Wc2ZmpnGMy+Uyau/NealTx6fy4soLAAAAAADgaBQvAAAAAACAo1G8AAAAAAAAjkbxAgAAAAAAOBrFCwAAAAAA4GgULwAAAAAAgKNRvAAAAAAAAI5G8QIAAAAAADgaxQsAAAAAAOBoFC8AAAAAAICjUbwAAAAAAACORvECAAAAAAA4mm9Fzrxp06bGMZs3bzaOWbhwYYW299YTTzxRKf0A/2uSk5ONY7Kysoxjtm3bZtT+lltuMe5jwIABxjHefP7ExETjmKpk7NixxjE9evQwan/s2DHjPlatWmUcM3jwYOOYqiQhIcE4Ji8vzzgmOzvbqL03eSUlJRnHhIaGGsegbJmZmcYxpusgLS3NuA9vcJy4+Lw5Xo8ZM8aofWRkpHEfubm5xjHebOuxsbHGMVVFamqqcUxISIhRe2+OK5c6rrwAAAAAAACORvECAAAAAAA4GsULAAAAAADgaBQvAAAAAACAo1G8AAAAAAAAjkbxAgAAAAAAOBrFCwAAAAAA4GgULwAAAAAAgKNRvAAAAAAAAI5G8QIAAAAAADgaxQsAAAAAAOBoFC8AAAAAAICj+VbkzJs2bWocM2XKFOOYJ554wqh9hw4djPvYsmWLcQwuvtDQUOOYAQMGGLVfunSpcR9ZWVnGMcnJycYxVUVsbKxxTHZ2doXHpKWlGffhzfYUGRlpHJOYmGgcU5WEhYUZx9x///0VkImnwYMHG8fMnj27AjKBKdPjUX5+vnEfHCfs583xfdq0aRc/kWKSkpKMYxISEi5+IlWcN/tobm6uUfuMjAzjPrxZ15xHXFzejB2m69qb70WXOq68AAAAAAAAjkbxAgAAAAAAOBrFCwAAAAAA4GgULwAAAAAAgKNRvAAAAAAAAI5G8QIAAAAAADgaxQsAAAAAAOBoFC8AAAAAAICjUbwAAAAAAACORvECAAAAAAA4GsULAAAAAADgaBQvAAAAAACAo7ksy7LsTgIAAAAAAKAsVebKi4KCAj355JOKiopSYGCgoqOj9fTTT4vaDSTp+PHjSk1NVUREhAIDA9WlSxdt2rTJ7rTgIC+99JIiIyMVEBCg+Ph4ffbZZ3anBAdYv369+vXrp4YNG8rlcikzM9PulOAQkydPVseOHRUUFKTw8HAlJiZq586ddqcFh5g1a5batm2r4OBgBQcHq3PnzlqxYoXdacGBnnvuOblcLqWmptqdChwgLS1NLpfL46dFixZ2p1VpqkzxYsqUKZo1a5ZmzJihr776SlOmTNHf/vY3TZ8+3e7U4AD33nuvVq1apfnz52v79u3q1auXevToof3799udGhzgX//6lx555BFNmDBBn3/+udq1a6fevXvr4MGDdqcGm508eVLt2rXTSy+9ZHcqcJh169YpJSVFGzdu1KpVq/Trr7+qV69eOnnypN2pwQEaN26s5557Tlu2bNHmzZt1ww03aMCAAdqxY4fdqcFBNm3apNmzZ6tt27Z2pwIHiYmJ0Y8//uj++fjjj+1OqdJUmdtGbr75ZtWrV0+vvvqqe9rAgQMVGBio119/3cbMYLdffvlFQUFBWrp0qfr27eueHhcXpz59+mjSpEk2ZgcniI+PV8eOHTVjxgxJUmFhoS6//HI99NBDGjt2rM3ZwSlcLpeWLFmixMREu1OBAx06dEjh4eFat26drrvuOrvTgQPVrl1bzz//vO655x67U4EDnDhxQu3bt9fMmTM1adIkxcbGKj093e60YLO0tDRlZmYqOzvb7lRsUWWuvOjSpYvWrFmjb775RpK0bds2ffzxx+rTp4/NmcFuv/32mwoKChQQEOAxPTAwsEpVMlG6s2fPasuWLerRo4d7WrVq1dSjRw9t2LDBxswAXEry8/Ml/f4FFThXQUGB3n77bZ08eVKdO3e2Ox04REpKivr27etx/gFI0q5du9SwYUM1bdpUd955p7777ju7U6o0vnYnUFnGjh2rn3/+WS1atJCPj48KCgr0zDPP6M4777Q7NdgsKChInTt31tNPP62WLVuqXr16euutt7RhwwY1a9bM7vRgs8OHD6ugoED16tXzmF6vXj19/fXXNmUF4FJSWFio1NRUde3aVa1bt7Y7HTjE9u3b1blzZ50+fVq1atXSkiVL1KpVK7vTggO8/fbb+vzzz3n+GkqIj49XRkaGmjdvrh9//FETJ07Utddeqy+++EJBQUF2p1fhqkzxYsGCBXrjjTf05ptvKiYmRtnZ2UpNTVXDhg2VlJRkd3qw2fz58zVixAg1atRIPj4+at++vYYOHaotW7bYnRoA4BKXkpKiL774gqv54KF58+bKzs5Wfn6+Fi1apKSkJK1bt44CRhX3/fff6+GHH9aqVatKXBUMnHvXQNu2bRUfH6+IiAgtWLCgStxyVmWKF48//rjGjh2rIUOGSJLatGmjvXv3avLkyRQvoOjoaK1bt04nT57Uzz//rAYNGuj2229X06ZN7U4NNqtTp458fHx04MABj+kHDhxQ/fr1bcoKwKVi1KhRWr58udavX6/GjRvbnQ4cxM/Pz32FZ1xcnDZt2qRp06Zp9uzZNmcGO23ZskUHDx5U+/bt3dMKCgq0fv16zZgxQ2fOnJGPj4+NGcJJQkNDdeWVV+rbb7+1O5VKUWWeeXHq1ClVq+b5cX18fFRYWGhTRnCimjVrqkGDBjp27JhWrlypAQMG2J0SbObn56e4uDitWbPGPa2wsFBr1qzh3mQAZbIsS6NGjdKSJUv04YcfKioqyu6U4HCFhYU6c+aM3WnAZt27d9f27duVnZ3t/unQoYPuvPNOZWdnU7iAhxMnTmj37t1q0KCB3alUiipz5UW/fv30zDPPqEmTJoqJidHWrVv14osvasSIEXanBgdYuXKlLMtS8+bN9e233+rxxx9XixYtNHz4cLtTgwM88sgjSkpKUocOHdSpUyelp6fr5MmTbB/QiRMnPP7akZOTo+zsbNWuXVtNmjSxMTPYLSUlRW+++aaWLl2qoKAg/fTTT5KkkJAQBQYG2pwd7DZu3Dj16dNHTZo00fHjx/Xmm28qKytLK1eutDs12CwoKKjEs3Fq1qypyy67jGfmQI899pj69euniIgI/fDDD5owYYJ8fHw0dOhQu1OrFFWmeDF9+nQ9+eST+tOf/qSDBw+qYcOGGjlypMaPH293anCA/Px8jRs3Tvv27VPt2rU1cOBAPfPMM6pevbrdqcEBbr/9dh06dEjjx4/XTz/9pNjYWL3//vslHuKJqmfz5s26/vrr3b8/8sgjkqSkpCRlZGTYlBWcYNasWZKkhIQEj+lz585VcnJy5ScERzl48KCGDRumH3/8USEhIWrbtq1Wrlypnj172p0aAAfbt2+fhg4dqiNHjqhu3bq65pprtHHjRtWtW9fu1CqFy7Isy+4kAAAAAAAAylJlnnkBAAAAAAAuTRQvAAAAAACAo1G8AAAAAAAAjkbxAgAAAAAAOBrFCwAAAAAA4GgULwAAAAAAgKNRvAAAAAAAAI5G8QIAAAAAADiar90JFJeammock5mZadQ+OTnZuA9v8goNDTWOwfklJiYax+Tl5Rm1z8rKMu4D9jNdz5KUlpZm1D4jI8O4j4SEBOMY0zENzhAZGWkc481xwpsxiuPR+Xmzz6Wnp1d4H6y3iys3N9c4xnQ9S+bHCm/WszfnQ96c/8bGxhrH4PxMzz282Qa92dYZb8pWGccIyfxcdtu2bcZ9eCMnJ8c4xptzovLgygsAAAAAAOBoFC8AAAAAAICjUbwAAAAAAACORvECAAAAAAA4GsULAAAAAADgaBQvAAAAAACAo1G8AAAAAAAAjkbxAgAAAAAAOBrFCwAAAAAA4GgULwAAAAAAgKNRvAAAAAAAAI7ma3cCxWVnZ1d4HxkZGcYxWVlZlRJTleTm5hrHLF269OInUozL5TKOadeunXFMZWzrVUlycrJxjOn2NGHCBOM+vBlvvInx5vPj/DIzM43a792717gPb2Ly8vKMY0JDQ41jqhJv9h/TZerNfp2ammocg7J5c97hzbmc6XrzZp+eNm2acYw340BsbKxxTFXizbozHQsiIyON+/AGx5ayeTN+r1u3zjgmJCTEqL0356UJCQnGMZW1DZYHV14AAAAAAABHo3gBAAAAAAAcjeIFAAAAAABwNIoXAAAAAADA0SheAAAAAAAAR6N4AQAAAAAAHI3iBQAAAAAAcDSKFwAAAAAAwNEoXgAAAAAAAEejeAEAAAAAAByN4gUAAAAAAHA0ihcAAAAAAMDRfO1OoLjY2FjjmMjISKP2GRkZxn2EhoYax2RlZRnHJCQkGMdcqvLy8iqln27duhm1N92eJO/WNcqWm5trHLN06VLjmKSkJKP2aWlpxn14s51nZ2cbx+DiS01NrfA+TMcnybsxCudXGeN+YmKicR+VsQ1WJd6cY3kzHpueZ3pzbAkJCTGO8WYbxPl5s4+anhdkZmYa9+HNmObN/uFNbpcib76fejN2mPbjzfbnzXdaJ+HKCwAAAAAA4GgULwAAAAAAgKNRvAAAAAAAAI5G8QIAAAAAADgaxQsAAAAAAOBoFC8AAAAAAICjUbwAAAAAAACORvECAAAAAAA4GsULAAAAAADgaBQvAAAAAACAo1G8AAAAAAAAjkbxAgAAAAAAOJqv3QkUl5ycbBxz1VVXGbXPzc017iM0NNQ4JjIy0jimKqms5ZOZmWnUPjEx0biPvLw84xiUzZv9zRvejDemKuuzVCXe7G+pqanGMXv37jWOgf28OcbHxsYax5ju297khUuT6XmHN7Kzs41jOC89v/T0dOOYefPmGcdMnTrVqL036y0/P984xptxEGXz5hzCNMabdXapH4u48gIAAAAAADgaxQsAAAAAAOBoFC8AAAAAAICjUbwAAAAAAACORvECAAAAAAA4GsULAAAAAADgaBQvAAAAAACAo1G8AAAAAAAAjkbxAgAAAAAAOBrFCwAAAAAA4GgULwAAAAAAgKP52p1AcXl5eRXex7p164xjcnJyjGMiIyONY6qS0NBQ45h27doZx4SFhRm1f/jhh437yM7ONo7Jzc01jqkq25Q3yxNVhzf7jjcxERERRu337t1r3EdsbKxxDM7Pm3EyLS3toudRnDfbhzfnRN4cW3FxpaenG7X3ZhxITU01jsnMzDSOqUq8OU54IyMjw6i96fbkLY5HZfNmf6uMc/bhw4dXeB9Ow5UXAAAAAADA0SheAAAAAAAAR6N4AQAAAAAAHI3iBQAAAAAAcDSKFwAAAAAAwNEoXgAAAAAAAEejeAEAAAAAAByN4gUAAAAAAHA0ihcAAAAAAMDRKF4AAAAAAABHo3gBAAAAAAAcjeIFAAAAAABwNJdlWVZFzTw7O9s45qqrrjKOmTBhglH73Nxc4z68+SyZmZnGMZGRkcYxOD/TdRcbG2vcR2pqqnGMN9uhN9vUpSgvL884JiwszDhmyZIlRu0TEhKM+0hOTjaOSUtLM47xZrvF+Znub7fccotxHyEhIcYx3uwfuPgyMjKM2ntznGBdVw3enA94M+Z7cw7hzXHvUuXN/ubNfm26HvLz8437iIiIMI7xZjvExVUZ5x1bt241jnHSOSZXXgAAAAAAAEejeAEAAAAAAByN4gUAAAAAAHA0ihcAAAAAAMDRKF4AAAAAAABHo3gBAAAAAAAcjeIFAAAAAABwNIoXAAAAAADA0SheAAAAAAAAR6N4AQAAAAAAHI3iBQAAAAAAcDSKFwAAAAAAwNF8K3LmkZGRxjEhISHGMampqUbtc3Nzjfu46qqrjGMyMjKMY9LS0oxjcH6xsbFG7U23J8m7dZ2ZmWkcU1WEhoYax3Tr1s04Jj093ai9N+vMm89ius2iYniz7pzYBy7Mm3F/2rRpRu0r4/xG8m6bSk5ONo7x5hzPbnl5ecYxWVlZFd6P6bFIkvLz841jvDn/rUq82Xe8Of8z3T7CwsKM+0hISDCOQdkqa+wwHYvbtWtn3Melfo7JlRcAAAAAAMDRKF4AAAAAAABHo3gBAAAAAAAcjeIFAAAAAABwNIoXAAAAAADA0SheAAAAAAAAR6N4AQAAAAAAHI3iBQAAAAAAcDSKFwAAAAAAwNEoXgAAAAAAAEejeAEAAAAAAByN4gUAAAAAAHA034qceWhoqHFMQkKCcUxYWJhR+5CQEOM+BgwYYByTmppqHIPz82aZZmdnG7XPy8sz7iMrK8s4JjY21jgGZcvMzDSOMd2eTLclScrIyDCOgTOY7qPt2rUz7mPbtm3GMd6MUd4cj6uS5ORk45jc3Fyj9t6M+d6Ma5V17hUZGWkcYzdv9p309PSLnsfF4M15qTfbOS4+03MPb763sK4vLm/O/7xZB/n5+UbtvTlGXOq48gIAAAAAADgaxQsAAAAAAOBoFC8AAAAAAICjUbwAAAAAAACORvECAAAAAAA4GsULAAAAAADgaBQvAAAAAACAo1G8AAAAAAAAjkbxAgAAAAAAOBrFCwAAAAAA4GgULwAAAAAAgKNRvAAAAAAAAI7msizLsjsJAAAAAACAsnDlBQAAAAAAcDSKFwAAAAAAwNEoXgAAAAAAAEejeAEAAAAAAByN4gUAAAAAAHA0ihcAAAAAAMDRKF4AAAAAAABHo3gBAAAAAAAcjeIFAAAAAABwtP8P05+veVHLDUIAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "digits = load_digits()\n", "X, y = digits.data, digits.target\n", "\n", "print(f\"X: {X.shape} (1,797 imágenes de 8x8 = 64 píxeles)\")\n", "print(f\"y: {y.shape} clases: {np.unique(y)}\")\n", "print(f\"Rango de los píxeles: {X.min():.0f} a {X.max():.0f}\")\n", "\n", "fig, axes = plt.subplots(2, 8, figsize=(11, 3))\n", "for ax, img, lab in zip(axes.ravel(), digits.images, y):\n", " ax.imshow(img, cmap=\"gray_r\")\n", " ax.set_title(str(lab), fontsize=10)\n", " ax.axis(\"off\")\n", "fig.suptitle(\"Ejemplos del dataset — lecturas de medidor escritas a mano\", y=1.04)\n", "plt.tight_layout(); plt.show()\n", "\n", "conteo = pd.Series(y).value_counts().sort_index()\n", "fig, ax = plt.subplots(figsize=(7, 2.6))\n", "ax.bar(conteo.index, conteo.values, color=OKABE[0])\n", "ax.set_xlabel(\"dígito\"); ax.set_ylabel(\"imágenes\"); ax.set_xticks(range(10))\n", "ax.set_title(f\"Distribución de clases — entre {conteo.min()} y {conteo.max()} por dígito (balanceado)\")\n", "plt.tight_layout(); plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. El split de tres vías\n", "\n", "### `# TU CÓDIGO AQUÍ`\n", "\n", "Divide `X` e `y` en **tres** conjuntos: entrenamiento, cross-validation y prueba.\n", "\n", "`train_test_split` solo parte en dos, así que tendrás que llamarlo **dos veces**: primero separas\n", "el test, y luego partes lo que queda en train y cv.\n", "\n", "**Debes usar exactamente estas proporciones y parámetros**, para que tus resultados sean\n", "comparables con los de tus compañeros:\n", "\n", "- **60% train · 20% cross-validation · 20% test**\n", "- `random_state=SEED` en **las dos** llamadas\n", "- `stratify=` en **las dos** llamadas, para que los 10 dígitos queden repartidos en la misma\n", " proporción en los tres conjuntos\n", "\n", "> **Cuidado con la segunda llamada.** Si al primer split le pides `test_size=0.2`, te queda un 80%\n", "> por repartir. Para que el cv-set sea el 20% **del total**, la fracción que le pides al segundo\n", "> split **no** es 0.2. Haz la cuenta.\n", "\n", "**Formato esperado:** seis variables con **exactamente estos nombres**:\n", "\n", "```python\n", "X_train, X_cv, X_test, y_train, y_cv, y_test\n", "```" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# ============================================================\n", "# TU CÓDIGO AQUÍ\n", "# ============================================================\n", "\n", "# Paso 1: separar el test-set del resto (20% del total)\n", "X_temp, X_test, y_temp, y_test = train_test_split(\n", " X, y, test_size=0.2, random_state=SEED, stratify=y)\n", "\n", "# Paso 2: partir lo que queda (80% del total) en train (60% del total)\n", "# y cross-validation (20% del total) -> 0.20 / 0.80 = 0.25 de lo que queda\n", "X_train, X_cv, y_train, y_cv = train_test_split(\n", " X_temp, y_temp, test_size=0.25, random_state=SEED, stratify=y_temp)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "✅ Split de 3 vías verificado\n", " train : 1077 imágenes (60%)\n", " cv : 360 imágenes (20%)\n", " test : 360 imágenes (20%)\n" ] } ], "source": [ "# --- Verificación (no modifiques esta celda) ---\n", "for _v in [\"X_train\", \"X_cv\", \"X_test\", \"y_train\", \"y_cv\", \"y_test\"]:\n", " assert _v in dir(), f\"No encuentro `{_v}` — revisa la celda anterior.\"\n", "\n", "_n = len(X)\n", "_frac = {\"train\": len(X_train) / _n, \"cv\": len(X_cv) / _n, \"test\": len(X_test) / _n}\n", "assert abs(_frac[\"train\"] - 0.60) < 0.02, f\"train debería ser ~60% del total, es {_frac['train']:.1%}\"\n", "assert abs(_frac[\"cv\"] - 0.20) < 0.02, f\"cv debería ser ~20% del total, es {_frac['cv']:.1%}\"\n", "assert abs(_frac[\"test\"] - 0.20) < 0.02, f\"test debería ser ~20% del total, es {_frac['test']:.1%}\"\n", "assert len(X_train) + len(X_cv) + len(X_test) == _n, \"Los tres conjuntos no suman el total\"\n", "\n", "# ¿estratificó? las proporciones por clase deben parecerse entre los tres\n", "_p = [np.bincount(s, minlength=10) / len(s) for s in (y_train, y_cv, y_test)]\n", "assert max(np.abs(_p[0] - _p[1]).max(), np.abs(_p[0] - _p[2]).max()) < 0.03, \\\n", " \"Las proporciones por dígito difieren mucho entre conjuntos — ¿usaste stratify en las dos llamadas?\"\n", "\n", "print(\"✅ Split de 3 vías verificado\")\n", "print(f\" train : {len(X_train):>5} imágenes ({_frac['train']:.0%})\")\n", "print(f\" cv : {len(X_cv):>5} imágenes ({_frac['cv']:.0%})\")\n", "print(f\" test : {len(X_test):>5} imágenes ({_frac['test']:.0%})\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Preprocesamiento (ya implementado)\n", "\n", "Las redes neuronales convergen mucho mejor con las entradas escaladas. Usamos `StandardScaler`.\n", "\n", "**El detalle que importa:** el scaler se ajusta (`fit`) **solo con el train-set**, y después se\n", "*aplica* (`transform`) a los tres conjuntos. Si lo ajustáramos con todos los datos, estaríamos\n", "filtrando información del cv y del test hacia el entrenamiento — el clásico *data leakage* que\n", "vimos en la unidad de train/test split, y que produce métricas optimistas que no se sostienen\n", "en producción." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Media del train escalado : -0.0000 (debe ser ~0)\n", "Desv. del train escalado : 0.9682 (debe ser ~1)\n", "Media del cv escalado : +0.0001 (NO es exactamente 0, y está bien:\n", " el cv no participó en el ajuste del scaler)\n" ] } ], "source": [ "scaler = StandardScaler().fit(X_train) # <-- SOLO con train\n", "\n", "X_train_s = scaler.transform(X_train)\n", "X_cv_s = scaler.transform(X_cv)\n", "X_test_s = scaler.transform(X_test)\n", "\n", "print(f\"Media del train escalado : {X_train_s.mean():+.4f} (debe ser ~0)\")\n", "print(f\"Desv. del train escalado : {X_train_s.std():.4f} (debe ser ~1)\")\n", "print(f\"Media del cv escalado : {X_cv_s.mean():+.4f} (NO es exactamente 0, y está bien:\")\n", "print(f\" el cv no participó en el ajuste del scaler)\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4. La bitácora de experimentos (ya implementado)\n", "\n", "Esto es lo que pidió el área de tecnología: que **cada experimento quede registrado**. La función\n", "`registrar_experimento` agrega una fila a `experimentos.csv` con la estrategia de búsqueda, el\n", "framework, la arquitectura, los hiper-parámetros y las métricas.\n", "\n", "Fíjate en el diseño: los hiper-parámetros se guardan **también** como una cadena JSON en la columna\n", "`config`. Así la bitácora sirve aunque cada framework tenga hiper-parámetros distintos, y siempre\n", "se puede reconstruir exactamente la configuración de cualquier fila." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Bitácora reiniciada: experimentos.csv\n", "Listo. Usa registrar_experimento(...) después de evaluar cada configuración.\n" ] } ], "source": [ "BITACORA = \"experimentos.csv\"\n", "\n", "def iniciar_bitacora(path=BITACORA):\n", " \"\"\"Borra la bitácora anterior. Útil si quieres re-correr la tarea desde cero.\"\"\"\n", " if os.path.exists(path):\n", " os.remove(path)\n", " print(f\"Bitácora reiniciada: {path}\")\n", "\n", "\n", "def registrar_experimento(estrategia, framework, arquitectura, config, metricas,\n", " segundos=None, path=BITACORA):\n", " \"\"\"Agrega UNA fila a la bitácora de experimentos.\n", "\n", " estrategia : 'grid' | 'random' | 'bayesiana' (cómo se eligió esta config)\n", " framework : 'sklearn' | 'tensorflow' | 'pytorch'\n", " arquitectura : nombre legible del tipo de modelo\n", " config : dict de hiper-parámetros\n", " metricas : dict con las métricas medidas en el CV-SET\n", " segundos : cuánto tardó en entrenar (opcional)\n", " \"\"\"\n", " fila = {\n", " \"experimento\": _siguiente_id(path),\n", " \"estrategia\": estrategia,\n", " \"framework\": framework,\n", " \"arquitectura\": arquitectura,\n", " \"config\": json.dumps(config, sort_keys=True), # reconstruible después\n", " **{f\"cv_{k}\": v for k, v in metricas.items()},\n", " \"segundos\": round(segundos, 2) if segundos is not None else None,\n", " }\n", " # también en columnas propias, para poder filtrar y graficar cómodamente\n", " for k, v in config.items():\n", " fila[f\"hp_{k}\"] = v\n", "\n", " # Cada framework aporta columnas hp_* distintas, asi que NO se puede\n", " # hacer append directo: pandas escribiria los valores por posicion y las\n", " # filas quedarian desalineadas. Se reescribe el archivo completo, que con\n", " # decenas de experimentos es instantaneo y siempre queda consistente.\n", " previo = pd.read_csv(path) if os.path.exists(path) else pd.DataFrame()\n", " completo = pd.concat([previo, pd.DataFrame([fila])], ignore_index=True)\n", " completo.to_csv(path, index=False)\n", " return fila\n", "\n", "\n", "def _siguiente_id(path=BITACORA):\n", " if not os.path.exists(path):\n", " return 1\n", " return len(pd.read_csv(path)) + 1\n", "\n", "\n", "def leer_bitacora(path=BITACORA):\n", " \"\"\"Devuelve la bitácora como DataFrame.\"\"\"\n", " if not os.path.exists(path):\n", " return pd.DataFrame()\n", " return pd.read_csv(path)\n", "\n", "\n", "iniciar_bitacora()\n", "print(\"Listo. Usa registrar_experimento(...) después de evaluar cada configuración.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 5. La función de métricas\n", "\n", "### `# TU CÓDIGO AQUÍ`\n", "\n", "Escribe una función que reciba las etiquetas verdaderas y las predichas, y devuelva un diccionario\n", "con cuatro métricas. La vas a llamar **decenas de veces** durante las búsquedas, así que conviene\n", "tenerla en un solo lugar.\n", "\n", "Como el problema es **multiclase** (10 dígitos), precision, recall y F1 necesitan un promedio.\n", "Usa `average=\"macro\"`, que promedia la métrica de cada clase dándoles el **mismo peso** — así un\n", "dígito que el modelo lee mal no queda escondido detrás de los otros nueve.\n", "\n", "**Formato esperado:** una función con esta firma exacta, que devuelva un `dict` con\n", "**exactamente estas cuatro llaves**:\n", "\n", "```python\n", "def evaluar(y_true, y_pred):\n", " return {\"accuracy\": ..., \"precision\": ..., \"recall\": ..., \"f1\": ...}\n", "```\n", "\n", "Importa lo que necesites de `sklearn.metrics`." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# ============================================================\n", "# TU CÓDIGO AQUÍ\n", "# ============================================================\n", "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n", "\n", "def evaluar(y_true, y_pred):\n", " return {\n", " \"accuracy\": accuracy_score(y_true, y_pred),\n", " \"precision\": precision_score(y_true, y_pred, average=\"macro\", zero_division=0),\n", " \"recall\": recall_score(y_true, y_pred, average=\"macro\", zero_division=0),\n", " \"f1\": f1_score(y_true, y_pred, average=\"macro\", zero_division=0),\n", " }" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "✅ Función evaluar() verificada\n", " sobre el ejemplo de prueba: {'accuracy': 0.875, 'precision': 0.9167, 'recall': 0.875, 'f1': 0.8667}\n" ] } ], "source": [ "# --- Verificación (no modifiques esta celda) ---\n", "assert \"evaluar\" in dir() and callable(evaluar), \"No encuentro la función `evaluar`.\"\n", "\n", "_yt = np.array([0, 1, 2, 3, 0, 1, 2, 3])\n", "_yp = np.array([0, 1, 2, 3, 0, 1, 3, 3]) # 1 error de 8\n", "_m = evaluar(_yt, _yp)\n", "\n", "assert isinstance(_m, dict), \"`evaluar` debe devolver un diccionario\"\n", "_esperadas = {\"accuracy\", \"precision\", \"recall\", \"f1\"}\n", "assert set(_m.keys()) == _esperadas, f\"Las llaves deben ser exactamente {_esperadas}, tienes {set(_m.keys())}\"\n", "assert abs(_m[\"accuracy\"] - 0.875) < 1e-6, f\"accuracy esperada 0.875, obtuve {_m['accuracy']}\"\n", "assert abs(_m[\"f1\"] - 0.8666667) < 1e-3, \\\n", " f\"f1 macro esperada ≈0.867, obtuve {_m['f1']:.4f} — ¿usaste average='macro'?\"\n", "\n", "print(\"✅ Función evaluar() verificada\")\n", "print(\" sobre el ejemplo de prueba:\", {k: round(v, 4) for k, v in _m.items()})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 6. Los tres frameworks (ya implementado)\n", "\n", "Aquí está lo que compite en esta tarea:\n", "\n", "| Framework | Arquitectura | Hiper-parámetros a ajustar |\n", "|---|---|---|\n", "| **scikit-learn** | Random Forest | `n_estimators`, `max_depth`, `min_samples_leaf` |\n", "| **TensorFlow / Keras** | MLP densa | `capas`, `unidades`, `dropout`, `lr` |\n", "| **PyTorch** | MLP densa | `capas`, `unidades`, `dropout`, `lr` |\n", "\n", "Los dos MLP usan **el mismo espacio de hiper-parámetros a propósito**: así puedes comparar si dos\n", "implementaciones de la misma arquitectura llegan a resultados parecidos. (Spoiler: parecidos, no\n", "idénticos — cada framework inicializa los pesos y baraja los lotes a su manera.)\n", "\n", "La función `entrenar` te devuelve un objeto con un método `.predict(X)`, sin importar el framework.\n", "Eso es lo que te permite escribir **un solo bucle de búsqueda** que funcione para los tres." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "sklearn arquitectura=RandomForest accuracy_cv=0.9694 (0.1 s)\n", "tensorflow arquitectura=MLP-Keras accuracy_cv=0.9778 (1.1 s)\n", "pytorch arquitectura=MLP-PyTorch accuracy_cv=0.9639 (0.6 s)\n" ] } ], "source": [ "class ModeloEntrenado:\n", " \"\"\"Envoltura con interfaz común para los tres frameworks.\"\"\"\n", "\n", " def __init__(self, framework, obj, arquitectura):\n", " self.framework = framework\n", " self.obj = obj\n", " self.arquitectura = arquitectura\n", "\n", " def predict(self, X):\n", " if self.framework == \"sklearn\":\n", " return self.obj.predict(X)\n", " if self.framework == \"tensorflow\":\n", " return self.obj.predict(X, verbose=0).argmax(axis=1)\n", " # pytorch\n", " self.obj.eval()\n", " with torch.no_grad():\n", " logits = self.obj(torch.tensor(X, dtype=torch.float32))\n", " return logits.argmax(dim=1).numpy()\n", "\n", "\n", "def _entrenar_sklearn(hp, X_tr, y_tr):\n", " modelo = RandomForestClassifier(\n", " n_estimators=hp[\"n_estimators\"],\n", " max_depth=hp[\"max_depth\"],\n", " min_samples_leaf=hp[\"min_samples_leaf\"],\n", " random_state=SEED, n_jobs=-1,\n", " ).fit(X_tr, y_tr)\n", " return ModeloEntrenado(\"sklearn\", modelo, \"RandomForest\")\n", "\n", "\n", "def _entrenar_tensorflow(hp, X_tr, y_tr):\n", " tf.keras.backend.clear_session()\n", " tf.random.set_seed(SEED)\n", " capas = [tf.keras.layers.Input(shape=(X_tr.shape[1],))]\n", " for _ in range(hp[\"capas\"]):\n", " capas.append(tf.keras.layers.Dense(hp[\"unidades\"], activation=\"relu\"))\n", " capas.append(tf.keras.layers.Dropout(hp[\"dropout\"]))\n", " capas.append(tf.keras.layers.Dense(10, activation=\"softmax\"))\n", " modelo = tf.keras.Sequential(capas)\n", " modelo.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=hp[\"lr\"]),\n", " loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"])\n", " modelo.fit(X_tr, y_tr, epochs=EPOCAS, batch_size=64, verbose=0)\n", " return ModeloEntrenado(\"tensorflow\", modelo, \"MLP-Keras\")\n", "\n", "\n", "class _MLPTorch(nn.Module):\n", " def __init__(self, n_entradas, capas, unidades, dropout):\n", " super().__init__()\n", " bloques, dim = [], n_entradas\n", " for _ in range(capas):\n", " bloques += [nn.Linear(dim, unidades), nn.ReLU(), nn.Dropout(dropout)]\n", " dim = unidades\n", " bloques.append(nn.Linear(dim, 10))\n", " self.red = nn.Sequential(*bloques)\n", "\n", " def forward(self, x):\n", " return self.red(x)\n", "\n", "\n", "def _entrenar_pytorch(hp, X_tr, y_tr):\n", " torch.manual_seed(SEED)\n", " modelo = _MLPTorch(X_tr.shape[1], hp[\"capas\"], hp[\"unidades\"], hp[\"dropout\"])\n", " opt = torch.optim.Adam(modelo.parameters(), lr=hp[\"lr\"])\n", " lossf = nn.CrossEntropyLoss()\n", " Xt = torch.tensor(X_tr, dtype=torch.float32)\n", " yt = torch.tensor(y_tr, dtype=torch.long)\n", " ds = torch.utils.data.TensorDataset(Xt, yt)\n", " dl = torch.utils.data.DataLoader(ds, batch_size=64, shuffle=True)\n", " modelo.train()\n", " for _ in range(EPOCAS):\n", " for xb, yb in dl:\n", " opt.zero_grad()\n", " loss = lossf(modelo(xb), yb)\n", " loss.backward()\n", " opt.step()\n", " return ModeloEntrenado(\"pytorch\", modelo, \"MLP-PyTorch\")\n", "\n", "\n", "EPOCAS = 30 # igual para los dos frameworks de redes, para que compitan parejo\n", "\n", "def entrenar(framework, hp, X_tr=None, y_tr=None):\n", " \"\"\"Entrena UNA configuración y devuelve un ModeloEntrenado con .predict(X).\n", "\n", " framework: 'sklearn' | 'tensorflow' | 'pytorch'\n", " hp : dict de hiper-parámetros de ese framework\n", " \"\"\"\n", " X_tr = X_train_s if X_tr is None else X_tr\n", " y_tr = y_train if y_tr is None else y_tr\n", " return {\"sklearn\": _entrenar_sklearn,\n", " \"tensorflow\": _entrenar_tensorflow,\n", " \"pytorch\": _entrenar_pytorch}[framework](hp, X_tr, y_tr)\n", "\n", "\n", "# Prueba rápida de que los tres funcionan (y de cuánto tarda cada uno)\n", "for _fw, _hp in [(\"sklearn\", {\"n_estimators\": 50, \"max_depth\": 10, \"min_samples_leaf\": 1}),\n", " (\"tensorflow\", {\"capas\": 1, \"unidades\": 64, \"dropout\": 0.2, \"lr\": 1e-3}),\n", " (\"pytorch\", {\"capas\": 1, \"unidades\": 64, \"dropout\": 0.2, \"lr\": 1e-3})]:\n", " _t0 = time.time()\n", " _m = entrenar(_fw, _hp)\n", " _seg = time.time() - _t0\n", " _acc = (_m.predict(X_cv_s) == y_cv).mean()\n", " print(f\"{_fw:<12} arquitectura={_m.arquitectura:<14} accuracy_cv={_acc:.4f} ({_seg:.1f} s)\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 7. Estrategia 1: Grid Search\n", "\n", "### `# TU CÓDIGO AQUÍ`\n", "\n", "Prueba **todas las combinaciones** de una rejilla de hiper-parámetros, para los tres frameworks.\n", "\n", "Usa exactamente estas rejillas (ya definidas en la celda de abajo, en `REJILLAS`):\n", "\n", "```python\n", "REJILLAS = {\n", " \"sklearn\": {\"n_estimators\": [50, 150], \"max_depth\": [5, 15], \"min_samples_leaf\": [1, 4]},\n", " \"tensorflow\": {\"capas\": [1, 2], \"unidades\": [32, 128], \"dropout\": [0.0, 0.3]},\n", " \"pytorch\": {\"capas\": [1, 2], \"unidades\": [32, 128], \"dropout\": [0.0, 0.3]},\n", "}\n", "```\n", "\n", "Los MLP necesitan además un `lr`; para grid search **déjalo fijo en `1e-3`** (si no, la rejilla\n", "crece de más). Lo vas a ajustar en las otras dos estrategias.\n", "\n", "**Para cada combinación debes:**\n", "1. Entrenar con `entrenar(framework, hp)` — usa el **train-set**\n", "2. Predecir sobre el **cv-set** (`X_cv_s`) y medir con tu función `evaluar`\n", "3. Registrar el experimento con `registrar_experimento(...)`, pasando\n", " `estrategia=\"grid\"`, el framework, `modelo.arquitectura`, la config, las métricas y los segundos\n", "\n", "> **Pista.** `itertools.product(*rejilla.values())` te da todas las combinaciones, y\n", "> `dict(zip(rejilla.keys(), combo))` las vuelve un dict de hiper-parámetros.\n", "\n", "Son 8 combinaciones por framework, 24 en total. Debería tomar **2 o 3 minutos**." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Grid search terminado\n" ] } ], "source": [ "REJILLAS = {\n", " \"sklearn\": {\"n_estimators\": [50, 150], \"max_depth\": [5, 15], \"min_samples_leaf\": [1, 4]},\n", " \"tensorflow\": {\"capas\": [1, 2], \"unidades\": [32, 128], \"dropout\": [0.0, 0.3]},\n", " \"pytorch\": {\"capas\": [1, 2], \"unidades\": [32, 128], \"dropout\": [0.0, 0.3]},\n", "}\n", "LR_FIJO = 1e-3 # para los MLP en grid search\n", "\n", "# ============================================================\n", "# TU CÓDIGO AQUÍ\n", "# ============================================================\n", "for framework, rejilla in REJILLAS.items():\n", " for combo in itertools.product(*rejilla.values()):\n", " hp = dict(zip(rejilla.keys(), combo))\n", " if framework in (\"tensorflow\", \"pytorch\"):\n", " hp[\"lr\"] = LR_FIJO\n", "\n", " t0 = time.time()\n", " modelo = entrenar(framework, hp)\n", " segundos = time.time() - t0\n", "\n", " y_pred = modelo.predict(X_cv_s) # sobre el CV-SET\n", " metricas = evaluar(y_cv, y_pred)\n", "\n", " registrar_experimento(estrategia=\"grid\", framework=framework,\n", " arquitectura=modelo.arquitectura, config=hp,\n", " metricas=metricas, segundos=segundos)\n", "\n", "print(\"Grid search terminado\")" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "✅ Grid search verificado: 24 experimentos registrados\n", " count mean max\n", "framework \n", "pytorch 8 0.9701 0.9834\n", "sklearn 8 0.9532 0.9752\n", "tensorflow 8 0.9629 0.9777\n" ] } ], "source": [ "# --- Verificación (no modifiques esta celda) ---\n", "_b = leer_bitacora()\n", "assert len(_b) > 0, \"La bitácora está vacía — ¿llamaste a registrar_experimento?\"\n", "_g = _b[_b[\"estrategia\"] == \"grid\"]\n", "assert len(_g) == 24, f\"Se esperaban 24 experimentos de grid (8 por framework), hay {len(_g)}\"\n", "assert set(_g[\"framework\"].unique()) == {\"sklearn\", \"tensorflow\", \"pytorch\"}, \\\n", " f\"Faltan frameworks en el grid: {set(_g['framework'].unique())}\"\n", "for _fw in (\"sklearn\", \"tensorflow\", \"pytorch\"):\n", " assert len(_g[_g[\"framework\"] == _fw]) == 8, f\"{_fw} debería tener 8 combinaciones\"\n", "assert _g[\"cv_f1\"].notna().all(), \"Hay filas sin métrica cv_f1 — ¿pasaste bien el dict de métricas?\"\n", "assert _g[\"cv_f1\"].max() > 0.80, \\\n", " f\"El mejor f1 del grid es {_g['cv_f1'].max():.3f}, sospechosamente bajo — ¿evaluaste sobre el CV-set?\"\n", "\n", "print(f\"✅ Grid search verificado: {len(_g)} experimentos registrados\")\n", "print(_g.groupby(\"framework\")[\"cv_f1\"].agg([\"count\", \"mean\", \"max\"]).round(4))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 8. Estrategia 2: Random Search\n", "\n", "### `# TU CÓDIGO AQUÍ`\n", "\n", "En vez de recorrer una rejilla, **muestrea configuraciones al azar** de un espacio continuo.\n", "Como vimos en la unidad, esto suele encontrar mejores configuraciones con el mismo presupuesto:\n", "la rejilla desperdicia pruebas en hiper-parámetros que no importan, el muestreo aleatorio no.\n", "\n", "Corre **8 configuraciones por framework** (24 en total, el mismo presupuesto que el grid, para que\n", "la comparación sea justa). Usa el generador `rng` ya creado, para que sea reproducible.\n", "\n", "**Espacios a muestrear:**\n", "\n", "| Framework | Hiper-parámetro | Cómo muestrearlo |\n", "|---|---|---|\n", "| sklearn | `n_estimators` | entero entre 30 y 300 |\n", "| sklearn | `max_depth` | entero entre 3 y 25 |\n", "| sklearn | `min_samples_leaf` | entero entre 1 y 8 |\n", "| tensorflow / pytorch | `capas` | entero entre 1 y 3 |\n", "| tensorflow / pytorch | `unidades` | entero entre 16 y 256 |\n", "| tensorflow / pytorch | `dropout` | real entre 0.0 y 0.5 |\n", "| tensorflow / pytorch | `lr` | **log-uniforme** entre 1e-4 y 1e-2 |\n", "\n", "> **Por qué el `lr` es log-uniforme.** Un learning rate de 0.0001 y uno de 0.001 son tan distintos\n", "> entre sí como 0.001 y 0.01, aunque en la recta real disten muy poco. Muestrear uniforme te daría\n", "> casi siempre valores grandes. Pista: `10 ** rng.uniform(-4, -2)`.\n", "\n", "Registra cada experimento igual que antes, pero con `estrategia=\"random\"`." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Random search terminado\n" ] } ], "source": [ "rng = np.random.default_rng(SEED)\n", "N_RANDOM = 8 # configuraciones por framework\n", "\n", "# ============================================================\n", "# TU CÓDIGO AQUÍ\n", "# ============================================================\n", "for framework in (\"sklearn\", \"tensorflow\", \"pytorch\"):\n", " for _ in range(N_RANDOM):\n", " if framework == \"sklearn\":\n", " hp = {\"n_estimators\": int(rng.integers(30, 301)),\n", " \"max_depth\": int(rng.integers(3, 26)),\n", " \"min_samples_leaf\": int(rng.integers(1, 9))}\n", " else:\n", " hp = {\"capas\": int(rng.integers(1, 4)),\n", " \"unidades\": int(rng.integers(16, 257)),\n", " \"dropout\": float(rng.uniform(0.0, 0.5)),\n", " \"lr\": float(10 ** rng.uniform(-4, -2))}\n", "\n", " t0 = time.time()\n", " modelo = entrenar(framework, hp)\n", " segundos = time.time() - t0\n", "\n", " y_pred = modelo.predict(X_cv_s) # sobre el CV-SET\n", " metricas = evaluar(y_cv, y_pred)\n", "\n", " registrar_experimento(estrategia=\"random\", framework=framework,\n", " arquitectura=modelo.arquitectura, config=hp,\n", " metricas=metricas, segundos=segundos)\n", "\n", "print(\"Random search terminado\")" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "✅ Random search verificado: 24 experimentos registrados\n", " learning rates muestreados: de 0.00013 a 0.00611\n", " count mean max\n", "framework \n", "pytorch 8 0.9560 0.9835\n", "sklearn 8 0.9633 0.9780\n", "tensorflow 8 0.9588 0.9834\n" ] } ], "source": [ "# --- Verificación (no modifiques esta celda) ---\n", "_b = leer_bitacora()\n", "_r = _b[_b[\"estrategia\"] == \"random\"]\n", "assert len(_r) == 24, f\"Se esperaban 24 experimentos de random search, hay {len(_r)}\"\n", "for _fw in (\"sklearn\", \"tensorflow\", \"pytorch\"):\n", " assert len(_r[_r[\"framework\"] == _fw]) == N_RANDOM, f\"{_fw} debería tener {N_RANDOM} configuraciones\"\n", "\n", "_nn = _r[_r[\"framework\"].isin([\"tensorflow\", \"pytorch\"])]\n", "assert _nn[\"hp_lr\"].nunique() > 8, \\\n", " \"Los learning rates se repiten demasiado — ¿los estás muestreando al azar?\"\n", "assert _nn[\"hp_lr\"].min() < 1e-3 < _nn[\"hp_lr\"].max(), \\\n", " \"Los learning rates no cubren el rango 1e-4 a 1e-2 — revisa el muestreo log-uniforme\"\n", "assert _r[\"hp_n_estimators\"].dropna().nunique() > 4, \"n_estimators se repite demasiado\"\n", "\n", "print(f\"✅ Random search verificado: {len(_r)} experimentos registrados\")\n", "print(f\" learning rates muestreados: de {_nn['hp_lr'].min():.5f} a {_nn['hp_lr'].max():.5f}\")\n", "print(_r.groupby(\"framework\")[\"cv_f1\"].agg([\"count\", \"mean\", \"max\"]).round(4))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 9. Estrategia 3: Optimización Bayesiana (Optuna)\n", "\n", "### `# TU CÓDIGO AQUÍ`\n", "\n", "Grid y random search son **ciegos**: cada prueba ignora lo que aprendieron las anteriores. La\n", "optimización bayesiana construye un modelo de qué zonas del espacio son prometedoras y **decide\n", "dónde probar** con base en los resultados que ya vio.\n", "\n", "Con Optuna esto se escribe como una función `objetivo(trial)` que:\n", "1. **Pide** los hiper-parámetros a `trial` (en vez de elegirlos tú)\n", "2. Entrena y evalúa en el cv-set\n", "3. **Registra** el experimento\n", "4. **Devuelve** la métrica a maximizar (usa `f1`)\n", "\n", "Aquí `trial` también elige **el framework**: así Optuna hace selección de arquitectura *y* tuning\n", "al mismo tiempo, que es lo que se hace en la práctica.\n", "\n", "Métodos de `trial` que vas a necesitar:\n", "\n", "```python\n", "trial.suggest_categorical(\"framework\", [\"sklearn\", \"tensorflow\", \"pytorch\"])\n", "trial.suggest_int(\"n_estimators\", 30, 300)\n", "trial.suggest_float(\"dropout\", 0.0, 0.5)\n", "trial.suggest_float(\"lr\", 1e-4, 1e-2, log=True) # log=True hace el muestreo log-uniforme\n", "```\n", "\n", "Corre **24 trials**, el mismo presupuesto que las otras dos estrategias. Registra cada uno con\n", "`estrategia=\"bayesiana\"`.\n", "\n", "> **Ojo:** dentro del objetivo, el dict `hp` que le pasas a `entrenar` y a\n", "> `registrar_experimento` **no** debe incluir la llave `\"framework\"` (ese va como argumento aparte)." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Mejor f1 en cv: 0.9833983001975856\n", "Mejores parámetros: {'framework': 'tensorflow', 'capas': 1, 'unidades': 146, 'dropout': 0.07046211248738132, 'lr': 0.0040215545266902904}\n" ] } ], "source": [ "N_TRIALS = 24\n", "\n", "# ============================================================\n", "# TU CÓDIGO AQUÍ\n", "# ============================================================\n", "def objetivo(trial):\n", " framework = trial.suggest_categorical(\"framework\", [\"sklearn\", \"tensorflow\", \"pytorch\"])\n", "\n", " if framework == \"sklearn\":\n", " hp = {\"n_estimators\": trial.suggest_int(\"n_estimators\", 30, 300),\n", " \"max_depth\": trial.suggest_int(\"max_depth\", 3, 25),\n", " \"min_samples_leaf\": trial.suggest_int(\"min_samples_leaf\", 1, 8)}\n", " else:\n", " hp = {\"capas\": trial.suggest_int(\"capas\", 1, 3),\n", " \"unidades\": trial.suggest_int(\"unidades\", 16, 256),\n", " \"dropout\": trial.suggest_float(\"dropout\", 0.0, 0.5),\n", " \"lr\": trial.suggest_float(\"lr\", 1e-4, 1e-2, log=True)}\n", "\n", " t0 = time.time()\n", " modelo = entrenar(framework, hp)\n", " segundos = time.time() - t0\n", " metricas = evaluar(y_cv, modelo.predict(X_cv_s))\n", "\n", " registrar_experimento(estrategia=\"bayesiana\", framework=framework,\n", " arquitectura=modelo.arquitectura, config=hp,\n", " metricas=metricas, segundos=segundos)\n", " return metricas[\"f1\"]\n", "\n", "estudio = optuna.create_study(direction=\"maximize\",\n", " sampler=optuna.samplers.TPESampler(seed=SEED))\n", "estudio.optimize(objetivo, n_trials=N_TRIALS)\n", "print(\"Mejor f1 en cv:\", estudio.best_value)\n", "print(\"Mejores parámetros:\", estudio.best_params)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "✅ Optimización bayesiana verificada: 24 trials registrados\n", " frameworks explorados: {'pytorch': np.int64(12), 'tensorflow': np.int64(8), 'sklearn': np.int64(4)}\n", " mejor f1 en cv: 0.9834\n" ] } ], "source": [ "# --- Verificación (no modifiques esta celda) ---\n", "_b = leer_bitacora()\n", "_o = _b[_b[\"estrategia\"] == \"bayesiana\"]\n", "assert len(_o) == N_TRIALS, f\"Se esperaban {N_TRIALS} trials bayesianos, hay {len(_o)}\"\n", "assert \"estudio\" in dir(), \"No encuentro el objeto `estudio` de Optuna.\"\n", "assert len(_o[\"framework\"].unique()) >= 2, \\\n", " \"Optuna probó un solo framework — ¿incluiste 'framework' como suggest_categorical?\"\n", "assert _o[\"cv_f1\"].max() > 0.80, f\"El mejor f1 bayesiano es {_o['cv_f1'].max():.3f}, revisa la evaluación\"\n", "\n", "print(f\"✅ Optimización bayesiana verificada: {len(_o)} trials registrados\")\n", "print(f\" frameworks explorados: {dict(_o['framework'].value_counts())}\")\n", "print(f\" mejor f1 en cv: {_o['cv_f1'].max():.4f}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 10. Comparación de las tres estrategias (ya implementado)\n", "\n", "Con la bitácora completa (72 experimentos) podemos comparar. Fíjate en tres cosas al mirar las\n", "gráficas:\n", "\n", "1. **¿Qué estrategia encontró la mejor configuración?** No siempre es la bayesiana con presupuestos\n", " chicos: TPE necesita algunos trials para \"calentar\".\n", "2. **¿Qué framework domina?** Y ojo con el costo: mira también los segundos.\n", "3. **La convergencia:** grid y random son planos por construcción (no aprenden); la bayesiana\n", " debería mejorar su mejor-hasta-ahora más rápido." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Bitácora: 72 experimentos\n", "\n", " count mean max\n", "estrategia framework \n", "bayesiana pytorch 12 0.9708 0.9806\n", " sklearn 4 0.9096 0.9613\n", " tensorflow 8 0.9422 0.9834\n", "grid pytorch 8 0.9701 0.9834\n", " sklearn 8 0.9532 0.9752\n", " tensorflow 8 0.9629 0.9777\n", "random pytorch 8 0.9560 0.9835\n", " sklearn 8 0.9633 0.9780\n", " tensorflow 8 0.9588 0.9834\n" ] } ], "source": [ "bit = leer_bitacora()\n", "print(f\"Bitácora: {len(bit)} experimentos\\n\")\n", "print(bit.groupby([\"estrategia\", \"framework\"])[\"cv_f1\"].agg([\"count\", \"mean\", \"max\"]).round(4))" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, axes = plt.subplots(1, 3, figsize=(14, 3.8))\n", "\n", "# (a) distribución del f1 por estrategia\n", "ests = [\"grid\", \"random\", \"bayesiana\"]\n", "datos = [bit[bit[\"estrategia\"] == e][\"cv_f1\"].values for e in ests]\n", "bp = axes[0].boxplot(datos, labels=ests, patch_artist=True)\n", "for caja in bp[\"boxes\"]:\n", " caja.set_facecolor(OKABE[0]); caja.set_alpha(0.55)\n", "axes[0].set_ylabel(\"f1 en cross-validation\")\n", "axes[0].set_title(\"(a) Distribución por estrategia\")\n", "axes[0].grid(alpha=0.3, axis=\"y\")\n", "\n", "# (b) f1 por framework\n", "fws = [\"sklearn\", \"tensorflow\", \"pytorch\"]\n", "datos2 = [bit[bit[\"framework\"] == f][\"cv_f1\"].values for f in fws]\n", "bp2 = axes[1].boxplot(datos2, labels=fws, patch_artist=True)\n", "for caja in bp2[\"boxes\"]:\n", " caja.set_facecolor(OKABE[2]); caja.set_alpha(0.55)\n", "axes[1].set_ylabel(\"f1 en cross-validation\")\n", "axes[1].set_title(\"(b) Distribución por framework\")\n", "axes[1].grid(alpha=0.3, axis=\"y\")\n", "\n", "# (c) mejor-hasta-ahora, por estrategia\n", "for i, e in enumerate(ests):\n", " sub = bit[bit[\"estrategia\"] == e].reset_index(drop=True)\n", " axes[2].plot(range(1, len(sub) + 1), sub[\"cv_f1\"].cummax(),\n", " marker=\"o\", ms=3, color=OKABE[i], label=e)\n", "axes[2].set_xlabel(\"experimento dentro de la estrategia\")\n", "axes[2].set_ylabel(\"mejor f1 hasta ahora\")\n", "axes[2].set_title(\"(c) Convergencia\")\n", "axes[2].legend(); axes[2].grid(alpha=0.3)\n", "\n", "plt.tight_layout(); plt.show()" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Top 5 configuraciones de toda la bitácora:\n", " experimento estrategia framework arquitectura cv_f1 cv_accuracy segundos\n", " 47 random pytorch MLP-PyTorch 0.983540 0.983333 0.54\n", " 58 bayesiana tensorflow MLP-Keras 0.983398 0.983333 1.26\n", " 24 grid pytorch MLP-PyTorch 0.983362 0.983333 0.40\n", " 36 random tensorflow MLP-Keras 0.983360 0.983333 1.50\n", " 37 random tensorflow MLP-Keras 0.980661 0.980556 2.00\n" ] } ], "source": [ "# Costo vs beneficio: ¿los modelos más lentos son mejores?\n", "fig, ax = plt.subplots(figsize=(7, 4))\n", "for i, fw in enumerate(fws):\n", " sub = bit[bit[\"framework\"] == fw]\n", " ax.scatter(sub[\"segundos\"], sub[\"cv_f1\"], s=42, alpha=0.75,\n", " color=OKABE[i], label=fw, edgecolors=\"white\", linewidths=0.6)\n", "ax.set_xlabel(\"segundos de entrenamiento\")\n", "ax.set_ylabel(\"f1 en cross-validation\")\n", "ax.set_title(\"Costo de entrenamiento vs desempeño\")\n", "ax.legend(); ax.grid(alpha=0.3)\n", "plt.tight_layout(); plt.show()\n", "\n", "print(\"Top 5 configuraciones de toda la bitácora:\")\n", "cols = [\"experimento\", \"estrategia\", \"framework\", \"arquitectura\", \"cv_f1\", \"cv_accuracy\", \"segundos\"]\n", "print(bit.nlargest(5, \"cv_f1\")[cols].to_string(index=False))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 11. El modelo final y el test-set\n", "\n", "### `# TU CÓDIGO AQUÍ`\n", "\n", "Llegó el momento de usar el test-set — **por primera y única vez**.\n", "\n", "**Lo que tienes que hacer:**\n", "\n", "1. Encontrar en la bitácora la fila con el **mejor `cv_f1`** y guardarla en `mejor_fila`\n", "2. Reconstruir su configuración desde la columna `config` (es una cadena JSON: `json.loads`)\n", " y guardarla en `mejor_config`\n", "3. **Re-entrenar** esa configuración usando **train + cv juntos**\n", " (`np.vstack` / `np.concatenate`) — ahora que ya elegiste, no tiene sentido desperdiciar el cv\n", "4. Evaluar ese modelo en el **test-set** y guardar las métricas en `metricas_test`\n", "\n", "**Formato esperado:** tres variables con estos nombres:\n", "\n", "```python\n", "mejor_fila # una fila (Series) de la bitácora\n", "mejor_config # dict de hiper-parámetros\n", "metricas_test # dict con las 4 métricas, medidas en test\n", "```\n", "\n", "> **Por qué re-entrenar con train + cv.** El cv-set ya cumplió su función (elegir). Volver a\n", "> entrenar con más datos casi siempre mejora el modelo que sale a producción. Lo que **no** puedes\n", "> hacer es tocar el test-set antes de este punto." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'accuracy': 0.975, 'precision': 0.9757523257523258, 'recall': 0.9748369798369797, 'f1': 0.9749683984469085}\n" ] } ], "source": [ "# ============================================================\n", "# TU CÓDIGO AQUÍ\n", "# ============================================================\n", "bit = leer_bitacora()\n", "mejor_fila = bit.loc[bit[\"cv_f1\"].idxmax()]\n", "mejor_config = json.loads(mejor_fila[\"config\"])\n", "\n", "X_full = np.vstack([X_train_s, X_cv_s])\n", "y_full = np.concatenate([y_train, y_cv])\n", "\n", "modelo_final = entrenar(mejor_fila[\"framework\"], mejor_config, X_full, y_full)\n", "metricas_test = evaluar(y_test, modelo_final.predict(X_test_s))\n", "\n", "print(metricas_test)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "✅ Selección final verificada\n", " modelo elegido : MLP-PyTorch (pytorch, estrategia random)\n", " f1 en cv : 0.9835\n", " f1 en test : 0.9750\n" ] } ], "source": [ "# --- Verificación (no modifiques esta celda) ---\n", "for _v in [\"mejor_fila\", \"mejor_config\", \"metricas_test\", \"modelo_final\"]:\n", " assert _v in dir(), f\"No encuentro `{_v}` — revisa la celda anterior.\"\n", "assert isinstance(mejor_config, dict), \"`mejor_config` debe ser un dict (usa json.loads)\"\n", "assert set(metricas_test.keys()) == {\"accuracy\", \"precision\", \"recall\", \"f1\"}, \\\n", " \"`metricas_test` debe tener las mismas 4 llaves que devuelve evaluar()\"\n", "\n", "_bit = leer_bitacora()\n", "assert abs(mejor_fila[\"cv_f1\"] - _bit[\"cv_f1\"].max()) < 1e-9, \\\n", " \"`mejor_fila` no es la de mayor cv_f1 de la bitácora\"\n", "assert metricas_test[\"f1\"] > 0.85, \\\n", " f\"f1 en test es {metricas_test['f1']:.3f}, muy bajo — ¿evaluaste con X_test_s (escalado)?\"\n", "\n", "print(\"✅ Selección final verificada\")\n", "print(f\" modelo elegido : {mejor_fila['arquitectura']} ({mejor_fila['framework']}, \"\n", " f\"estrategia {mejor_fila['estrategia']})\")\n", "print(f\" f1 en cv : {mejor_fila['cv_f1']:.4f}\")\n", "print(f\" f1 en test : {metricas_test['f1']:.4f}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 12. Reporte final del modelo elegido (ya implementado)\n", "\n", "Esto es lo que le entregas al área de tecnología." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "====================================================================\n", "REPORTE FINAL — Lector automático de medidores\n", "====================================================================\n", "\n", "Experimentos corridos : 72\n", " por grid search : 24\n", " por random search : 24\n", " por optimización bayesiana: 24\n", "Tiempo total de entrenamiento: 49 s\n", "\n", "MODELO ELEGIDO\n", " arquitectura : MLP-PyTorch\n", " framework : pytorch\n", " hallado por : random (experimento #47)\n", " hiper-parámetros:\n", " capas = 2\n", " dropout = 0.39036451551098394\n", " lr = 0.0008276210937283387\n", " unidades = 185\n", "\n", "DESEMPEÑO\n", " métrica cross-validation test diferencia\n", " accuracy 0.9833 0.9750 -0.0083\n", " precision 0.9842 0.9758 -0.0084\n", " recall 0.9832 0.9748 -0.0084\n", " f1 0.9835 0.9750 -0.0086\n", "\n", " El número que va al informe es el de TEST: f1 = 0.9750\n", " (el de cv está sesgado al alza: esa configuración se eligió justamente por ser la mejor ahí)\n", "====================================================================\n" ] } ], "source": [ "from sklearn.metrics import confusion_matrix, classification_report\n", "\n", "bit = leer_bitacora()\n", "\n", "print(\"=\" * 68)\n", "print(\"REPORTE FINAL — Lector automático de medidores\")\n", "print(\"=\" * 68)\n", "print(f\"\\nExperimentos corridos : {len(bit)}\")\n", "print(f\" por grid search : {(bit['estrategia'] == 'grid').sum()}\")\n", "print(f\" por random search : {(bit['estrategia'] == 'random').sum()}\")\n", "print(f\" por optimización bayesiana: {(bit['estrategia'] == 'bayesiana').sum()}\")\n", "print(f\"Tiempo total de entrenamiento: {bit['segundos'].sum():.0f} s\")\n", "\n", "print(f\"\\nMODELO ELEGIDO\")\n", "print(f\" arquitectura : {mejor_fila['arquitectura']}\")\n", "print(f\" framework : {mejor_fila['framework']}\")\n", "print(f\" hallado por : {mejor_fila['estrategia']} (experimento #{mejor_fila['experimento']})\")\n", "print(f\" hiper-parámetros:\")\n", "for k, v in mejor_config.items():\n", " print(f\" {k:<18} = {v}\")\n", "\n", "print(f\"\\nDESEMPEÑO\")\n", "print(f\" {'métrica':<12} {'cross-validation':>18} {'test':>10} {'diferencia':>12}\")\n", "for m in [\"accuracy\", \"precision\", \"recall\", \"f1\"]:\n", " cv_v, te_v = mejor_fila[f\"cv_{m}\"], metricas_test[m]\n", " print(f\" {m:<12} {cv_v:>18.4f} {te_v:>10.4f} {te_v - cv_v:>+12.4f}\")\n", "\n", "print(f\"\\n El número que va al informe es el de TEST: f1 = {metricas_test['f1']:.4f}\")\n", "print(\" (el de cv está sesgado al alza: esa configuración se eligió justamente por ser la mejor ahí)\")\n", "print(\"=\" * 68)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABGkAAAGuCAYAAAAjwVsAAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAoGRJREFUeJzs3XdYU2f/BvA7QUjYQ5mKCwd1KyriwiqKqChq66xbWxWtStVKrYITrbt1tdbVCnXUUbWOuq1V26rVVq2zqDhAHAxBgpDz+4MfeY0MkxByArk/73WutznnPOf5JjwmJ988QyIIggAiIiIiIiIiIhKVVOwAiIiIiIiIiIiISRoiIiIiIiIiIqPAJA0RERERERERkRFgkoaIiIiIiIiIyAgwSUNEREREREREZASYpCEiIiIiIiIiMgJM0hARERERERERGQEmaYiIiIiIiIiIjACTNFTqKRQKzJ07FwcPHhQ7FCIiIiIiIqICMUmjg8jISEgkkmKtQyKRIDIysljrMISEhAS89957KFu2LCQSCZYuXar3Ot72WoWFhSE6Ohq+vr56r5vIFLRp0wZ16tQROwwiIgC63yPduXMHEokEGzZs0HtMb1O5cmUMHjy4WOvQ5v60tNxnljSDBw9G5cqV1fZp+rcoju8fx48fh0QiwfHjx/V6XSIqGqNO0mzYsAESiQQSiQSnTp3Kc1wQBHh6ekIikaBLly461TF37lzs2rWriJFSQSZMmICDBw8iPDwc33//PTp27GjQ+rdu3Ypdu3Zh//79cHBwMGjdRZV7M6nJdufOHdUHbUHb5s2bVdfOzMzEsmXL0LBhQ9jZ2cHBwQG1a9fGhx9+iGvXrgGAxnWL8cGeW/fw4cPzPT516lTVOU+ePFHtHzx4MGxsbAq99uvvOxKJBHK5HDVq1MCYMWOQkJDw1tjatGmjVt7JyQlNmjTBunXroFQqNX6Ob8ZR0PbmzR4RkSEY4h6NiPRj5cqVoiQnxWSI73inT59GZGQkkpKSirUeMj1lxA5AE3K5HDExMWjZsqXa/hMnTuD+/fuQyWQ6X3vu3Ll47733EBISonGZzz//HFOmTNG5TlNy9OhRdOvWDRMnTiy2Ol6+fIkyZfI2ZUEQcP/+fezfvx8VK1YstvqLi7OzM77//nu1fYsWLcL9+/exZMmSPOfeuXMHAPDxxx+jSZMmea7n5+en+u+ePXti//796Nu3L0aMGIFXr17h2rVr2Lt3L5o3bw5vb+88dX/33Xc4dOhQnv3vvPNOUZ6mzuRyObZv346VK1fCwsJC7dgPP/wAuVyOjIwMna8/c+ZMVKlSBRkZGTh16hRWrVqFffv24fLly7Cysiq0bIUKFRAVFQUASExMxHfffYdhw4bhxo0bmDdvnkb1t27dOs9rPXz4cDRt2hQffvihat/bkk5ERMWpOO/RSDu8Py2ZCrqP1aeVK1eiXLlyeXpztW7dGi9fvsxzH1Ua6PIdT1unT5/GjBkzMHjw4BL3YzAZtxKRpOnUqRO2bduGL7/8Uu1NLCYmBj4+Pmq/lBentLQ0WFtbo0yZMsX+ZlpaPH78uNjftORyeb77JRIJwsLCirXu4mRtbY0PPvhAbd/mzZvx/PnzPPtf16pVK7z33nsFHv/zzz+xd+9ezJkzB5999pnaseXLl6t+DXizjrNnz+LQoUOF1m1IHTt2xO7du7F//35069ZNtf/06dOIjY1Fz549sX37dp2vHxQUhMaNGwPISY6ULVsWixcvxk8//YS+ffsWWtbe3l7tdfroo49Qs2ZNLF++HLNmzYK5uflb669atSqqVq2qtm/kyJGoWrWqXv4Gue9nRERFYSz3aIRSc3+akZEBCwsLSKVG3eFfbwq6jzUEqVQqav1ElL8S8e7Xt29fPH36FIcOHVLty8zMxI8//oh+/frlW2bhwoVo3rw5ypYtC0tLS/j4+ODHH39UO0cikSAtLQ0bN25UddnNzTDnjvu8evUq+vXrB0dHR9WvRG+OCR08eHCBQxHeNsZUoVBgwoQJcHZ2hq2tLbp27Yr79+/ne+6DBw8wdOhQuLq6QiaToXbt2li3bt3bXj6VTZs2oWnTprCysoKjoyNat26NX375Re2clStXonbt2pDJZPDw8EBoaGieLny581NcvXoV7777LqysrFC+fHl88cUXqnNyu0ELgoAVK1aoXo/8Xr83y+T2CAGAc+fOITAwEOXKlYOlpSWqVKmCoUOHqpXL73X+66+/EBQUBDs7O9jY2KBdu3Y4e/ZsvvX99ttvCAsLg7OzM6ytrdG9e3ckJiZq9Jpeu3YN7733HpycnCCXy9G4cWPs3r1b7/Xo0+3btwEALVq0yHPMzMwMZcuWNXRIOilfvjxat26NmJgYtf3R0dGoW7eu3udQadu2LQAgNjZW67JWVlZo1qwZ0tLSkJiYiIiICJibm+f79//www/h4OCgcS8gbdr6iRMnMHr0aLi4uKBChQqq4/v374e/vz9sbW1hZ2eHJk2a5HldART6b56ITJMu92hpaWn45JNP4OnpCZlMhpo1a2LhwoUQBEHtPEPdIx09ehStWrWCtbU1HBwc0K1bN/z7778alVUoFIiIiEC1atUgk8ng6emJyZMnQ6FQvLVsUlISxo8fr3odqlWrhvnz5+cZGvv06VMMGDBANTx50KBBuHTpUp75dfK7v9LmNdTk8wTIuY/IvZfQ5DlOmDABlStXhkwmQ4UKFTBw4EBV8i53qPbmzZvx+eefo3z58rCyskJKSgoAYNu2bfDx8YGlpSXKlSuHDz74AA8ePFCrIz4+HkOGDEGFChUgk8ng7u6Obt26aX0/+aYxY8bAxsYG6enpeY717dsXbm5uyM7OBgD89NNP6Ny5Mzw8PCCTyeDl5YVZs2apjhcmv/vYU6dOoUmTJpDL5fDy8sLXX3+db9n169ejbdu2cHFxgUwmQ61atbBq1Sq1cypXrowrV67gxIkTqvvxNm3aACh4ThpNXvfcIeQPHjxASEgIbGxs4OzsjIkTJ771eXfp0iXPD1G5/Pz8VD+SAcChQ4fQsmVLODg4wMbGBjVr1szzI+ObCvuOB2j+fvHVV1+hdu3aqu9OjRs3Vt0fRUZGYtKkSQCAKlWqqE1BQFRUJSLdXrlyZfj5+eGHH35AUFAQgJwvFcnJyejTpw++/PLLPGWWLVuGrl27on///sjMzMTmzZvx/vvvY+/evejcuTMA4Pvvv88zfMDLy0vtOu+//z6qV6+OuXPn5rl5yPXRRx8hICBAbd+BAwcQHR0NFxeXQp/b8OHDsWnTJvTr1w/NmzfH0aNHVfG9LiEhAc2aNYNEIsGYMWPg7OyM/fv3Y9iwYUhJScH48eMLrWfGjBmIjIxE8+bNMXPmTFhYWOD333/H0aNH0aFDBwA5bzYzZsxAQEAARo0ahevXr2PVqlX4888/8dtvv6n9+v/8+XN07NgRPXr0QK9evfDjjz/i008/Rd26dREUFKQaqjFgwAC0b98eAwcOLDS+/Dx+/BgdOnSAs7MzpkyZAgcHB9y5cwc7duwotNyVK1fQqlUr2NnZYfLkyTA3N8fXX3+NNm3a4MSJE3kmEB47diwcHR0RERGBO3fuYOnSpRgzZgy2bNny1npatGiB8uXLY8qUKbC2tsbWrVsREhKC7du3o3v37nqpR1upqan5/nKZO3lzpUqVAOQkM1q0aFGif3Xr168fxo0bhxcvXsDGxgZZWVnYtm0bwsLCijTUKT+5N6S6JrH+++8/mJmZwcHBAQMGDMDMmTOxZcsWjBkzRnVO7hebnj17avTLlrZtffTo0XB2dsb06dORlpYGICeBM3ToUNSuXRvh4eFwcHDAX3/9hQMHDqh9wXrbv3kiMk3a3qMJgoCuXbvi2LFjGDZsGBo0aICDBw9i0qRJePDggdpwXkPcIx0+fBhBQUGoWrUqIiMj8fLlS3z11Vdo0aIFLly4UOi8X0qlEl27dsWpU6fw4Ycf4p133sE///yDJUuW4MaNG4XOh5Geng5/f388ePAAH330ESpWrIjTp08jPDwcjx49Ui20oFQqERwcjD/++AOjRo2Ct7c3fvrpJwwaNKjAa79O09dQm8+Tdu3aAcBbv4y+ePECrVq1wr///ouhQ4eiUaNGePLkCXbv3o379++jXLlyqnNnzZoFCwsLTJw4EQqFAhYWFtiwYQOGDBmCJk2aICoqCgkJCVi2bBl+++03/PXXX6qe2j179sSVK1cwduxYVK5cGY8fP8ahQ4dw79491WNd7id79+6NFStW4Oeff8b777+v2p+eno49e/Zg8ODBMDMzA5DzWWpjY4OwsDDY2Njg6NGjmD59OlJSUrBgwYJC63nTP//8o4o3MjISWVlZiIiIgKura55zV61ahdq1a6Nr164oU6YM9uzZg9GjR0OpVCI0NBQAsHTpUowdOxY2NjaYOnUqAOR7rVyavu4AkJ2djcDAQPj6+mLhwoU4fPgwFi1aBC8vL4waNarQ13bgwIH4888/1Ybo3717F2fPnlW9ZleuXEGXLl1Qr149zJw5EzKZDLdu3cJvv/1W6GtY2Hc8Td8v1qxZg48//hjvvfcexo0bh4yMDPz999/4/fff0a9fP/To0QM3btzADz/8gCVLlqjas7Ozc6GxEWlEMGLr168XAAh//vmnsHz5csHW1lZIT08XBEEQ3n//feHdd98VBEEQKlWqJHTu3FmtbO55uTIzM4U6deoIbdu2VdtvbW0tDBo0KE/dERERAgChb9++BR4ryM2bNwV7e3uhffv2QlZWVoHnXbx4UQAgjB49Wm1/v379BABCRESEat+wYcMEd3d34cmTJ2rn9unTR7C3t8/zfN+MRyqVCt27dxeys7PVjimVSkEQBOHx48eChYWF0KFDB7Vzli9fLgAQ1q1bp9rn7+8vABC+++471T6FQiG4ubkJPXv2VLs+ACE0NFRtX0GvX+7fOzY2VhAEQdi5c6fq71+YN1+rkJAQwcLCQrh9+7Zq38OHDwVbW1uhdevWeeoLCAhQvQ6CIAgTJkwQzMzMhKSkpELrbdeunVC3bl0hIyNDtU+pVArNmzcXqlevrrd6Xte5c2ehUqVK+R47duyYAKDA7dGjR6oYc/+Grq6uQt++fYUVK1YId+/eLbTu0NDQQtu9IeW2q2fPngkWFhbC999/LwiCIPz888+CRCIR7ty5o2pniYmJqnKDBg0SrK2tC7127t/r8OHDQmJiohAXFyds3rxZKFu2rGBpaSncv3+/0PL+/v6Ct7e3kJiYKCQmJgr//vuv8PHHHwsAhODgYNV5fn5+gq+vr1rZHTt2CACEY8eO5XvtN9+vtG3rLVu2VHtPSkpKEmxtbQVfX1/h5cuXanW93la1+TdPRKZB13u0Xbt2CQCE2bNnq13vvffeEyQSiXDr1i1BEIrnHik2NlYAIKxfv151ToMGDQQXFxfh6dOnqn2XLl0SpFKpMHDgwEJfg++//16QSqXCr7/+qrZ/9erVAgDht99+U+2rVKmS2vv3rFmzBGtra+HGjRtqZadMmSKYmZkJ9+7dEwRBELZv3y4AEJYuXao6Jzs7W2jbtm2e5/Lm/ZU2r6Gmnye5z6Wge5HXTZ8+XQAg7NixI8+x3M+Y3HuXqlWrqt3LZmZmCi4uLkKdOnXUPp/27t0rABCmT58uCIIgPH/+XAAgLFiwoMA4NL2fzC/G8uXL5/mc27p1qwBAOHnypGpffvfhH330kWBlZaV2nzho0KA8r11+fwu5XK52X3b16lXBzMwsz31YfvUGBgYKVatWVdtXu3Ztwd/fP8+5ua9/7n2Hpq977nMBIMycOVPtmg0bNhR8fHzy1PW65ORkQSaTCZ988ona/i+++EKQSCSq575kyZI893KaKug7nqbvF926dRNq165daB0LFixQ++5CpC8lYrgTAPTq1QsvX77E3r17kZqair179xbYjRYALC0tVf/9/PlzJCcno1WrVrhw4YJW9Y4cOVKr89PS0tC9e3c4Ojrihx9+UGXY87Nv3z4AORO9vu7NX3wEQcD27dsRHBwMQRDw5MkT1RYYGIjk5ORCn9euXbugVCoxffr0PON7c7vFHj58GJmZmRg/frzaOSNGjICdnR1+/vlntXI2NjZq82JYWFigadOm+O+//wqMQ1u5mfq9e/fi1atXGpXJzs7GL7/8gpCQELVulO7u7ujXrx9OnTql6kKb68MPP1TrHtyqVStkZ2fj7t27Bdbz7NkzHD16FL169VL1XHny5AmePn2KwMBA3Lx5M0+3UF3q0cX06dNx6NChPJuTkxOAnL/5wYMHMXv2bFU7DQ0NRaVKldC7d+8SNUO9o6MjOnbsiB9++AFAzhwIzZs3V/UWKoqAgAA4OzvD09MTffr0gY2NDXbu3Iny5cu/tey1a9fg7OwMZ2dnvPPOO/jqq6/QuXNnta60AwcOxO+//67WZTw6Ohqenp7w9/d/ax26tPURI0aovScdOnQIqampmDJlSp6eO292mTfEv3kiKpm0uUfbt28fzMzM8tz7fPLJJxAEAfv371edBxTvPdKjR49w8eJFDB48WPUZCQD16tVD+/btVTEUZNu2bXjnnXfg7e2tVm/u8Nhjx44VWrZVq1ZwdHRUKxsQEIDs7GycPHkSQE7PbHNzc4wYMUJVViqVqnpJFEbT11Dbz5M7d+5oNKRj+/btqF+/fp6exUDez5hBgwap3bufO3cOjx8/xujRo9U+nzp37gxvb2/VfamlpSUsLCxw/PhxPH/+PN84dLmfzI3x/fffx759+/DixQvV/i1btqB8+fJqk2W/HnvufWGrVq2Qnp6uWjVTE9nZ2Th48CBCQkLUFr145513EBgYmOf81+tNTk7GkydP4O/vj//++w/Jycka15tL09f9dW9+V2rVqtVb7w3s7OwQFBSErVu3qo1U2LJlC5o1a6Z67rl/u59++kmrFTILos37hYODA+7fv48///yzyPUSaavEJGmcnZ0REBCAmJgY7NixA9nZ2YVOjrp37140a9YMcrkcTk5OcHZ2xqpVq7R+w6pSpYpW548YMQK3b9/Gzp073zos4u7du5BKpXmGWNWsWVPtcWJiIpKSkvDNN9+ovvjlbkOGDAGQMzSoILdv34ZUKkWtWrUKjSW/ui0sLFC1atU8iYQKFSrk+YB1dHQs8ANSF/7+/ujZsydmzJiBcuXKoVu3bli/fn2h47wTExORnp6e53kAOR9wSqUScXFxavvfXPnJ0dERAAp9Lrdu3YIgCJg2bVqev0lERASAvH8TXerRRd26dREQEJBne33mfplMhqlTp+Lff//Fw4cP8cMPP6BZs2bYunWr2vCbonj27Bni4+N12jIzMzWup1+/fqpuzbt27So0eauNFStW4NChQzh27BiuXr2K//77T3WD9OLFC7V435xbpnLlyjh06BAOHz6MU6dOIT4+Hnv37lXr2t27d2/IZDJER0cDyLm52rt3L/r375/vnE1v0qWtv/l+lpsg0mT+HkP8myeikkmbe7S7d+/Cw8MDtra2avtzVwrMvd8wxD1SQfc+ufE8efJENTQ0Pzdv3sSVK1fy1FujRo1C680te+DAgTxlc4fP55a9e/cu3N3d86wqWK1atQKv/frz0/Q11PbzRBO3b9/WeH64Nz+fCvvbeHt7q47LZDLMnz8f+/fvh6urK1q3bo0vvvgC8fHxqvM1uZ9MTExU+1zPTcr07t0bL1++VM03+OLFC+zbtw/vv/++2mfilStX0L17d9jb28POzg7Ozs6qHza0+e6RmJiIly9fonr16nmO5fda/PbbbwgICFDNp+Ts7Kyar0WXJI2mr3suuVyeZ3iPpvcGvXv3RlxcHM6cOQMgp72cP38evXv3VjunRYsWGD58OFxdXdGnTx9s3bpV54SNNu8Xn376KWxsbNC0aVNUr14doaGhbx1mRaQvJWoyin79+mHEiBGIj49HUFBQgasG/frrr+jatStat26NlStXwt3dHebm5li/fn2+k2EW5vUM9dssW7YMP/zwAzZt2oQGDRpoVU9hct+IPvjggwLHINerV09v9WmioB5Cr2fDC1LQF9A3JxmTSCT48ccfcfbsWezZswcHDx7E0KFDsWjRIpw9e1ZvSw/r8lxy/yYTJ07M95cNIO8NVFFes+Lk7u6OPn36oGfPnqhduza2bt2KDRs2FHmumh49euDEiRM6lT127JhqUru36dq1K2QyGQYNGgSFQoFevXrpVOebmjZtqjZx3esWLlyIGTNmqB5XqlRJ7VdFa2vrPPNUvcnR0RFdunRBdHQ0pk+fjh9//BEKhaJYV8/S5v3sTcbafonIOGh6j6ZvYt4jKZVK1K1bF4sXL873uKenZ6Fl27dvj8mTJ+d7PDfRYyqK8vk0fvx4BAcHY9euXTh48CCmTZuGqKgoHD16FA0bNtTofrJJkyZqCYiIiAhERkaiWbNmqFy5MrZu3Yp+/fphz549ePnypVoiISkpCf7+/rCzs8PMmTPh5eUFuVyOCxcu4NNPP9VLD5D83L59G+3atYO3tzcWL14MT09PWFhYYN++fViyZEmx1fu6wkYMvE1wcDCsrKywdetWNG/eHFu3boVUKlWb/8fS0hInT57EsWPH8PPPP+PAgQPYsmUL2rZti19++UXr+rV5v3jnnXdw/fp17N27FwcOHMD27duxcuVKTJ8+Xe0ekKg4lKgkTffu3fHRRx/h7NmzhU62un37dsjlchw8eBAymUy1f/369XnO1eQXa038+uuvmDhxIsaPH4/+/ftrVKZSpUpQKpW4ffu2Wsb6+vXrauflzsifnZ391i9++fHy8oJSqcTVq1cLTB7lDg+5fv26WlfXzMxMxMbG6lRvQXJ7kCQlJandxBU07KdZs2Zo1qwZ5syZg5iYGPTv3x+bN2/G8OHD85zr7OwMKyurPK8hkDMERSqVFnrTpKnc18jc3Fyvr42YzM3NUa9ePdy8eRNPnjyBm5tbka63aNEinXtZ1K9fX+NzLS0tERISgk2bNiEoKEitt0pxGThwYIHdnLW9Trdu3fDnn38iOjoaDRs2RO3atTUqq4+2nvvr6uXLlzX6VZaIqCCa3qNVqlQJhw8fRmpqqlpvmtwhIbn3I4a4R3r93udN165dQ7ly5WBtbV1geS8vL1y6dAnt2rXT+n7Sy8sLL168eGvMlSpVwrFjx5Cenq7Wm+bWrVtvrUOb17A47p28vLxw+fJlrcsB6n+b3OFjua5fv55nWLOXlxc++eQTfPLJJ7h58yYaNGiARYsWYdOmTapzCrufjI6OxsuXL1Xnvn4v3KtXLyxbtgwpKSnYsmULKleujGbNmqmOHz9+HE+fPsWOHTvQunVr1X5dVoN0dnaGpaUlbt68mefYm3+fPXv2QKFQYPfu3Wq9tfMbZqdp+9T2dS8Ka2trdOnSBdu2bcPixYuxZcsWtGrVCh4eHmrnSaVStGvXDu3atcPixYsxd+5cTJ06FceOHSv0309+z1nb9wtra2v07t0bvXv3RmZmJnr06IE5c+YgPDwccrlcb98jid5UYoY7ATlzIqxatQqRkZEIDg4u8DwzMzNIJBK1nhl37tzJd5Z9a2vrIs/B8ejRI/Tq1QstW7bUagb33FUQ3lz5IHdG/1xmZmbo2bMntm/fnu+H3duWcQ4JCYFUKsXMmTPzZNVzfwXPHQ7z5Zdfqv0yvnbtWiQnJ+e7EoCucr8Y5o63BqBaJu91z58/z/MrfW6SqaAhT2ZmZujQoQN++ukntZ4NCQkJiImJQcuWLWFnZ1fk5+Di4oI2bdrg66+/xqNHj/IcF2NpbU3dvHkT9+7dy7M/KSkJZ86cgaOjo15mpvfx8cl32JUmW24iT1MTJ05EREQEpk2bVuS4NVG1alW1ePNbzlwTuUml+fPn48SJE1r1otFHW+/QoQNsbW0RFRWVZzUs9pAhIm1oeo/WqVMnZGdnY/ny5Wr7lyxZAolEoro3MsQ9kru7Oxo0aICNGzeq3QtevnwZv/zyCzp16lRgWSDny/uDBw+wZs2aPMdevnxZ6FCpXr164cyZMzh48GCeY0lJScjKygIABAYG4tWrV2p1KJVKrFixotDYAO1eQ20+TzRdgrtnz564dOkSdu7cmefY2z5jGjduDBcXF6xevVrtnm///v34999/Vfel6enpeT6/vLy8YGtrqyqnyf1kixYt1D7XX0/S9O7dGwqFAhs3bsSBAwfy9NjN7c3xeh2ZmZlYuXJloc8xP2ZmZggMDMSuXbvU7tX+/fffPG0lv3qTk5Pz/VFa0+87mr7u+tK7d288fPgQ3377LS5duqTWQwnIGTr/prd9F8iV33PW5v3i6dOnascsLCxQq1YtCIKgmtsoN4lbkuZzpJKhRPWkAaDRkoOdO3fG4sWL0bFjR/Tr1w+PHz/GihUrUK1aNfz9999q5/r4+ODw4cNYvHgxPDw8UKVKlTzL1r7Nxx9/jMTEREyePBmbN29WO1avXr0Cu9k2aNAAffv2xcqVK5GcnIzmzZvjyJEj+f46Mm/ePBw7dgy+vr4YMWIEatWqhWfPnuHChQs4fPhwvm9iuapVq4apU6di1qxZaNWqFXr06AGZTIY///wTHh4eiIqKgrOzM8LDwzFjxgx07NgRXbt2xfXr17Fy5Uo0adJEr0MwOnTogIoVK2LYsGGYNGkSzMzMsG7dOjg7O6t9IG3cuBErV65E9+7d4eXlhdTUVKxZswZ2dnaF3jjNnj0bhw4dQsuWLTF69GiUKVMGX3/9NRQKBb744gu9PY8VK1agZcuWqFu3LkaMGIGqVasiISEBZ86cwf3793Hp0iW91aWNX3/9Nd/lp3Pb4qVLl9CvXz8EBQWhVatWcHJywoMHD7Bx40Y8fPgQS5cuLVL3VTHUr19f4943r169wuzZs/Psd3JywujRo/UdWqHMzc3Rp08fLF++HGZmZujbt69W5Yva1u3s7LBkyRIMHz4cTZo0Qb9+/eDo6IhLly4hPT09T+KUiKgwmtyjBQcH491338XUqVNx584d1K9fH7/88gt++uknjB8/XvVDjqHukRYsWICgoCD4+flh2LBhqiW47e3tERkZWehzGTBgALZu3YqRI0fi2LFjaNGiBbKzs3Ht2jVs3boVBw8eLHDY7KRJk7B792506dIFgwcPho+PD9LS0vDPP//gxx9/xJ07d1CuXDmEhISgadOm+OSTT3Dr1i14e3tj9+7dqudU2C/52ryG2nyeaLoE96RJk/Djjz/i/fffx9ChQ+Hj44Nnz55h9+7dWL16daGf2+bm5pg/fz6GDBkCf39/9O3bV7UUdOXKlTFhwgQAwI0bN9CuXTv06tULtWrVQpkyZbBz504kJCSgT58+AHS/n8zVqFEj1b20QqHIk0ho3rw5HB0dMWjQIHz88ceQSCT4/vvvdf6xY8aMGThw4ABatWqF0aNHIysrC1999RVq166t9j2mQ4cOsLCwQHBwMD766CO8ePECa9asgYuLS54fEH18fLBq1SrMnj0b1apVg4uLS56eMoDmr7u+dOrUCba2tpg4caIqgfK6mTNn4uTJk+jcuTMqVaqEx48fY+XKlahQoYJaj+b8FPQdT9P3iw4dOsDNzQ0tWrSAq6sr/v33XyxfvhydO3dW9QL08fEBAEydOhV9+vSBubk5goODC+2BR6QRA64kpbXXl3csTH5LcK9du1aoXr26IJPJBG9vb2H9+vX5Lv187do1oXXr1oKlpaUAQLVUW37L9+Z68zq5y9Pmt72+pF5+Xr58KXz88cdC2bJlBWtrayE4OFiIi4vLt2xCQoIQGhoqeHp6Cubm5oKbm5vQrl074Ztvvim0jlzr1q0TGjZsKMhkMsHR0VHw9/cXDh06pHbO8uXLBW9vb8Hc3FxwdXUVRo0aJTx//lztHH9//3yXpCtoWcE3l+AWBEE4f/684OvrK1hYWAgVK1YUFi9enGcJ7gsXLgh9+/YVKlasKMhkMsHFxUXo0qWLcO7cuTx1vPlaXbhwQQgMDBRsbGwEKysr4d133xVOnz6tdk5B7evN5QgLc/v2bWHgwIGCm5ubYG5uLpQvX17o0qWL8OOPP+q1nlxFWYI79zVKSEgQ5s2bJ/j7+wvu7u5CmTJlBEdHR6Ft27Zqcb/JGJfgLkxBS3AX9Pp4eXkJgqD5+05BCvr3UZA//vhDACB06NDhrefmt5xkUdp6rt27dwvNmzcXLC0tBTs7O6Fp06bCDz/88NbnlN+/eSIyDUW5R0tNTRUmTJggeHh4CObm5kL16tWFBQsWqJZlzqXve6T8luAWBEE4fPiw0KJFC9V7YHBwsHD16lWNXofMzExh/vz5Qu3atVX3Vz4+PsKMGTOE5ORktdfhzffv1NRUITw8XKhWrZpgYWEhlCtXTmjevLmwcOFCITMzU3VeYmKi0K9fP8HW1lawt7cXBg8eLPz2228CAGHz5s2q8/K7z9XmNdTk8yT3uWj63v/06VNhzJgxQvny5QULCwuhQoUKwqBBg1TLH+feu2zbti3f8lu2bFHduzo5OQn9+/cX7t+/rzr+5MkTITQ0VPD29hasra0Fe3t7wdfXV9i6dava89LkfrIwU6dOFQAI1apVy/f4b7/9JjRr1kywtLQUPDw8hMmTJwsHDx7Mc5+nyRLcgiAIJ06cEHx8fAQLCwuhatWqwurVq/P9++7evVuoV6+eIJfLhcqVKwvz588X1q1bl2dZ6Pj4eKFz586Cra2tAEC1HHdB96Jve91zn4u1tXWe1yK/OAvTv39/AYAQEBCQ59iRI0eEbt26CR4eHoKFhYXg4eEh9O3bN8/S9fkp6DueIGj2fvH1118LrVu3FsqWLSvIZDLBy8tLmDRpktq/a0EQhFmzZgnly5cXpFIpl+MmvZEIAvu0ExGJ5dKlS2jQoAG+++47DBgwQOxwiIioBNi1axe6d++OU6dO6TzkloiIjFOJmpOGiKi0WbNmDWxsbNCjRw+xQyEiIiP0+oS2QM5qmF999RXs7OzQqFEjkaIiIqLiUuLmpCEiKg327NmDq1ev4ptvvsGYMWM4fpmIiPI1duxYvHz5En5+flAoFNixYwdOnz6NuXPnFmnpaiIiMk4c7kREJILKlSsjISEBgYGB+P7779WWoiUiIsoVExODRYsW4datW8jIyEC1atUwatQojBkzRuzQiIioGDBJQ0RERERERERkBDgnDRERERERERGREWCShoiIiIiIiIjICDBJQ0RERERERERkBEr86k5KpRIPHz6Era0tJBKJ2OEQEZUKgiAgNTUVHh4ekEoNm8/PyMhAZmZmka5hYWEBuVyup4hMDz9biYiIiPRL0/vrEp+kefjwITw9PcUOg4ioVIqLi0OFChUMVl9GRgYsbcsCWelFuo6bmxtiY2OZqNERP1uJiIiIisfb7q9LfJImd9laiybjISkjEzWWe3s/E7V+KtyrLKXYIQAAzMtwlCEZv9SUFFSr4mnwpcEzMzOBrHTIag8BzCx0u0h2JuKvrEdmZiaTNDrK/bvHxcXBzs5O5GiIiIiISr6UlBR4er79/rrEJ2lyu2FLyshET9LwRta4MUlDpD3RhrqYWUCiY5JG0HMopij3725nZ8fPNiIiIiI9etv9dYlP0hARUSkkAaBrgohTqBARERFRCcUkDRERGR+JNGfTtSwRERERUQnEJA0RERkfiaQIPWnYlYaIiIiISiYmaYiIiIiIiKjUUSqVOYsSEBmAubk5zMzMinwdJmmIiMj4cLgTERERFUFmZiZiY2OhVBrH4iFkGhwcHODm5lakxTeYpCEiIuPD4U5ERESkI0EQ8OjRI5iZmcHT0xNSKX/AoeIlCALS09Px+PFjAIC7u7vO12KShoiIjFARetKAN2JERESmLCsrC+np6fDw8ICVlZXY4ZCJsLS0BAA8fvwYLi4uOg994p0sERERERERlRrZ2dkAAAsLC5EjIVOTmxR89eqVztdgTxoiIjI+HO5ERERERVSUeUGIdKGPNmeSPWn2LBqAP9aPwtm1I3H4q6GoX90NAHBty3hc2jQWZ9eOxNm1I/Fe29oiR0rGYFLYONSpWRV2lmb4+9JFscMhMg25EwfrupUSJ0+eRHBwMDw8PCCRSLBr1663ljl+/DgaNWoEmUyGatWqYcOGDcUeJxEREZEmIiMj0aBBA9XjwYMHIyQkpNAybdq0wfjx44tct76uU9yMoifNihUrsGDBAsTHx6N+/fr46quv0LRp02Kr74OIbUh+kQEA6NrKG9+Ed4fv0FUAgAGR2/D3rfhiq5tKnpAePTE+bBIC27UWOxQi08GeNACAtLQ01K9fH0OHDkWPHj3een5sbCw6d+6MkSNHIjo6GkeOHMHw4cPh7u6OwMBAA0RMREREpLlly5ZBEAS9XvP48eN499138fz5czg4OKj279ixA+bm5nqtqziInqTZsmULwsLCsHr1avj6+mLp0qUIDAzE9evX4eLiUix15iZoAMDOWq73RkGlS4uWTM4QlWarVq3CqlWrcOfOHQBA7dq1MX36dAQFBQHI+dXlxIkTamU++ugjrF69uthjCwoKUsWhidWrV6NKlSpYtGgRAOCdd97BqVOnsGTJEiZpiIjI5Ek+2WPQ+oRFwcV6/VevXpWIpENh7O3tDVaXk5OTweoqCtH7hC9evBgjRozAkCFDUKtWLaxevRpWVlZYt25dsdb77WfdcfPHMEQMb4thc3b8b//U7vhzw2is+rQbytlzJnAiIlEYcLhThQoVMG/ePJw/fx7nzp1D27Zt0a1bN1y5ckV1zogRI/Do0SPV9sUXX+j7GevFmTNnEBAQoLYvMDAQZ86cKbScQqFASkqK2gYASqWSGzdu3LhxK5GbIAh5NkPLL4a3bdnZ2Zg/fz6qVasGmUyGihUrYvbs2YiNjYVEIsHmzZvh7+8PuVyOTZs2ITs7GzNmzECFChUgk8nQoEED7N+/X3U9hUKB0NBQuLu7Qy6Xo1KlSpg7dy4EQYBSqURERAQqVqwImUwGDw8PjB07Nt+4kpOTYWlpiX379qnt37FjB2xtbZGWlgZBEDB58mTUqFEDVlZWqFq1Kj7//HNkZmbm+Tvk/nfucKfcxy9evMDAgQNhY2MDd3d3LFy4MM9r+d1336Fx48awtbWFm5sb+vXrh4SEBAiCgNjYWLz77rsAAEdHR0gkEgwePBiCIKBNmzYYN26c6jrPnj3DwIED4ejoCCsrKwQFBeHGjRuq4+vXr4eDgwMOHDiAd955BzY2NujYsSMePnz41r9jQe1SE6L2pMnMzMT58+cRHh6u2ieVShEQEFDgDaVCoYBCoVA9zr2R1NbwuTsBAP071sfske3RfXI02o9dj7jHyShjJkXkiHZYM7U7uk+O1un6RERUBAYc7hQcrP4r15w5c7Bq1SqcPXsWtWvnzE1mZWUFNzc33eIxoPj4eLi6uqrtc3V1RUpKCl6+fKlaGvJNUVFRmDFjRp79iYmJyMjIyKcEERGR8Xr16hWUSiWysrKQlZUlWhy61B0eHo5169ZhwYIFaNGiBeLj43H9+nXVtcLDwzF//nysWbMGcrkcS5YsweLFi7FixQo0aNAAGzZsQLdu3XDx4kVUr14dS5cuxZ49exATEwNPT0/cv38fcXFxyMrKwvbt27F06VJs2rQJtWrVQkJCAv7+++9847ayskKnTp0QHR2N9u3bq/Zv2rQJXbt2hYWFBbKysmBtbY1vv/0W7u7uuHz5MkaNGgVra2tMnDgRAFQJtNw6cpMXuY8nTpyIEydOYPv27XB2dsa0adNw4cIF1KtXT3WOQqFAREQEatSogcTEREyaNAmDBw/G7t274e7uji1btqB37964fPky7OzsYGlpiaysLFUCJfc6gwYNwq1bt1SJpqlTp6Jz5864dOkSzM3NoVQqkZ6ejoULF2L9+vWQSqUYNGgQPvnkE3z33XcF/s2VSiWePn2ap5dTamqqRm1A1CTNkydPkJ2dne8N5bVr1/ItU9CNpK6iD1zCV58Ew8nOEnGPkwEAWdlKLN92Bn9Hf6y3eoiISAtFmQD4/8u9mcSXyWSQyWSFFs3Ozsa2bduQlpYGPz8/1f7o6Ghs2rQJbm5uCA4OxrRp01RLLJYG4eHhCAsLUz1OSUmBp6cnnJ2dYWdnJ2JkRERE2svIyEBqairKlCmDMmXE+8qrbd2pqalYvnw5vvrqKwwdOhQAULNmTfj7+6uGZY8bNw7vv/++qsySJUswefJk9O/fHwCwYMECnDx5EsuXL8eKFStw//59VK9eHf7+/pBIJPDy8lKVffDgAdzc3BAYGAhzc3NUrVpV7f7nTR988AEGDhyIzMxMWFlZISUlBfv378eOHTtUz3X69Omq86tVq4Zbt25hy5YtmDJlCoCcThkSiUR1vlQqhVQqRZkyZfDixQusX78e33//PTp06AAA+O677+Dp6alWZvjw4ao6atSogS+//BJNmzZFRkYGbGxs4OzsDADw8PBQm5NGIpGornPz5k3s3bsXp06dQvPmzQHk3O9VrFgRe/fuxfvvvw+pVIpXr15h9erVqtdtzJgxmDVrVoF/2zJlykAqlaJs2bKQy+Vqx958XBDR56TRVkE3kpqyt5HDSmaOR09zsljBLb3xLDkdGZlZsLeRq+ar6dWuLi7dfKTf4ImIyGDe/GyIiIhAZGRkvuf+888/8PPzU32479y5E7Vq1QIA9OvXD5UqVYKHhwf+/vtvfPrpp7h+/Tp27NiR77XE5ObmhoSEBLV9CQkJql+RClJQAiv3xomIiKgkyU0E5G5i0bbua9euQaFQICAgIE/Z3MdNmjRR/XdKSgoePnyIli1bqp3fokULXLp0CRKJBEOGDEH79u3h7e2Njh07okuXLqoESK9evbBs2TJ4eXmhY8eO6NSpE4KDg1GmTBnMnTsXc+fOVV3z6tWr6Ny5M8zNzbFnzx706dMHO3bsgJ2dHdq3b6+qf8uWLfjyyy9x+/ZtvHjxAllZWbCzs1Mdf/P/X39+//33HzIzM9GsWTPV8bJly6JmzZpqf8vz588jMjISly5dwvPnz1XDiOLi4lCrVi21OvKrRyKR4Nq1ayhTpoxaXeXKlUPNmjVx7do11XlWVlaoVq2aqryHhwceP35c4N82t1x+91Ca3lOJmqQpV64czMzM8r2hLKhbuSa/hBbG3lqG6Jm9IJeZQ6kU8CQpDT2mxMDF0QY/zOoNM7OcFzX24XMMm7NT53qo9Bg3ZiQO7t+HhIR4dO8aBBsbW1y6ckPssIhKN4mkCD1pcj404+Li1HqBFPbZUbNmTVy8eBHJycn48ccfMWjQIJw4cQK1atXChx9+qDqvbt26cHd3R7t27XD79m21X6OMgZ+fH/bt26e279ChQ4X+KkZERETGobAfVHJZW1trdc1GjRohNjYW+/fvx+HDh9GrVy8EBATgxx9/hKenJ65fv47Dhw/j0KFDGD16NBYsWIATJ05g5MiR6NWrl+o6Hh4eKFOmDN577z3ExMSgT58+iImJQe/evVW9Ss6cOYP+/ftjxowZCAwMhL29PTZv3qxa0EAf0tLSEBgYiMDAQERHR8PZ2Rn37t1DYGAgMjMz9VZPrjeHLEkkkmKf30jUJI2FhQV8fHxw5MgR1droSqUSR44cwZgxY4qlznsJyWj10Zp8j/kNL/6VOqjkWbac7YLI4KSSnE3XsgDs7Ow0HqpjYWGh+pXEx8cHf/75J5YtW4avv/46z7m+vr4AgFu3bhV7kubFixe4deuW6nFsbCwuXrwIJycnVKxYEeHh4Xjw4IFqXPTIkSOxfPlyTJ48GUOHDsXRo0exdetW/Pzzz8UaJxERERVd9erVYWlpiSNHjqgN6SmInZ0dPDw88Ntvv8Hf31+1/7fffkPTpk3Vzuvduzd69+6N9957Dx07dsSzZ8/g5OQES0tLBAcHIzg4GKGhofD29sY///yDRo0a5bsaUv/+/dG+fXtcuXIFR48exezZs1XHTp8+jUqVKmHq1KmqfXfv3tX4+Xt5ecHc3By///47KlasCAB4/vw5bty4oXp+165dw9OnTzFv3jxVr+lz586pXcfCwgJAzjD2grzzzjvIysrC77//rhru9PTpU1y/fl3Vm1osog93CgsLw6BBg9C4cWM0bdoUS5cuRVpaGoYMGSJ2aEREJBY9zElTFEqlUm2S+tddvHgRAODu7l7ket7m3LlzqhUKAKiG+w4aNAgbNmzAo0ePcO/ePdXxKlWq4Oeff8aECROwbNkyVKhQAd9++y2X3yaTYOildQ2huJfvJSLjIpfL8emnn2Ly5MmwsLBAixYtkJiYiCtXrqBdu3b5lpk0aRIiIiLg5eWFBg0aYP369bh48SKio3MWwFm8eDHc3d3RsGFDSKVSbNu2DW5ubnBwcMCGDRuQnZ0NX19fWFlZYdOmTbC0tESlSpUKjLF169Zwc3ND//79UaVKFdWPV0BOkunevXvYvHkzmjRpgp9//hk7d2o+OsXGxgbDhg3DpEmTULZsWbi4uGDq1Klqw4QqVqwICwsLfPXVVxg5ciQuX76MWbNmqV2nUqVKkEgk2Lt3Lzp16gRLS0vY2NionVO9enV069YNI0aMwNdffw1bW1tMmTIF5cuXR7du3TSOuTiInqTp3bs3EhMTMX36dMTHx6NBgwY4cOBAnsmEiYiIikN4eDiCgoJQsWJFpKamIiYmBsePH8fBgwdx+/ZtxMTEoFOnTihbtiz+/vtvTJgwAa1bt0a9evWKPbY2bdoU2qV2w4YN+Zb566+/ijEq/eOXayIyJnxPIn05F5ekdZmgwWORkPYKU6Z+jsSEeJRzcUWP/kPg/E7OgghX4lOR9dp1m3cfiD73EvDx+DA8e5qIKtVrYuHaGCTLnXEuLglPX5nh6zlRiIv9D1IzKWrVa4SF67bgwoMUPMkyx8aVKxA7YQKU2UpU866FhWt/QGy6GWLT84+9sacD+vbtiy+++EJtkmAA6Nq1KyZMmIAxY8ZAoVCgc+fOmDZtWoFzAuZnwYIFePHiBYKDg2Fra4tPPvkEycnJquPOzs7YsGEDPvvsM3z55Zdo1KgRFi5ciK5du6rOKV++PGbMmIEpU6ZgyJAhGDhwYL73TOvXr8e4cePQpUsXZGZmonXr1ti3b1+eIU6GJhHEWDBej1JSUmBvbw+Z36eQlNF9rhp9eH5Uf6tOkf69ytJsXfriZl6Gk3CS8UtJSYFrWXskJycbdHUf1Xt662mQlNFsBvw3CVkZUJycpXHsw4YNw5EjR/Do0SPY29ujXr16+PTTT9G+fXvExcXhgw8+wOXLl5GWlgZPT090794dn3/+eale9Sj372Covz+/EJE+sB2RvrAtlXwZGRmIjY1FlSpVNF5RpzjokqQxdo09HcQOwagV1vY0vb8SvScNERFRHgYc7rR27doCj3l6euLEiRO6xUEm7dEG8VYTKQ7ug0v0b3olVmlrRwDbkljYlkhfMp+ce/tJJYhFucZih5AHkzRERGR8JBLVKk06lSUiIiIiKoE47oKIiIiIiIiIyAiwJw0RERkfkVd3IiIiIiISA5M0RERkfDjciYiIiIhMEJM0RERkfNiThoiIiIhMEO9kiYiIiIiIiIiMAHvSEBGR8eFwJyIiIiIyQUzSEBGRESrCcCd2EiUiIiKiEqrUJGnu7f0MdnZ2osbg2DZC1Ppf9/gX44jFvIzxfFkypliI6C3Yk4aIiIiITBC/tRIRERERERGJ7KNeXbAoMlxv14sMG42Jw/vr7XpkGKWmJw0REZUiEkkRVndiTxoiIiLK69EGA98jtHtu2PqoVGBPGiIiMj65S3DruhERERGVIJFho3Hh7G/YvG41mlR0RJOKjngYdw+3rl/FxwPfQ2vvCghsVAPTx32EpGdPVeWO/PwT+rRvjpbV3RFQrypG9w3By/Q0fLN4Hn7+8Qec+GWf6nrnz5wS8RmSptiThoiIjA/npCEiIiITMjEyCvdib8GrRi189EnOkKcy5uYY3LUduvUZgLDpc6HIyMBXUZEIHz0EqzbvxpOEeEwdOxwffzYDbQK7ID0tFX/9cQaCIOCDj8Yg9tYNpL1IwfSFKwAA9g6OYj5F0hCTNEREREREREQisrGzh7m5BeSWlijn4goAWPvlQtSsXQ+hn05XnTdt4Vfo4lsHd/+7hZdpacjOysK7HbvAvUJFAEA179qqc2VyOV5lKlTXo5KBSRoiIjI+RRm2xOFOREREVArcvHoZ5878itbeFfIcu383Fs1at0WTFv7o26ElmrVuC9/W76Jdp26wc3AwfLCkN0zSEBGR8eFwJyIiIjJx6ekv0CqgI8aGR+Y5Vs7FFWZmZlgRsxN/n/sdZ08ew9YN32DVgtlY/9NhlK9YyfABk17w50YiIjI+nDiYiIiITIy5uQWUymzVY+869fHfjWtwr1ARnpWrqm2WVtYAAIlEgvpNmuGjT8Kxaf9JmJtb4PjBvarrZWdn51sXGS/eyRIRERERERGJzL1CRVz+6zwext1D0rOneH/gcKQkPcfnY4bjyqULuH8nFmdOHMGMT0KRnZ2Ny3+dw/rli3D10l+IfxCHY/v34PmzJ6hcrQYAwMPTE7euXcGd2zeR9Owpsl69EvkZkiaYpCEiIuOTO9xJ142IiIiohPngozEwMzNDr3bN0L5BNbx69Qrf7jiAbGU2xvbvgT4dWmDxjM9ga2cPqVQKaxtbXPj9DMYP7oWebZpg1cI5GP/5LLR4tz0AIKTvIFSqWh2DurRF+wbVcOnc7yI/Q9IE56QhIiKjI5FIIOGcNERERKRH7oMFg9b3IC5Jq/MrVa2Gdbt+ybN/wTff53t+leo18dX3PxZ4Pcey5bA8eodWMZD4mKQhIiKjwyQNEREREZkiJmlEtGfRALg62UCpFPAiPROffLkPl27G49qW8VC8ysZLRc6YwYXRv+LHo1cMEtOksHHY//Me3Lt3F6fOnke9+g0MUi8RERERERGRqRM9SXPy5EksWLAA58+fx6NHj7Bz506EhISIHZZBfBCxDckvMgAAXVt545vw7vAdugoAMCByG/6+FW/wmEJ69MT4sEkIbNfa4HUTEalI/n/TtSwRERERUQkk+sTBaWlpqF+/PlasWCF2KAaXm6ABADtrOQTBsGMk89OiZWuUr1BB7DCIyMTlDnfSdSMiIiIiKolE70kTFBSEoKAgscMQzbefdYd/oyoAgJDJm/63f2p3SCQSnPv3AaatPoQnyelihUhEZHCck4aIiIiITJHoSRptKRQKKBQK1eOUlBQRoym64XN3AgD6d6yP2SPbo/vkaLQfux5xj5NRxkyKyBHtsGZqd3SfHC1ypERERERERCWHMYxUINOijzYn+nAnbUVFRcHe3l61eXp6ih2SXkQfuAT/hlXgZGeJuMfJAICsbCWWbzuDFvUqiRwdEZFhcbgTERER6crMzAwAkJmZKXIkZGrS03NGwJibm+t8jRLXkyY8PBxhYWGqxykpKSUyUWNvI4eVzByPnqYCAIJbeuNZcjoyMrNgbyNXzVfTq11dXLr5SMxQiYgMjsOdiIiISFdlypSBlZUVEhMTYW5uDqlUpL4JWaUvSZTxSuwI9EuZkfH2kzQgCALS09Px+PFjODg4qBKFuihxSRqZTAaZTCZ2GEVmby1D9MxekMvMoVQKeJKUhh5TYuDiaIMfZvWGmVnOF5TYh88xbM5Og8U1bsxIHNy/DwkJ8ejeNQg2Nra4dOWGweonIgLA1Z2IiIhIZxKJBO7u7oiNjcXdu3dFi+PJ89I3r6jc/InYIeiVWVKsXq/n4OAANze3Il2jxCVpSot7Cclo9dGafI/5DV9t4Gj+Z9ly8eomIiIiIiLSBwsLC1SvXl3UIU9BW4+JVndxOVljlNgh6JVL92t6u5a5uXmRetDkEj1J8+LFC9y6dUv1ODY2FhcvXoSTkxMqVqwoYmRERCQWDnciIiKiopJKpZDL5aLVfzclS7S6i4u5QryeScVBzPZRENGTNOfOncO7776repw738ygQYOwYcMGkaIiIiIxSSQoQpJGv7EQERERERmK6EmaNm3acGk0IiIiIiIiIjJ5oidpiIiI3iRBUZbSZlcaIiIiIiqZmKQhIiKjwzlpiIiIiMgUibRgPBERUSEkRdy0sGrVKtSrVw92dnaws7ODn58f9u/frzqekZGB0NBQlC1bFjY2NujZsycSEhKK+gyJiIiIiPJgkoaIiExahQoVMG/ePJw/fx7nzp1D27Zt0a1bN1y5cgUAMGHCBOzZswfbtm3DiRMn8PDhQ/To0UPkqImIiIioNOJwJyIiMj5FGO4kaFkuODhY7fGcOXOwatUqnD17FhUqVMDatWsRExODtm3bAgDWr1+Pd955B2fPnkWzZs10ipGIiIiIKD/sSUNEREYnd04aXTddZWdnY/PmzUhLS4Ofnx/Onz+PV69eISAgQHWOt7c3KlasiDNnzujjqRIRERERqbAnDRERGZ2iJFtyy6WkpKjtl8lkkMlk+Zb5559/4Ofnh4yMDNjY2GDnzp2oVasWLl68CAsLCzg4OKid7+rqivj4eJ3iIyIiIiIqCHvSEBFRqeTp6Ql7e3vVFhUVVeC5NWvWxMWLF/H7779j1KhRGDRoEK5evWrAaImIiIiI2JOGiIiMkQ6rNKmVBRAXFwc7OzvV7oJ60QCAhYUFqlWrBgDw8fHBn3/+iWXLlqF3797IzMxEUlKSWm+ahIQEuLm56RggEREREVH+2JOGiIiMjj7mpMldUjt3KyxJ8yalUgmFQgEfHx+Ym5vjyJEjqmPXr1/HvXv34Ofnp/fnTURERESmjT1p9Oj50Rlih6Di2DZC7BAAGNdrQkQlhz7mpNFUeHg4goKCULFiRaSmpiImJgbHjx/HwYMHYW9vj2HDhiEsLAxOTk6ws7PD2LFj4efnx5WdiIiIiEjvmKQhIiKT9vjxYwwcOBCPHj2Cvb096tWrh4MHD6J9+/YAgCVLlkAqlaJnz55QKBQIDAzEypUrRY6aiIiIiEojJmmIiMjoGLInzdq1aws9LpfLsWLFCqxYsUKneIiIiIiINMUkDRERGR1DJmmIiIiIiIwFkzRERGR89LC6ExERERFRScPVnYiIiIiIiIiIjAB70hARkdHhcCciIiIiMkVM0hARkdFhkoaIiIiITBGTNEREZHSYpCEiIiIiU8Q5aYiIiIzcihUrULlyZcjlcvj6+uKPP/4o9PylS5eiZs2asLS0hKenJyZMmICMjAwDRUtEREREumKShoiIjI+kiFspsmXLFoSFhSEiIgIXLlxA/fr1ERgYiMePH+d7fkxMDKZMmYKIiAj8+++/WLt2LbZs2YLPPvvMwJETERERkbaYpCEiIqOTO9xJ1600Wbx4MUaMGIEhQ4agVq1aWL16NaysrLBu3bp8zz99+jRatGiBfv36oXLlyujQoQP69u371t43RERERCQ+JmmIiMjoMEmTIzMzE+fPn0dAQIBqn1QqRUBAAM6cOZNvmebNm+P8+fOqpMx///2Hffv2oVOnTgaJmYiIiIh0J+rEwVFRUdixYweuXbsGS0tLNG/eHPPnz0fNmjXFDMvk7Fk0AK5ONlAqBbxIz8QnX+7DpZvxuLZlPBSvsvFS8QoAsDD6V/x49IrI0RIRmY4nT54gOzsbrq6uavtdXV1x7dq1fMv069cPT548QcuWLSEIArKysjBy5MhChzspFAooFArV45SUFACAUqmEUqnUwzMpnBRCsddhaEIp+x3MEO2gqNiOSga2JXGwLYmDbcn4GbIdaVqXqEmaEydOIDQ0FE2aNEFWVhY+++wzdOjQAVevXoW1tbWYoZmUDyK2IflFzoSSXVt545vw7vAdugoAMCByG/6+FS9meERkgiQowupOpW1SGi0dP34cc+fOxcqVK+Hr64tbt25h3LhxmDVrFqZNm5ZvmaioKMyYMSPP/sTERINMOOzjVOxVGFySuY/YIeiVtIA5kIwJ21HJwLYkDrYlcbAtGT9DtqPU1FSNzhM1SXPgwAG1xxs2bICLiwvOnz+P1q1bixSV6clN0ACAnbUcglD6Mr5EVLJwCe4c5cqVg5mZGRISEtT2JyQkwM3NLd8y06ZNw4ABAzB8+HAAQN26dZGWloYPP/wQU6dOhVSa9xew8PBwhIWFqR6npKTA09MTzs7OsLOz0+Mzyt/5Z8VehcE5lD8vdgh65eLiInYIb8V2VDKwLYmDbUkcbEvGz5DtSC6Xa3SeqEmaNyUnJwMAnJxKYcrRyH37WXf4N6oCAAiZvOl/+6d2h0Qiwbl/H2Da6kN4kpwuVohEZEqKskpT6cnRwMLCAj4+Pjhy5AhCQkIA5HSVPXLkCMaMGZNvmfT09DyJGDMzMwAoMAkvk8kgk8ny7JdKpfkmdfRNWZr+aP9PAuPvhq8NQ7SDomI7KhnYlsTBtiQOtiXjZ8h2pGldRpOkUSqVGD9+PFq0aIE6deoUeF5B4+apaIbP3QkA6N+xPmaPbI/uk6PRfux6xD1ORhkzKSJHtMOaqd3RfXK0yJESEZmWsLAwDBo0CI0bN0bTpk2xdOlSpKWlYciQIQCAgQMHonz58oiKigIABAcHY/HixWjYsKFquNO0adMQHBysStYQERERkXEymiRNaGgoLl++jFOnThV6XkHj5kk/og9cwlefBMPJzhJxj3N6NmVlK7F82xn8Hf2xyNERkangcKf/6d27NxITEzF9+nTEx8ejQYMGOHDggGoy4Xv37qn9MvP5559DIpHg888/x4MHD+Ds7Izg4GDMmTNHrKdARERERBoyiiTNmDFjsHfvXpw8eRIVKlQo9NyCxs2Tbuxt5LCSmePR05xJjIJbeuNZcjoyMrNgbyNXzVfTq11dXLr5SMxQiciEMEmjbsyYMQUObzp+/Lja4zJlyiAiIgIREREGiIyIiIiI9EnUJI0gCBg7dix27tyJ48ePo0qVKm8tU9C4edKNvbUM0TN7QS4zh1Ip4ElSGnpMiYGLow1+mNUbZmY5X5RiHz7HsDk7xQ6XiEyERJKz6VqWiIiIiKgkEjVJExoaipiYGPz000+wtbVFfHzOUs/29vawtLQUMzSTcS8hGa0+WpPvMb/hqw0cDREREREREZHpEnVK7FWrViE5ORlt2rSBu7u7atuyZYuYYRERkchyetJIdNzEjp6IiIiISDeiD3ciIiLKowjDnUrhapdEREREZCKMYuJgIiKi13HiYCIiIiIyRaIOdyIiIiIiIiIiohzsSUNEREaHqzsRERERkSlikoaIiIyOVCqBVKpbtkXQsRwRERERkdiYpCEiIqPDnjREREREZIo4Jw0RERERERERkRFgTxoiIjI6XN2JiIiIiEwRkzRERGR0ONyJiIiIiEwRkzRERGR02JOGiIiIiEwR56QhIiIiIiIiIjIC7ElTSj0/OkPsEAAAjk3GiB2CyvM/l4sdAhFpiD1piIiIiMgUMUlDRERGh3PSEBEREZEpYpKGiIiMjgRF6EkDZmmIiIiIqGTinDREREREREREREaAPWmIiMjocLgTEREREZki9qQhIiKjkztxsK6bNqKiotCkSRPY2trCxcUFISEhuH79uto5bdq0yVPHyJEj9fmUiYiIiIiYpCEiIuOT25NG100bJ06cQGhoKM6ePYtDhw7h1atX6NChA9LS0tTOGzFiBB49eqTavvjiCz0+YyIiIiIiDnciIiITd+DAAbXHGzZsgIuLC86fP4/WrVur9ltZWcHNzc3Q4RERERGRCWFPGiIiMjr6GO6UkpKitikUCo3qTk5OBgA4OTmp7Y+Ojka5cuVQp04dhIeHIz09Xb9PmoiIiIhMHnvSEBGR0dHHxMGenp5q+yMiIhAZGVloWaVSifHjx6NFixaoU6eOan+/fv1QqVIleHh44O+//8ann36K69evY8eOHboFSURERESUDyZpiIioVIqLi4OdnZ3qsUwme2uZ0NBQXL58GadOnVLb/+GHH6r+u27dunB3d0e7du1w+/ZteHl56S9oIiIiIjJpTNIQEZHR0WWVptfLAoCdnZ1akuZtxowZg7179+LkyZOoUKFCoef6+voCAG7dusUkDRERERHpDZM0RERkfIow3AlalhMEAWPHjsXOnTtx/PhxVKlS5a1lLl68CABwd3fXIUAiIiIiovwxSUNGZc/KULiWtYNSEPAiLQOffPEj4uKfY9/XY1XnWMktUKV8WVRsF47nKZy4k6g00kdPGk2FhoYiJiYGP/30E2xtbREfHw8AsLe3h6WlJW7fvo2YmBh06tQJZcuWxd9//40JEyagdevWqFevnk4xEhERERHlR9QkzapVq7Bq1SrcuXMHAFC7dm1Mnz4dQUFBYoZFIvpg8jokv3gJAOj6bj18M/MD+Paeh2Z95qnOGT+gHVr6VGOChoj0YtWqVQCANm3aqO1fv349Bg8eDAsLCxw+fBhLly5FWloaPD090bNnT3z++eciREtEREREpZmoSZoKFSpg3rx5qF69OgRBwMaNG9GtWzf89ddfqF27tpihkUhyEzQAYGdjCUHIe86gED9M/2q3AaMiIkPTx+pOmhLye6N5jaenJ06cOKFbMEREREREWhA1SRMcHKz2eM6cOVi1ahXOnj3LJI0J+3bWAPg3rgEACBm7Su1Ys/pV4GBnhX2/XhYjNCIyEEMOdyIiIiIiMhZGMydNdnY2tm3bhrS0NPj5+RV4nkKhgEKhUD1OSUkxRHhkQMOnfQ8A6B/si9njuqH7a4maQSF+iNn7O7KzlWKFR0QGYMieNERERERExkIqdgD//PMPbGxsIJPJMHLkSOzcuRO1atUq8PyoqCjY29urNk9PTwNGS4YUved3+DeuDid7awCAtaUFerZvhI0/nRU5MiIiIiIiIiL9Ez1JU7NmTVy8eBG///47Ro0ahUGDBuHq1asFnh8eHo7k5GTVFhcXZ8BoqTjZ21jC3dle9Ti4TT08S07Ds+Q0AMB7gT7458YD3LiTIFaIRGQgucOddN2IiIiIiEoi0Yc7WVhYoFq1agAAHx8f/Pnnn1i2bBm+/vrrfM+XyWSQyWSGDJEMxN5WjugvhkEus4BSUOLJ8xfo8fFq1fHBIX5Yt+O0iBESkaFwThoiIiIiMkWiJ2nepFQq1eacIdNx79FztBqwsMDj7w5ebMBoiEhMnJOGiIiIiEyRqEma8PBwBAUFoWLFikhNTUVMTAyOHz+OgwcPihkWEREREREREZHBiZqkefz4MQYOHIhHjx7B3t4e9erVw8GDB9G+fXsxwyIiIpFxuBMRERERmSJRkzRr164Vs3oiIjJSHO5ERERERKbI6OakISIiYk8aIiIiIjJFoi/BTURERERERERE7ElDRERGSIIiDHfSayRERERERIbDJA0RERkdqUQCqY5ZGl3LERERERGJjUkaIiIyOpw4mIiIiIhMEeekISIiIiIiIiIyAuxJQ0RERoerOxERERGRKWKShoiIjI5UkrPpWpaIiIiIqCRikoaIiIyPpAg9YpikISIiIqISinPSEBEREREREREZAfakoWL1/M/lYoeg4tg2QuwQAADPj84QOwQqAV5lKU26fq7uRERERESmSKMkTUpKisYXtLOz0zkYIiIiAJD8//90LUtEREREVBJplKRxcHB469wAgiBAIpEgOztbL4EREZHp4sTBRERERGSKNErSHDt2rLjjICIiIiIiIiIyaRolafz9/Ys7DiIiIhWJRKLz6k46rwpFRERERCQynVd3Sk9Px7Vr1/D333+rbUREREWVO3Gwrltps2LFClSuXBlyuRy+vr74448/Cj0/KSkJoaGhcHd3h0wmQ40aNbBv3z4DRUtEREREutJ6dafExEQMGTIE+/fvz/c456QhIqKikkokkOqYbdG1nLHasmULwsLCsHr1avj6+mLp0qUIDAzE9evX4eLikuf8zMxMtG/fHi4uLvjxxx9Rvnx53L17Fw4ODoYPnoiIiIi0onVPmvHjxyMpKQm///47LC0tceDAAWzcuBHVq1fH7t27iyNGIiIik7V48WKMGDECQ4YMQa1atbB69WpYWVlh3bp1+Z6/bt06PHv2DLt27UKLFi1QuXJl+Pv7o379+gaOnIiIiIi0pXWS5ujRo1i8eDEaN24MqVSKSpUq4YMPPsAXX3yBqKio4oiRiIhMDIc75cjMzMT58+cREBCg2ieVShEQEIAzZ87kW2b37t3w8/NDaGgoXF1dUadOHcydO5c9XYmIiIhKAK2HO6Wlpam6Vzs6OiIxMRE1atRA3bp1ceHCBb0HSEREpocTB+d48uQJsrOz4erqqrbf1dUV165dy7fMf//9h6NHj6J///7Yt28fbt26hdGjR+PVq1eIiIjIt4xCoYBCoVA9TklJAQAolUoolUo9PZuCSSEUex2GJug+7Z9RMkQ7KCq2o5KBbUkcbEviYFsyfoZsR5rWpXWSpmbNmrh+/ToqV66M+vXr4+uvv0blypWxevVquLu7ax0oERHRm4rSI6YU5Wh0olQq4eLigm+++QZmZmbw8fHBgwcPsGDBggKTNFFRUZgxY0ae/YmJicjIyCjukOHjVOxVGFySuY/YIeiV9PFjsUN4K7ajkoFtSRxsS+JgWzJ+hmxHqampGp2ndZJm3LhxePToEQAgIiICHTt2RHR0NCwsLLBhwwZtL0dEREQFKFeuHMzMzJCQkKC2PyEhAW5ubvmWcXd3h7m5OczMzFT73nnnHcTHxyMzMxMWFhZ5yoSHhyMsLEz1OCUlBZ6ennB2doadnZ2enk3Bzj8r9ioMzqH8ebFD0Kv8Jqk2NmxHJQPbkjjYlsTBtmT8DNmO5HK5RudpnaT54IMPVP/t4+ODu3fv4tq1a6hYsSLKlSun7eWIjNKeRQPg6mQDpVLAi/RMfPLlPly6GY9rW8ZD8SobLxWvAAALo3/Fj0eviBwt0f9MChuH/T/vwb17d3Hq7HnUq99A7JB0wtWdclhYWMDHxwdHjhxBSEgIgJyeMkeOHMGYMWPyLdOiRQvExMRAqVRCKs3pknzjxg24u7vnm6ABAJlMBplMlme/VCpVXaM4KVF6/ma5JDD+bvjaMEQ7KCq2o5KBbUkcbEviYFsyfoZsR5rWpXNEmZmZuH79OiwsLNCoUSO9JGjmzZsHiUSC8ePHF/laREXxQcQ2NB2yCs2GrcaXW0/jm/DuqmMDIreh2bDVaDZsNRM0ZHRCevTEwSMnUbFiJbFDKRJJEbfSJCwsDGvWrMHGjRvx77//YtSoUUhLS8OQIUMAAAMHDkR4eLjq/FGjRuHZs2cYN24cbty4gZ9//hlz585FaGioWE+BiIiIiDSkdU+a9PR0jB07Fhs3bgSQ8+tc1apVMXbsWJQvXx5TpkzRKZA///wTX3/9NerVq6dTeSJ9Sn7xvzkY7KzlEITSN+kXlU4tWrYWOwS94MTB/9O7d28kJiZi+vTpiI+PR4MGDXDgwAHVZML37t1T+2XG09MTBw8exIQJE1CvXj2UL18e48aNw6effirWUyAiIiIiDWmdpAkPD8elS5dw/PhxdOzYUbU/ICAAkZGROiVpXrx4gf79+2PNmjWYPXu21uWJisO3n3WHf6MqAICQyZv+t39qd0gkEpz79wGmrT6EJ8npYoVIRCZizJgxBQ5vOn78eJ59fn5+OHv2bDFHRURERET6pvVwp127dmH58uVo2bKl2q+VtWvXxu3bt3UKIjQ0FJ07d0ZAQMBbz1UoFEhJSVHbiIrD8Lk7Uf29xYj89ghmj2wPAGg/dj2aDlkFv2Gr8TQ5HWumdn/LVYhIF1JJ0TZtREVFoUmTJrC1tYWLiwtCQkJw/fp1tXMyMjIQGhqKsmXLwsbGBj179swzmS8RERERUVFpnaRJTEzMdwbktLQ0nbqYb968GRcuXEBUVJRG50dFRcHe3l61eXp6al0nkTaiD1yCf8MqcLKzRNzjZABAVrYSy7edQYt6JXveDyJjlTvcSddNGydOnEBoaCjOnj2LQ4cO4dWrV+jQoQPS0tJU50yYMAF79uzBtm3bcOLECTx8+BA9evTQ99MmIiIiIhOndZKmcePG+Pnnn1WPc2+Gv/32W/j5+Wl1rbi4OIwbNw7R0dEaL0cVHh6O5ORk1RYXF6dVnURvY28jh3tZW9Xj4JbeeJacjozMLNjb/K+d9mpXF5duPhIjRCKTIJHotmnrwIEDGDx4MGrXro369etjw4YNuHfvHs6fz1liMjk5GWvXrsXixYvRtm1b+Pj4YP369Th9+jSHFBERERGRXmk9J83cuXMRFBSEq1evIisrC8uWLcPVq1dx+vRpnDhxQqtrnT9/Ho8fP0ajRo1U+7Kzs3Hy5EksX74cCoUCZmZmamUKWiaUSF/srWWIntkLcpk5lEoBT5LS0GNKDFwcbfDDrN4wM8v5pT724XMMm7NT7HCJ1IwbMxIH9+9DQkI8uncNgo2NLS5duSF2WCVKcnJOjzknJycAOZ9Vr169UhuS6+3tjYoVK+LMmTNo1qyZKHESERERUemjdZKmZcuWuHTpEqKiolC3bl388ssvaNSoEc6cOYO6detqda127drhn3/+Uds3ZMgQeHt749NPP82ToCEyhHsJyWj10Zp8j/kNX23gaIi0s2x56Wij+ljd6c05yzRJ8iuVSowfPx4tWrRAnTp1AADx8fGwsLCAg4OD2rmurq6Ij4/XKUYiIiIiovxolaR59eoVPvroI0ybNg1r1uT/JVYbtra2qpvgXNbW1ihbtmye/UREZDp0mQD49bIA8sxZFhERgcjIyELLhoaG4vLlyzh16pRulRMRERERFYFWSRpzc3Ns374d06ZNK654iIiI9NKTJi4uDnZ2dqr9b+tFM2bMGOzduxcnT55EhQoVVPvd3NyQmZmJpKQktd40CQkJcHNz0ylGIiIiIqL8aD1xcEhICHbt2lUMoeQ4fvw4li5dWmzXJyIi02BnZ6e2FZSkEQQBY8aMwc6dO3H06FFUqVJF7biPjw/Mzc1x5MgR1b7r16/j3r17Wk+YT0RERERUGK3npKlevTpmzpyJ3377DT4+PrC2tlY7/vHHH+stOCIiMk2S/990LauN0NBQxMTE4KeffoKtra1qnhl7e3tYWlrC3t4ew4YNQ1hYGJycnGBnZ4exY8fCz8+PkwYTERERkV5pnaRZu3YtHBwccP78edXypLkkEgmTNEREVGRSiQRSHYc7aVtu1apVAIA2bdqo7V+/fj0GDx4MAFiyZAmkUil69uwJhUKBwMBArFy5Uqf4iIiIiIgKonWSJjY2tjjiICIiUpFIcjZdy2pDEIS3niOXy7FixQqsWLFCt6CIiIiIiDSg9Zw0RERERERERESkf1r3pCEiIipu+ljdiYiIiIiopGGShoiIjI4hhzsRERERERkLDnciIiIiIiIiIjIC7ElDRERGx5CrOxERERERGQudkjRJSUlYu3Yt/v33XwBA7dq1MXToUNjb2+s1OCIiMk0c7kREREREpkjr4U7nzp2Dl5cXlixZgmfPnuHZs2dYvHgxvLy8cOHCheKIkYiITEzuxMG6bkREREREJZHWPWkmTJiArl27Ys2aNShTJqd4VlYWhg8fjvHjx+PkyZN6D5JIH54fnSF2CAAAxxaTxA4BAPD8twVih0BERERERESv0TpJc+7cObUEDQCUKVMGkydPRuPGjfUaHBERmSYpdJ/ZnjPiExEREVFJpfW9rJ2dHe7du5dnf1xcHGxtbfUSFBERmTYOdyIiIiIiU6R1kqZ3794YNmwYtmzZgri4OMTFxWHz5s0YPnw4+vbtWxwxEhGRiZFIAKmOG3M0RERERFRSaT3caeHChZBIJBg4cCCysrIAAObm5hg1ahTmzZun9wCJiIiIiIiIiEyB1kkaCwsLLFu2DFFRUbh9+zYAwMvLC1ZWVnoPjoiITFNurxhdyxIRERERlURaD3caOnQoUlNTYWVlhbp166Ju3bqwsrJCWloahg4dWhwxEhGRieGcNERERERkirRO0mzcuBEvX77Ms//ly5f47rvv9BIUERGZNl3noylKDxwiIiIiIrFpPNwpJSUFgiBAEASkpqZCLperjmVnZ2Pfvn1wcXEpliCJiIiIiIiIiEo7jZM0Dg4Oqm7kNWrUyHNcIpFgxowZeg2OiIhMk6QIqzRxtBMRERERlVQaJ2mOHTsGQRDQtm1bbN++HU5OTqpjFhYWqFSpEjw8PIolSCIiMi1SiQRSHbMtupYjIiIiIhKbxkkaf39/AEBsbCwqVqzIiRmJiKjYSKHDpGmvlSUiIiIiKok0StL8/fffqFOnDqRSKZKTk/HPP/8UeG69evX0FhwRERERERERkanQKEnToEEDxMfHw8XFBQ0aNIBEIoEgCHnOk0gkyM7O1rjyyMjIPPPY1KxZE9euXdP4GkSl2Z4vR8DVyRZKQcCL9Ax8sugnXLrxEBbmZpg/LhgBzWogQ5GFf24+wtDIH8QOl4zApLBx2P/zHty7dxenzp5HvfoNxA5JJ5yThoiIiIhMkUZJmtjYWDg7O6v+W59q166Nw4cP/y+gMhqPwCIq9T747Hskv8gAAHT1r4NvpveG7wdLMDu0EwRBQN33vgAAuDrZihkmGZGQHj0xPmwSAtu1FjuUIpGiCHPSgFkaIiIiIiqZNMqIVKpUKd//1ksAZcrAzc1Nr9ckKi1yEzQAYGcjhyAAVnJzDOraFNWCZ6uOJTxLFSM8MkItWpbs5Ewu9qQhIiIiIlOkdbeV3bt357tfIpFALpejWrVqqFKlisbXu3nzJjw8PCCXy+Hn54eoqChUrFhR27CISq1vI/rA38cLABAyYS2qViiH58npmDyoLd5tWh0ZileYveYQjp+7JXKkREREREREVBRaJ2lCQkLynZMmd59EIkHLli2xa9cuODo6FnotX19fbNiwATVr1sSjR48wY8YMtGrVCpcvX4atbf7DNxQKBRQKhepxSkqKtk+BqEQZPmMzAKB/Jx/MHtMJM1YfRCUPJ/wb+xjTVu5H/Roe2PvVh/DpuxCPn70QOVoi/ZBKcjZdyxIRERERlURar1R66NAhNGnSBIcOHUJycjKSk5Nx6NAh+Pr6Yu/evTh58iSePn2KiRMnvvVaQUFBeP/991GvXj0EBgZi3759SEpKwtatWwssExUVBXt7e9Xm6emp7VMgKpGi952Hf6NqeJiYjOxsJTYfvAAAuHTjIe4+fIbaXu4iR0ikPxIJIJVIdNo43ImIiIiISiqte9KMGzcO33zzDZo3b67a165dO8jlcnz44Ye4cuUKli5diqFDh2odjIODA2rUqIFbtwoethEeHo6wsDDV45SUFCZqqFSyt5HDSm6BR09yeosFt66NZylpePzsBY6du4X2zWri4OlrqOTuiEoeTrh+J0HkiIn0h3PSEBEREZEp0jpJc/v2bdjZ2eXZb2dnh//++w8AUL16dTx58kTrYF68eIHbt29jwIABBZ4jk8kgk8m0vjZRSWNvI0f03AGQy8yhFAQ8eZ6GHmHrAQBj523H6s/fx+zQTlAKAsbO246HiRz6R8C4MSNxcP8+JCTEo3vXINjY2OLSlRtih0VERERERBrQOknj4+ODSZMm4bvvvlMty52YmIjJkyejSZMmAHImA9akd8vEiRMRHByMSpUq4eHDh4iIiICZmRn69u2rbVhEpc69+CS0GvpVvsfuPHyGjqO/NnBEVBIsW75a7BD0gnPSEBEREZEp0jpJs3btWnTr1g0VKlRQJWLi4uJQtWpV/PTTTwByesR8/vnnb73W/fv30bdvXzx9+hTOzs5o2bIlzp49q0r+EBGRaZL8//90LUtEREREVBJpnaSpWbMmrl69il9++QU3btxQ7Wvfvj2k0px5iENCQjS61ubNm7WtnoiITAB70hARERGRKXprkubLL79Eo0aN0LJlS9U+qVSKjh07omPHjsUaHBERERERERGRqXhrkqZZs2bo1asXlixZgu7du+PLL78s9PyPP/5Yb8EREZFpYk8aIiIiIjJFb03SNG3aFKdOnUKfPn3QvXt3LFmypMBzJRIJkzRERFRkEokEEh3X0ta1HBERERGR2DSak6ZChQo4duwYACA2NrZYAyIiImJPGiIiIiIyRVJNTzQ3Ny/OOIiIiIiIiIiITJpGPWnCwsI0vuDixYt1DoaIiAgAJJKcTdey2jh58iQWLFiA8+fP49GjR9i5c6faKoWDBw/Gxo0b1coEBgbiwIEDugVIRERERFQAjZI0f/31l9rjCxcuICsrCzVr1gQA3LhxA2ZmZvDx8dF/hEREZHKkEgmkOmZptC2XlpaG+vXrY+jQoejRo0e+53Ts2BHr169XPZbJZDrFRkRERERUGI2SNLnz0QA5PWVsbW2xceNGODo6AgCeP3+OIUOGoFWrVsUTJRERmRRDzkkTFBSEoKCgQs+RyWRwc3PTLSAiIiIiIg1pPCdNrkWLFiEqKkqVoAEAR0dHzJ49G4sWLdJrcERERLpKSUlR2xQKhc7XOn78OFxcXFCzZk2MGjUKT58+1WOkREREREQ5tE7SpKSkIDExMc/+xMREpKam6iUoIiIycZL/zUuj7Yb/70nj6ekJe3t71RYVFaVTKB07dsR3332HI0eOYP78+Thx4gSCgoKQnZ2tv+dLRERERAQNhzu9rnv37hgyZAgWLVqEpk2bAgB+//13TJo0qcCx/KbiVZZS7BBUzMtonX8jA3n+2wKxQwAAOLaNEDsEledHZ4gdgtER+9+w2PVLIYEUOs5J8//l4uLiYGdnp9qv6zwyffr0Uf133bp1Ua9ePXh5eeH48eNo166dTtckIiIiIsqP1kma1atXY+LEiejXrx9evXqVc5EyZTBs2DAsWGAcXz6JiKhk08fqTnZ2dmpJGn2pWrUqypUrh1u3bjFJQ0RERER6pXWSxsrKCitXrsSCBQtw+/ZtAICXlxesra31HhwREZGxuX//Pp4+fQp3d3exQyEiIiKiUkbn/uzW1taoV68e6tWrxwQNERHpVe7qTrpu2njx4gUuXryIixcvAgBiY2Nx8eJF3Lt3Dy9evMCkSZNw9uxZ3LlzB0eOHEG3bt1QrVo1BAYG6v+JF2DFihWoXLky5HI5fH198ccff2hUbvPmzZBIJAgJCSneAImIiIhILzhxCRERGR2pRFKkTRvnzp1Dw4YN0bBhQwBAWFgYGjZsiOnTp8PMzAx///03unbtiho1amDYsGHw8fHBr7/+qvMcN9rasmULwsLCEBERgQsXLqB+/foIDAzE48ePCy13584dTJw4Ea1atTJInERERERUdFoPdyIiIipu+piTRlNt2rSBIAgFHj948KBugejJ4sWLMWLECAwZMgRAztxwP//8M9atW4cpU6bkWyY7Oxv9+/fHjBkz8OuvvyIpKcmAERMRERGRrpikISIiMlKZmZk4f/48wsPDVfukUikCAgJw5syZAsvNnDkTLi4uGDZsGH799de31qNQKKBQKFSPU1JSAABKpRJKZfGvXChFwUmykkooZZ2VDdEOiortqGRgWxIH25I42JaMnyHbkaZ1MUlDRERGRwrthy29Xra0ePLkCbKzs+Hq6qq239XVFdeuXcu3zKlTp7B27VrVHDuaiIqKwowZM/LsT0xMREZGhlYx68LHqdirMLgkcx+xQ9Ar6VuG1xkDtqOSgW1JHGxL4mBbMn6GbEepqakancckDRERGR1DDncqTVJTUzFgwACsWbMG5cqV07hceHg4wsLCVI9TUlLg6ekJZ2fnYlnG/E3nnxV7FQbnUP682CHolYuLi9ghvBXbUcnAtiQOtiVxsC0ZP0O2I7lcrtF5TNIQEZHRkUL3me1LUyfccuXKwczMDAkJCWr7ExIS4Obmluf827dv486dOwgODlbty+1aW6ZMGVy/fh1eXl55yslksnwnQpZKpZBKi/8VVZai3k+5JDD+bvjaMEQ7KCq2o5KBbUkcbEviYFsyfoZsR5rWZfwtm4iIyERZWFjAx8cHR44cUe1TKpU4cuQI/Pz88pzv7e2Nf/75R7Wk+MWLF9G1a1e8++67uHjxIjw9PQ0ZPhERERFpiT1piIjI6EgkEkh0HLekazljFRYWhkGDBqFx48Zo2rQpli5dirS0NNVqTwMHDkT58uURFRUFuVyOOnXqqJV3cHAAgDz7iYiIiMj4MElDRERGR/L/m65lS5PevXsjMTER06dPR3x8PBo0aIADBw6oJhO+d+9eiejyTURERERvxySNkZgUNg77f96De/fu4tTZ86hXv4HYIRGp2bNoAFydbKBUCniRnolPvtyHSzfjcW3LeCheZeOl4hUAYGH0r/jx6BWRo6WSTiopwupOpawnDQCMGTMGY8aMyffY8ePHCy27YcMG/QdERERERMVC9CTNgwcP8Omnn2L//v1IT09HtWrVsH79ejRu3Fjs0AwqpEdPjA+bhMB2rcUOhShfH0RsQ/KLnKV4u7byxjfh3eE7dBUAYEDkNvx9K17M8IiIiIiIiEo8UZM0z58/R4sWLfDuu+9i//79cHZ2xs2bN+Ho6ChmWKJo0ZLJGTJuuQkaALCzlkMQBBGjIVNQ+vrDEBEREREVTtQkzfz58+Hp6Yn169er9lWpUkXEiIioMN9+1h3+jXL+jYZM3vS//VO7QyKR4Ny/DzBt9SE8SU4XK0QqJSSSnE3XskREREREJZGoMw3u3r0bjRs3xvvvvw8XFxc0bNgQa9asKbSMQqFASkqK2kZEhjF87k5Uf28xIr89gtkj2wMA2o9dj6ZDVsFv2Go8TU7HmqndRY6SSoPc1Z103YiIiIiISiJRkzT//fcfVq1aherVq+PgwYMYNWoUPv74Y2zcuLHAMlFRUbC3t1dtnp6eBoyYiAAg+sAl+DesAic7S8Q9TgYAZGUrsXzbGbSoV0nk6IiIiIiIiEomUZM0SqUSjRo1wty5c9GwYUN8+OGHGDFiBFavXl1gmfDwcCQnJ6u2uLg4A0ZMZJrsbeRwL2urehzc0hvPktORkZkFexu5an+vdnVx6eYjMUKkUkZaxI2IiIiIqCQSdU4ad3d31KpVS23fO++8g+3btxdYRiaTQSaTFXdoBjduzEgc3L8PCQnx6N41CDY2trh05YbYYREBAOytZYie2QtymTmUSgFPktLQY0oMXBxt8MOs3jAzyxliEvvwOYbN2Sl2uFQKFGXYEoc7EREREVFJJWqSpkWLFrh+/bravhs3bqBSJdMbLrFsecG9h4jEdi8hGa0+yn++KL/hbLtERERERET6IGqv8AkTJuDs2bOYO3cubt26hZiYGHzzzTcIDQ0VMywiIhKZpIgbEREREVFJJGqSpkmTJti5cyd++OEH1KlTB7NmzcLSpUvRv39/McMiIiKRcXUnIiIiIjJFog53AoAuXbqgS5cuYodBRERGpCgTAHPiYCIiIiIqqXgvS0RERERERERkBETvSUNERPQmru5ERERERKaISRoiIjI6RZkAmCkaIiIiIiqpmKQhIiKjI5HkbLqWJSIiIiIqiTgnDRERERERERGREWBPGiIiMjpSSCDVceCSruWIiIiIiMTGJA0RERkdDnciIiIiIlPEJA0RERkdyf//T9eyREREREQlEeekISIiIiIiIiIyAuxJQ0RERofDnYiIiIjIFDFJo0fmZdgxiUqO50dniB2CimOLSWKHAAB4/tsCsUOg/ycpwsTBHO5ERERERCUVkzRERGR02JOGiIiIiEwRu34QERERERERERkB9qQhIiKjw540RERERGSKmKQhIiKjwyW4iYiIiMgUMUlDRERGRyrJ2XQtS0RERERUEnFOGiIiMmknT55EcHAwPDw8IJFIsGvXLrXjgiBg+vTpcHd3h6WlJQICAnDz5k1xgiUiIiKiUo1JGiIiMjqSIv5PG2lpaahfvz5WrFiR7/EvvvgCX375JVavXo3ff/8d1tbWCAwMREZGhj6eKhERERGRCoc7ERGR0THkxMFBQUEICgrK95ggCFi6dCk+//xzdOvWDQDw3XffwdXVFbt27UKfPn10C5KIiIiIKB/sSUNEREZHgqL0psmRkpKitikUCq3jiI2NRXx8PAICAlT77O3t4evrizNnzujnyRIRERER/T8maYiIqFTy9PSEvb29aouKitL6GvHx8QAAV1dXtf2urq6qY0RERERE+sLhTkREZHT0sbpTXFwc7OzsVPtlMpkeIiMiIiIiKj5M0hBRibLnyxFwdbKFUhDwIj0Dnyz6CZduPISFuRnmjwtGQLMayFBk4Z+bjzA08gexwyUd6TIB8OtlAcDOzk4tSaMLNzc3AEBCQgLc3d1V+xMSEtCgQYMiXZuIiIiI6E2iJmkqV66Mu3fv5tk/evToAlfZICLT9sFn3yP5Rc6qOl396+Cb6b3h+8ESzA7tBEEQUPe9LwAArk62YoZJRWTIiYMLU6VKFbi5ueHIkSOqpExKSgp+//13jBo1Sn8VERERERFB5CTNn3/+iezsbNXjy5cvo3379nj//fdFjIqIjFluggYA7GzkEATASm6OQV2bolrwbNWxhGepYoRHJdCLFy9w69Yt1ePY2FhcvHgRTk5OqFixIsaPH4/Zs2ejevXqqFKlCqZNmwYPDw+EhISIFzQRERERlUqiJmmcnZ3VHs+bNw9eXl7w9/cXKSIiKgm+jegDfx8vAEDIhLWoWqEcnienY/Kgtni3aXVkKF5h9ppDOH7u1luuRMZK8v+brmW1ce7cObz77ruqx2FhYQCAQYMGYcOGDZg8eTLS0tLw4YcfIikpCS1btsSBAwcgl8t1jJCIiIiIKH9GMydNZmYmNm3ahLCwMEgK6auuUCjUllFNSUkxRHhEZESGz9gMAOjfyQezx3TCjNUHUcnDCf/GPsa0lftRv4YH9n71IXz6LsTjZy9EjpZ0IYUEUh3HLUm1TNO0adMGgiAUeFwikWDmzJmYOXOmTvEQEREREWnKaJbg3rVrF5KSkjB48OBCz4uKilJbUtXT09MwARKR0Ynedx7+jarhYWIysrOV2HzwAgDg0o2HuPvwGWp7ub/lCmSsJEXciIiIiIhKIqNJ0qxduxZBQUHw8PAo9Lzw8HAkJyertri4OANFSERis7eRw73c/1brCW5dG89S0vD42QscO3cL7ZvVBABUcndEJQ8nXL+TIFaoREREREREWjOK4U53797F4cOHsWPHjreeK5PJIJPJDBAVERkbexs5oucOgFxmDqUg4MnzNPQIWw8AGDtvO1Z//j5mh3aCUhAwdt52PEzkcMgSy5CT0hARERERGQmjSNKsX78eLi4u6Ny5s9ihEJERuxefhFZDv8r32J2Hz9Bx9NcGjoiKi+T//6drWSIiIiKikkj0JI1SqcT69esxaNAglCkjejhERGQMJICO8wazJw0RERERlViiz0lz+PBh3Lt3D0OHDhU7FCIiIiIiIiIi0YjedaVDhw6FLn1KRESmh1PSEBEREZEpEj1JQ0RElAezNERERERkgpikISIio8OJg4mIiIjIFIk+Jw0REREREREREbEnDRERGSFJEVZ30nlVKCIiIiIikTFJQ0RERodT0hARERGRKWKShoiIjA+zNERERERkgjgnDRERERERERGREWBPGiIiMjpc3YmIiIiITBGTNEREZHQ4cTARERERmSIOdyIiIqMjKeJW2qxYsQKVK1eGXC6Hr68v/vjjjwLPXbNmDVq1agVHR0c4OjoiICCg0POJiIiIyHiwJ40eJaVlih2CioO1hdghEGns+W8LxA4BAODUZ53YIag82zxU7BDISGzZsgVhYWFYvXo1fH19sXTpUgQGBuL69etwcXHJc/7x48fRt29fNG/eHHK5HPPnz0eHDh1w5coVlC9fXoRnQERERESaYk8aIiIyPuxKo7J48WKMGDECQ4YMQa1atbB69WpYWVlh3br8k4rR0dEYPXo0GjRoAG9vb3z77bdQKpU4cuSIgSMnIiIiIm0xSUNEREZHUsT/lRaZmZk4f/48AgICVPukUikCAgJw5swZja6Rnp6OV69ewcnJqbjCJCIiIiI94XAnIiIyOpw4OMeTJ0+QnZ0NV1dXtf2urq64du2aRtf49NNP4eHhoZboeZNCoYBCoVA9TklJAQAolUoolUodIteOFEKx12FoQin7HcwQ7aCo2I5KBrYlcbAtiYNtyfgZsh1pWheTNERERKXUvHnzsHnzZhw/fhxyubzA86KiojBjxow8+xMTE5GRkVGcIQIAfEphJ58kcx+xQ9Ar6ePHYofwVmxHJQPbkjjYlsTBtmT8DNmOUlNTNTqPSRoiIjI6RZlaphR1pEG5cuVgZmaGhIQEtf0JCQlwc3MrtOzChQsxb948HD58GPXq1Sv03PDwcISFhakep6SkwNPTE87OzrCzs9P9CWjo/LNir8LgHMqfFzsEvcpvkmpjw3ZUMrAtiYNtSRxsS8bPkO2osB/MXsckDRERGR9maQAAFhYW8PHxwZEjRxASEgIAqkmAx4wZU2C5L774AnPmzMHBgwfRuHHjt9Yjk8kgk8ny7JdKpZBKi79bs7I0/dH+nwTG3w1fG4ZoB0XFdlQysC2Jg21JHGxLxs+Q7UjTupikISIiMmJhYWEYNGgQGjdujKZNm2Lp0qVIS0vDkCFDAAADBw5E+fLlERUVBQCYP38+pk+fjpiYGFSuXBnx8fEAABsbG9jY2Ij2PIiIiIjo7ZikISIio1OUVZpK0+pOANC7d28kJiZi+vTpiI+PR4MGDXDgwAHVZML37t1T+2Vm1apVyMzMxHvvvad2nYiICERGRhoydCIiIiLSEpM0RERkdLi6k7oxY8YUOLzp+PHjao/v3LlT/AERERERUbFgkoaIiIwOp6QhIiIiIlNk/LMtERERERERERGZAPakISIi48OuNERERERkgkRN0mRnZyMyMhKbNm1CfHw8PDw8MHjwYHz++eeQlMZJBQrRu3snJCYkQCqVwtrWFrPnLUbd+g3EDouICrB7WiBcHSwhKAWkZrzCxHVnce1+Mr6b0AbeFRzwMjMbickvMW7NafwXnyp2uCUOJw4mIiIiIlMkapJm/vz5WLVqFTZu3IjatWvj3LlzGDJkCOzt7fHxxx+LGZrBfbM+BvYODgCAfXt+wvjRw3Hkt3PiBkVEBRqw6BiS0zMBAF2bVsLXoa3hH74H6w5dx8G/7gMARnZ8BytHtUTHiP1ihloiceJgIiIiIjJFoiZpTp8+jW7duqFz584AgMqVK+OHH37AH3/8IWZYoshN0ABAakqyyfUkIippchM0AGBnZQ4IAhSvslUJGgD44+ZjjOtaR4zwiIiIiIioBBI1SdO8eXN88803uHHjBmrUqIFLly7h1KlTWLx4sZhhiWbsR0Nx+tQJAMCmrT+JHA0Rvc2asa3hX9sNANB97qE8x0d3qo29f94zdFilAqekISIiIiJTJGqSZsqUKUhJSYG3tzfMzMyQnZ2NOXPmoH///gWWUSgUUCgUqscpKSmGCNUgvvp6HQBga8z3mB35GaK37RY5IiIqzIivTgIA+vtXw+wPGqslaib1qAcvNzt0msGhTjphloaIiIiITJCoS3Bv3boV0dHRiImJwYULF7Bx40YsXLgQGzduLLBMVFQU7O3tVZunp6cBIzaMXv0G4PSvJ/Ds2VOxQyEiDUSfuIXWtd3hZCMDAIzrWgfdfCsjZM4veJmZLXJ0JZOkiP/TRmRkJCQSidrm7e1dTM+MiIiIiKhgovakmTRpEqZMmYI+ffoAAOrWrYu7d+8iKioKgwYNyrdMeHg4wsLCVI9TUlJKfKImOSkJL1+mw83dAwCwf+9PcHQqC0dHJ5EjI6L82FtZwEpmhkfPXwIAgptUxLMXCjx7ocDYLrXRq0VVdJ55QG3eGjJutWvXxuHDh1WPy5QR9eORiIiIiEyUqHeh6enpkErVO/OYmZlBqVQWWEYmk0EmkxV3aAaVkpKMDwf3Q0bGS0glUpQtVw7fbd7JyYOJjJSdlTmiP2kLuYUZlALwJCUDPaMOobyTFeYP9sV/8Sk4EBkEAFBkKeEfvkfkiEugIqzupMtwpzJlysDNzU3HComIiIiI9EPUJE1wcDDmzJmDihUronbt2vjrr7+wePFiDB06VMywDM6zYiXsP/qb2GEQkYbinqShdQGJF6v31hk4mtLJ0FPS3Lx5Ex4eHpDL5fDz80NUVBQqVqyoYwRERERERLoRNUnz1VdfYdq0aRg9ejQeP34MDw8PfPTRR5g+fbqYYRERkdj0kKV5c2L5gnpi+vr6YsOGDahZsyYePXqEGTNmoFWrVrh8+TJsbW11DIKIiIiISHuiJmlsbW2xdOlSLF26VMwwiIioFHpzvrKIiAhERkbmOS8oKEj13/Xq1YOvry8qVaqErVu3YtiwYcUdJhERERGRCmdGJCIio6PLKk2vlwWAuLg42NnZqfZrOp+Zg4MDatSogVu3bulUPxERERGRrkRdgpuIiCg/EknRNgCws7NT2zRN0rx48QK3b9+Gu7t7MT5DIiIiIqK8mKQhIiKjIynipo2JEyfixIkTuHPnDk6fPo3u3bvDzMwMffv21c+TISIiIiLSEIc7ERGRSbt//z769u2Lp0+fwtnZGS1btsTZs2fh7OwsdmhEREREZGKYpCEiIuNjwDW4N2/erGNFRERERET6xSQNEREZHX1MHExEREREVNIwSUNEREZHgv9NAKxLWSIiIiKikogTBxMRERERERERGQH2pCEiIqNjwClpiIiIiIiMBpM0RERkdCSSIgx3YpaGiIiIiEooJmmIiMgIsS8NEREREZkeJmn0yMHaQuwQiKgIEjYNFjsEFce2EaLWL2QpRK2fiIiIiMgUMUlDRERGh8OdiIiIiMgUMUlDRERGh4OdiIiIiMgUMUlDRERGhz1piIiIiMgUScUOgIiIiIiIiIiI2JOGiIiMkOT//6drWSIiIiKikohJGiIiMj6clIaIiIiITBCTNEREZHSYoyEiIiIiU8Q5aYiIiIiIiIiIjAB70hARkdHh6k5EREREZIqYpCEiIqPDiYOJiIiIyBQxSUNERMaHk9IQERERkQlikoaIqIgmhY3D/p/34N69uzh19jzq1W9g0Pr3LBoAVycbKJUCXqRn4pMv9+HSzXhc2zIeilfZeKl4BQBYGP0rfjx6xaCxERERERGR5kRP0qSmpmLatGnYuXMnHj9+jIYNG2LZsmVo0qSJ2KEREWkkpEdPjA+bhMB2rUWp/4OIbUh+kQEA6NrKG9+Ed4fv0FUAgAGR2/D3rXhR4ioKdqQhIiIiIlMkepJm+PDhuHz5Mr7//nt4eHhg06ZNCAgIwNWrV1G+fHmxwyMieqsWLcVJzuTKTdAAgJ21HIIgiBiNfnDiYCIiIiIyRaImaV6+fInt27fjp59+QuvWOV9yIiMjsWfPHqxatQqzZ88WMzwiohLj28+6w79RFQBAyORN/9s/tTskEgnO/fsA01YfwpPkdLFC1JLuEwezLw0RERERlVSiJmmysrKQnZ0NuVyutt/S0hKnTp3Kt4xCoYBCoVA9TklJKdYYiYhKguFzdwIA+nesj9kj26P75Gi0H7secY+TUcZMisgR7bBmand0nxwtcqRERERERFQQqZiV29raws/PD7NmzcLDhw+RnZ2NTZs24cyZM3j06FG+ZaKiomBvb6/aPD09DRw1EZHxij5wCf4Nq8DJzhJxj5MBAFnZSizfdgYt6lUSOTrN5Q530nUjIiIiIiqJRE3SAMD3338PQRBQvnx5yGQyfPnll+jbty+k0vxDCw8PR3JysmqLi4szcMRERMbD3kYO97K2qsfBLb3xLDkdGZlZsLf5Xy/FXu3q4tLN/JPfRERERERkHESfONjLywsnTpxAWloaUlJS4O7ujt69e6Nq1ar5ni+TySCTyQwcJRFRwcaNGYmD+/chISEe3bsGwcbGFpeu3DBI3fbWMkTP7AW5zBxKpYAnSWnoMSUGLo42+GFWb5iZSSCRSBD78DmGzdlpkJj0gRMHExEREZEpEj1Jk8va2hrW1tZ4/vw5Dh48iC+++ELskIiINLJs+WrR6r6XkIxWH63J95jfcPHiIiIiIiIi7YmepDl48CAEQUDNmjVx69YtTJo0Cd7e3hgyZIjYoRERkUgkRVjdSfdVoYiIiIiIxCV6kiY5ORnh4eG4f/8+nJyc0LNnT8yZMwfm5uZih0ZERCLhcCciIiIiMkWiJ2l69eqFXr16iR0GEREZEcn/b7qWJSIiIiIqiURf3YmIiIiIiIiIiIygJw0REVEe7EpDRERERCaISRoiIjI6nDiYiIiIiEwRhzsRERERERERERkB9qQhIiKjw9WdiIiIiMgUMUlDRERGh1PSEBEREZEp4nAnIiIyPpIibjpYsWIFKleuDLlcDl9fX/zxxx9FfBL6o21s27Ztg7e3N+RyOerWrYt9+/YZKFIiIiIiKgomaYiIyORt2bIFYWFhiIiIwIULF1C/fn0EBgbi8ePHYoemdWynT59G3759MWzYMPz1118ICQlBSEgILl++bODIiYiIiEhbTNIQEZHRkRTxf9pavHgxRowYgSFDhqBWrVpYvXo1rKyssG7dumJ4dsUb27Jly9CxY0dMmjQJ77zzDmbNmoVGjRph+fLlBo6ciIiIiLRV4uekEQQBAJCakiJyJERU0r3KUoodgoqQpTCK+nPfYw0tNTVF5wmAU1NzPg9S3vhckMlkkMlkec7PzMzE+fPnER4ertonlUoREBCAM2fO6BaEnugS25kzZxAWFqa2LzAwELt27SqwHoVCAYXif20uOTkZAJCUlASlsvj/XUgUacVeh6GlvCxdsyNZJiWJHcJbsR2VDGxL4mBbEgfbkvEzZDvKvTd92/11iU/SpKamAgCqVfEUORIiotInNTUV9vb2BqvPwsICbm5uqF7E93QbGxt4eqpfIyIiApGRkXnOffLkCbKzs+Hq6qq239XVFdeuXStSHEWlS2zx8fH5nh8fH19gPVFRUZgxY0ae/ZUqVdIhagIAb7ED0LfRjmJHYJJKXTsC2JZEwrZE+lLq2pII7eht99clPknj4eGBuLg42NraQqLjz64pKSnw9PREXFwc7Ozs9BxhyYvDmGJhHMYbC+Mw3lj0EYcgCEhNTYWHh4eeoyucXC5HbGwsMjMzi3QdQRDyfCbk14uGcoSHh6v1vlEqlXj27BnKli2r82erKTOW9wIq2diOSF/Ylkhf2JaKRtP76xKfpJFKpahQoYJermVnZ2cUjc1Y4gCMJxbGkZexxMI48jKWWIoahyF70LxOLpdDLpcbrL5y5crBzMwMCQkJavsTEhLg5uZmsDjyo0tsbm5uWj+X/IaCOTg46BY0qRjLewGVbGxHpC9sS6QvbEu60+T+mhMHExGRSbOwsICPjw+OHDmi2qdUKnHkyBH4+fmJGJlusfn5+amdDwCHDh0S/bkQERER0duV+J40RERERRUWFoZBgwahcePGaNq0KZYuXYq0tDQMGTJE7NDeGtvAgQNRvnx5REVFAQDGjRsHf39/LFq0CJ07d8bmzZtx7tw5fPPNN2I+DSIiIiLSAJM0yOnmHRERIfp8BcYShzHFwjiMNxbGYbyxGEscJUnv3r2RmJiI6dOnIz4+Hg0aNMCBAwfyTMBrjLHdu3cPUun/OsY2b94cMTEx+Pzzz/HZZ5+hevXq2LVrF+rUqSPWUzA5/DdI+sB2RPrCtkT6wrZkGBJBrPVViYiIiIiIiIhIhXPSEBEREREREREZASZpiIiIiIiIiIiMAJM0RERERERERERGgEkaIiIiIiIjc/z4cUgkEiQlJen1XKK3iYyMRIMGDVSPBw8ejJCQENHiIXEIgoAPP/wQTk5OkEgkuHjxotghmQyTT9KsWLEClStXhlwuh6+vL/744w+Dx3Dy5EkEB/9fe3ce1dSVxwH8G5awBFCkpYJCVETFBcoiFbFilWqtdXA5dRlFLNIVplAdREetWutWi4q1YxWn4lipOu3YOu5UkVFUBAVEYRAYrZZh3EqrUSsQfvNHj5mGVasmqX4/5+Qc3n335n7zyHlJbu67GQpXV1coFAp89dVXBs8AAAsXLkTPnj1hb28PZ2dnDBs2DMXFxUbJsmrVKnh7e8PBwQEODg4ICgrCrl27jJLljkWLFkGhUCAuLs7gfc+ZMwcKhULv1qVLF4PnAIDy8nKMHz8eTk5OsLGxQY8ePZCTk2PwHO3atat3TBQKBaKjow2aQ6vVYtasWWjfvj1sbGzg4eGBefPmwRhrsl+/fh1xcXFQq9WwsbFB7969kZ2dbfAcRER0/3r37o2Kigq0aNHigdYlIrobu3fvRkpKCrZv346Kigpcu3bNJD6zPg4e60GazZs3Y/LkyZg9ezZOnDgBHx8fDBo0CJcuXTJojhs3bsDHxwcff/yxQfutKyMjA9HR0Th69CjS0tJQXV2NgQMH4saNGwbP0rZtWyxatAjHjx9HTk4O+vfvj7CwMJw+fdrgWQAgOzsbq1evhre3t1H6B4Bu3bqhoqJCdzt06JDBM1RWViI4OBiWlpbYtWsXCgsLkZiYCEdHR4Nnyc7O1jseaWlpAICXX37ZoDkWL16MVatWYeXKlSgqKsLixYvxwQcf4KOPPjJoDgCIiopCWloaNmzYgIKCAgwcOBChoaEoLy83eBYialh1dbWxI5ABVFVV3fd9KJVKtG7dGgqF4oHWpd+2B/HcIrobZWVlcHFxQe/evdG6dWuT+cz6WJDHWGBgoERHR+u2tVqtuLq6ysKFC42WCYBs3brVaP3/0qVLlwSAZGRkGDuKiIg4OjrK2rVrDd7v9evXxdPTU9LS0iQkJERiY2MNnmH27Nni4+Nj8H7rSkhIkD59+hg7RoNiY2PFw8NDamtrDdrvkCFDJDIyUq9sxIgRMm7cOIPmuHnzppibm8v27dv1yv38/GTGjBkGzUJkSnbt2iXBwcHSokULadWqlQwZMkRKS0t1+y9cuCBjxowRR0dHsbW1FX9/fzl69Khu/7Zt2yQgIECsrKzEyclJhg0bptvX0Gt2ixYtZN26dSIicvbsWQEgmzZtkr59+4qVlZWsW7dOrly5ImPGjBFXV1exsbGR7t27S2pqqt79aLVaWbx4sXh4eIhSqRQ3Nzd5//33RUTkueee03v/IvLza7alpaV88803D+KwUR0hISESHR0t0dHR4uDgIE5OTjJz5kzda45arZb33ntPwsPDxd7eXiIiIkRE5ODBg9KnTx+xtraWtm3byh/+8AfRaDS6+/3pp59k6tSp0rZtW1EqleLh4aF7r5Oeni4ApLKyUkREzp07Jy+99JK0bNlSbG1tpWvXrrJjx44G64qIfPHFF9K1a1dRKpWiVqvlww8/1HtMarVa5s+fL6+88orY2dmJm5ubrF69+iEdQfq17jz3YmNjxcnJSfr16ycFBQXywgsviEqlEmdnZxk/frxcvnxZ16ap84eIyNSpU8XT01NsbGykffv2MnPmTKmqqtLtr/u+MyIiQsLCwgzxcMlERERECADdTa1W6+03pc+sj6LHdiZNVVUVjh8/jtDQUF2ZmZkZQkNDceTIESMmMx0//vgjAKBVq1ZGzaHVarFp0ybcuHEDQUFBBu8/OjoaQ4YM0XuuGENJSQlcXV3RoUMHjBs3DufPnzd4hm3btiEgIAAvv/wynJ2d4evri+TkZIPnqKuqqgqfffYZIiMjDf4tYu/evbFv3z6cOXMGAJCfn49Dhw5h8ODBBs1RU1MDrVYLa2trvXIbGxujzLoiMhU3btzA5MmTkZOTg3379sHMzAzDhw9HbW0tNBoNQkJCUF5ejm3btiE/Px9Tp05FbW0tAGDHjh0YPnw4XnzxReTm5mLfvn0IDAy85wzTpk1DbGwsioqKMGjQIPz000/w9/fHjh07cOrUKbz22msIDw/Xu+R6+vTpWLRoEWbNmoXCwkKkpqbiqaeeAvDzrLnU1FTcvn1bV/+zzz5DmzZt0L9///s8YtSY9evXw8LCAseOHUNSUhKWLl2KtWvX6vZ/+OGH8PHxQW5uLmbNmoWysjK88MILGDlyJE6ePInNmzfj0KFDiImJ0bWZMGECPv/8c6xYsQJFRUVYvXo17OzsGuw/Ojoat2/fxj//+U8UFBRg8eLFjdY9fvw4Ro0ahTFjxqCgoABz5szBrFmzkJKSolcvMTERAQEByM3NxVtvvYU333zTaJe6U+PWr18PpVKJzMxMLFq0CP3794evry9ycnKwe/duXLx4EaNGjdLVb+r8AQD29vZISUlBYWEhkpKSkJycjGXLlhnjoZGJSkpKwnvvvYe2bduioqKCl88bmrFHiYylvLxcAMjhw4f1yuPj4yUwMNBIqUxnVFKr1cqQIUMkODjYaBlOnjwpKpVKzM3NpUWLFrpviwzp888/l+7du8utW7dERIw2k2bnzp2yZcsWyc/Pl927d0tQUJC4u7vLtWvXDJrDyspKrKysZPr06XLixAlZvXq1WFtbS0pKikFz1LV582YxNzeX8vJyg/et1WolISFBFAqFWFhYiEKhkAULFhg8h4hIUFCQhISESHl5udTU1MiGDRvEzMxMOnXqZJQ8RKbo8uXLAkAKCgpk9erVYm9vL1evXm2wblBQUJOz4hp6zW5oJs3y5cubzTVkyBCZMmWKiIhcu3ZNrKysJDk5ucG6t27dEkdHR9m8ebOuzNvbW+bMmdNsP/TrhISEiJeXl95szYSEBPHy8hKRn2el/HKWlYjIpEmT5LXXXtMrO3jwoJiZmcmtW7ekuLhYAEhaWlqDfdadHdOjR49G/8d16/7+97+X559/Xq9OfHy8dO3aVbetVqtl/Pjxuu3a2lpxdnaWVatWNXEkyNBCQkLE19dXtz1v3jwZOHCgXp0LFy4IACkuLm72/NGQJUuWiL+/v26bM2lIRGTZsmX1ZtDcYSqfWR9VFsYaHCLTFh0djVOnThn1G/jOnTsjLy8PP/74I7744gtEREQgIyMDXbt2NUj/Fy5cQGxsLNLS0urNTjC0X87K8Pb2xjPPPAO1Wo0tW7Zg0qRJBstRW1uLgIAALFiwAADg6+uLU6dO4ZNPPkFERITBctT1l7/8BYMHD4arq6vB+96yZQs2btyI1NRUdOvWDXl5eYiLi4Orq6vBj8mGDRsQGRmJNm3awNzcHH5+fhg7diyOHz9u0BxEpqSkpATvvvsusrKycOXKFd0smfPnzyMvLw++vr6NzhjNy8vDq6++et8ZAgIC9La1Wi0WLFiALVu2oLy8HFVVVbh9+zZsbW0BAEVFRbh9+zYGDBjQ4P1ZW1sjPDwcn376KUaNGoUTJ07g1KlT2LZt231npcb16tVLb7ZmUFAQEhMTodVqAdT/P+fn5+PkyZPYuHGjrkxEUFtbi7Nnz6KgoADm5uYICQm5q/7ffvttvPnmm9i7dy9CQ0MxcuTIRtfKKyoqQlhYmF5ZcHAwli9fDq1WC3NzcwDQa69QKNC6dWuDr81IzfP399f9nZ+fj/T09AZnUZWVleGHH35o8vwB/Lwu54oVK1BWVgaNRoOamho4ODg8lOxEdO8e28udnnjiCZibm+PixYt65RcvXkTr1q2NlMo0xMTEYPv27UhPT0fbtm2NlkOpVKJjx47w9/fHwoUL4ePjg6SkJIP1f/z4cVy6dAl+fn6wsLCAhYUFMjIysGLFClhYWOjelBlDy5Yt0alTJ5SWlhq0XxcXl3qDZF5eXka59OqOb7/9Ft988w2ioqKM0n98fDymTZuGMWPGoEePHggPD8c777yDhQsXGjyLh4cHMjIyoNFocOHCBRw7dgzV1dXo0KGDwbMQmYqhQ4fi+++/R3JyMrKyspCVlQXg58skbWxsmmzb3H6FQlHvl9waWhhYpVLpbS9ZsgRJSUlISEhAeno68vLyMGjQIN2CoM31C/x/ofDvvvsO69atQ//+/aFWq5ttRw9P3f+zRqPB66+/jry8PN0tPz8fJSUl8PDwuKv/8y9FRUXh3//+N8LDw1FQUICAgID7XqTe0tJSb1uhUOgGMsl0/PK5pdFoMHToUL3nVV5eHkpKStC3b99mn1dHjhzBuHHj8OKLL2L79u3Izc3FjBkzuCAxkQl5bAdplEol/P39sW/fPl1ZbW0t9u3bZ5R1T0yBiCAmJgZbt27F/v370b59e2NH0lNbW6t3/f3DNmDAABQUFOi9AAYEBGDcuHHIy8vTfQtlDBqNRrfiuiEFBwfXu1b9zJkzRv1gsG7dOjg7O2PIkCFG6f/mzZswM9M/lZqbmxv1Ta5KpYKLiwsqKyuxZ8+eet+mEj0url69iuLiYsycORMDBgyAl5cXKisrdfu9vb2Rl5eH77//vsH23t7eeu8T6nryySdRUVGh2y4pKcHNmzebzZWZmYmwsDCMHz8ePj4+6NChg25dKwDw9PSEjY1Nk3336NEDAQEBSE5ORmpqKiIjI5vtl+7PnQG+O44ePQpPT89G3w/4+fmhsLAQHTt2rHdTKpXo0aMHamtrkZGRcdcZ3Nzc8MYbb+Dvf/87pkyZ0ui6cF5eXsjMzNQry8zMRKdOnYz6/oXun5+fH06fPo127drVe16pVKpmzx+HDx+GWq3GjBkzEBAQAE9PT3z77bcGfhRE1JTH+nKnyZMnIyIiAgEBAQgMDMTy5ctx48YNvPLKKwbNodFo9GZEnD17Fnl5eWjVqhXc3d0NliM6Ohqpqan4+uuvYW9vj//+978AgBYtWtzztz33a/r06Rg8eDDc3d1x/fp1pKam4sCBA9izZ4/BMtjb26N79+56ZSqVCk5OTvXKH7Y//vGPGDp0KNRqNf7zn/9g9uzZMDc3x9ixYw2a45133kHv3r2xYMECjBo1CseOHcOaNWuwZs0ag+a4o7a2FuvWrUNERAQsLIxzOhs6dCjmz58Pd3d3dOvWDbm5uVi6dKlRPjDt2bMHIoLOnTujtLQU8fHx6NKli8HPaUSmwtHREU5OTlizZg1cXFxw/vx5TJs2Tbd/7NixWLBgAYYNG4aFCxfCxcUFubm5cHV1RVBQEGbPno0BAwbAw8MDY8aMQU1NDXbu3ImEhAQAQP/+/bFy5UoEBQVBq9UiISGh3syEhnh6euKLL77A4cOH4ejoiKVLl+LixYu6mYrW1tZISEjA1KlToVQqERwcjMuXL+P06dN6l7hGRUUhJiYGKpUKw4cPf8BHj+o6f/48Jk+ejNdffx0nTpzARx99hMTExEbrJyQkoFevXoiJiUFUVBRUKhUKCwuRlpaGlStXol27doiIiEBkZCRWrFgBHx8ffPvtt7h06ZLeIrB3xMXFYfDgwejUqRMqKyuRnp4OLy+vBvueMmUKevbsiXnz5mH06NE4cuQIVq5ciT//+c8P7HiQcURHRyM5ORljx47F1KlT0apVK5SWlmLTpk1Yu3Zts+cPT09PnD9/Hps2bULPnj2xY8cObN261dgPi34DTOUz62PBuEviGN9HH30k7u7uolQqJTAwUO9nNw3lzmJvdW93fr7RUBrKAEC3AKIhRUZGilqtFqVSKU8++aQMGDBA9u7da/AcdRlr4eDRo0eLi4uLKJVKadOmjYwePVrvJ2QN6R//+Id0795drKyspEuXLrJmzRqj5BAR2bNnj26hPGO5du2axMbGiru7u1hbW0uHDh1kxowZcvv2bYNn2bx5s3To0EGUSqW0bt1aoqOj5YcffjB4DiJTkpaWJl5eXmJlZSXe3t5y4MABvQUPz507JyNHjhQHBwextbWVgIAAycrK0rX/8ssv5emnnxalUilPPPGEjBgxQrevvLxcBg4cKCqVSjw9PWXnzp0NLhycm5url+nq1asSFhYmdnZ24uzsLDNnzpQJEyboLcyp1Wrl/fffF7VaLZaWluLu7l5vUfLr16+Lra2tvPXWWw/0mFF9ISEh8tZbb8kbb7whDg4O4ujoKH/605/0foJ72bJl9dodO3ZMnn/+ebGzsxOVSiXe3t4yf/583f5bt27JO++8o3uN79ixo3z66aciUn8x4JiYGPHw8BArKyt58sknJTw8XK5cudJgXZH//wT3nefPkiVL9LI1lNnHx0dmz559fweLHqiG3nueOXNGhg8fLi1bthQbGxvp0qWLxMXF6Z6PzZ0/4uPjxcnJSezs7GT06NGybNkyadGihW4/Fw4mkfoLB5vKZ9bHgUKkzsXURERERGTyzp07Bw8PD2RnZ8PPz8/YcR5p/fr1w9NPP43ly5cbOwoRET3iHuvLnYiIiIh+a6qrq3H16lXMnDkTvXr14gANERHRI+SxXTiYiIiI6LcoMzMTLi4uyM7OxieffGLsOERERPQA8XInIiIiIiIiIiITwJk0REREREREREQmgIM0REREREREREQmgIM0REREREREREQmgIM0REREREREREQmgIM09MjIyspCUlISuBY2ERERERER/RZxkIZ+k/r164e4uDjd9nfffYdRo0bB19cXCoWi2fbnzp2DQqFAXl7ewwtpIAqFAl999RWAe39cEydOxLBhwx5aNiIiIiIiIrp7HKSh37yqqiqMGjUKiYmJ6Nu37121cXNzQ0VFBbp37w4AOHDgABQKBX744YeHmPThq/u4iIiIiIiI6LfDwtgBiO6XUqnE4cOH76mNubk5Wrdu/ZAS3bvq6mpYWlre9/2Y2uMiIiIiIiKiu8eZNGTybty4gQkTJsDOzg4uLi5ITEysV6ddu3ZYvny5bvtf//oX+vTpA2tra3Tt2hXffPNNo5cFnTt3Ds899xwAwNHREQqFAhMnTgQA3L59G2+//TacnZ1hbW2NPn36IDs7u8m87dq1w7x58zB27FioVCq0adMGH3/8sV4dhUKBVatW4Xe/+x1UKhXmz58PAPj666/h5+cHa2trdOjQAXPnzkVNTY2uXUlJCfr27at7XGlpaXr329DlTqdPn8ZLL70EBwcH2Nvb49lnn0VZWZleuw8//BAuLi5wcnJCdHQ0qqurdfsqKysxYcIEODo6wtbWFoMHD0ZJSUmTx4CIiIiIiIjuHQdpyOTFx8cjIyMDX3/9Nfbu3YsDBw7gxIkTjdbXarUYNmwYbG1tkZWVhTVr1mDGjBmN1ndzc8OXX34JACguLkZFRQWSkpIAAFOnTsWXX36J9evX48SJE+jYsSMGDRqE77//vsnMS5YsgY+PD3JzczFt2jTExsbWG1CZM2cOhg8fjoKCAkRGRuLgwYOYMGECYmNjUVhYiNWrVyMlJUU3gFNbW4sRI0ZAqVQiKysLn3zyCRISEprMUV5ejr59+8LKygr79+/H8ePHERkZqTfwk56ejrKyMqSnp2P9+vVISUlBSkqKbv/EiRORk5ODbdu24ciRIxARvPjii3oDOURERERERPQACJEJu379uiiVStmyZYuu7OrVq2JjYyOxsbG6MrVaLcuWLRMRkV27domFhYVUVFTo9qelpQkA2bp1q4iInD17VgBIbm6uiIikp6cLAKmsrNS10Wg0YmlpKRs3btSVVVVViaurq3zwwQeNZlar1fLCCy/olY0ePVoGDx6s2wYgcXFxenUGDBggCxYs0CvbsGGDuLi4iIjInj17xMLCQsrLy3X7d+3a1eTjmj59urRv316qqqoazBoRESFqtVpqamp0ZS+//LKMHj1aRETOnDkjACQzM1O3/8qVK2JjY6P3PyEiIiIiIqL7xzVpyKSVlZWhqqoKzzzzjK6sVatW6Ny5c6NtiouL4ebmprc2S2Bg4K/qu7q6GsHBwboyS0tLBAYGoqioqMm2QUFB9bZ/eTkWAAQEBOht5+fnIzMzUzdzBvh5VtBPP/2EmzdvoqioCG5ubnB1dW20n7ry8vLw7LPPNrneTbdu3WBubq7bdnFxQUFBAQCgqKgIFhYWesffyckJnTt3bvYYEBERERER0b3hIA2RkahUKr1tjUaDuXPnYsSIEfXqWltb/6o+bGxsmq1TdwBHoVCgtrb2V/VHREREREREvx7XpCGT5uHhAUtLS2RlZenKKisrcebMmUbbdO7cGRcuXMDFixd1Zc0t9qtUKgH8PHPll30rlUpkZmbqyqqrq5GdnY2uXbs2eX9Hjx6tt+3l5dVkGz8/PxQXF6Njx471bmZmZvDy8sKFCxdQUVHRaD91eXt74+DBg796/RgvLy/U1NToHf+rV6+iuLi42WNARERERERE94aDNGTS7OzsMGnSJMTHx2P//v04deoUJk6cCDOzxp+6zz//PDw8PBAREYGTJ08iMzMTM2fOBPDzLJGGqNVqKBQKbN++HZcvX4ZGo4FKpcKbb76J+Ph47N69G4WFhXj11Vdx8+ZNTJo0qcncmZmZ+OCDD3DmzBl8/PHH+Nvf/obY2Ngm27z77rv461//irlz5+L06dMoKirCpk2bdNlDQ0PRqVMnREREID8/HwcPHmxyQWQAiImJwbVr1zBmzBjk5OSgpKQEGzZsQHFxcZPt7vD09ERYWBheffVVHDp0CPn5+Rg/fjzatGmDsLCwu7oPIiIiIiIiujscpCGTt2TJEjz77LMYOnQoQkND0adPH/j7+zda39zcHF999RU0Gg169uyJqKgo3WBGY5cNtWnTBnPnzsW0adPw1FNPISYmBgCwaNEijBw5EuHh4fDz80NpaSn27NkDR0fHJjNPmTIFOTk58PX1xfvvv4+lS5di0KBBTbYZNGgQtm/fjr1796Jnz57o1asXli1bBrVaDQAwMzPD1q1bcevWLQQGBiIqKkpv/ZqGODk5Yf/+/dBoNAgJCYG/vz+Sk5ObXKOmrnXr1sHf3x8vvfQSgoKCICLYuXPnPd0HERERERERNU8hImLsEEQPW2ZmJvr06YPS0lJ4eHg81L7atWuHuLg4xMXFPdR+iIiIiIiI6NHChYPpkbR161bY2dnB09MTpaWliI2NRXBw8EMfoCEiIiIiIiL6tThIQ4+k69evIyEhAefPn8cTTzyB0NBQJCYmGjsWERERERERUaN4uRMRERERERERkQngwsFERERERERERCaAgzRERERERERERCaAgzRERERERERERCaAgzRERERERERERCaAgzRERERERERERCaAgzRERERERERERCaAgzRERERERERERCaAgzRERERERERERCaAgzRERERERERERCbgfxDG6E9QUYkUAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Reporte por dígito (test-set):\n", "\n", " precision recall f1-score support\n", "\n", " 0 1.000 0.972 0.986 36\n", " 1 0.897 0.972 0.933 36\n", " 2 0.972 1.000 0.986 35\n", " 3 1.000 1.000 1.000 37\n", " 4 0.972 0.972 0.972 36\n", " 5 1.000 0.973 0.986 37\n", " 6 1.000 0.972 0.986 36\n", " 7 1.000 1.000 1.000 36\n", " 8 0.970 0.914 0.941 35\n", " 9 0.946 0.972 0.959 36\n", "\n", " accuracy 0.975 360\n", " macro avg 0.976 0.975 0.975 360\n", "weighted avg 0.976 0.975 0.975 360\n", "\n" ] } ], "source": [ "fig, axes = plt.subplots(1, 2, figsize=(13, 4.4))\n", "\n", "# matriz de confusión en test\n", "cm = confusion_matrix(y_test, modelo_final.predict(X_test_s))\n", "im = axes[0].imshow(cm, cmap=\"Blues\")\n", "axes[0].set_xticks(range(10)); axes[0].set_yticks(range(10))\n", "axes[0].set_xlabel(\"dígito predicho\"); axes[0].set_ylabel(\"dígito real\")\n", "axes[0].set_title(f\"Matriz de confusión en TEST — {mejor_fila['arquitectura']}\")\n", "for i in range(10):\n", " for j in range(10):\n", " if cm[i, j]:\n", " axes[0].text(j, i, cm[i, j], ha=\"center\", va=\"center\", fontsize=8,\n", " color=\"white\" if cm[i, j] > cm.max() / 2 else \"black\")\n", "fig.colorbar(im, ax=axes[0], fraction=0.046)\n", "\n", "# cv vs test del modelo elegido\n", "ms = [\"accuracy\", \"precision\", \"recall\", \"f1\"]\n", "xs = np.arange(len(ms)); w = 0.36\n", "axes[1].bar(xs - w/2, [mejor_fila[f\"cv_{m}\"] for m in ms], w, label=\"cross-validation\", color=OKABE[0])\n", "axes[1].bar(xs + w/2, [metricas_test[m] for m in ms], w, label=\"test\", color=OKABE[1])\n", "axes[1].set_xticks(xs); axes[1].set_xticklabels(ms)\n", "axes[1].set_ylim(0, 1.05); axes[1].legend(); axes[1].grid(alpha=0.3, axis=\"y\")\n", "axes[1].set_title(\"Modelo elegido: cross-validation vs test\")\n", "plt.tight_layout(); plt.show()\n", "\n", "print(\"\\nReporte por dígito (test-set):\\n\")\n", "print(classification_report(y_test, modelo_final.predict(X_test_s), digits=3))" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "El modelo se equivocó en 9 de 360 imágenes de test (2.5%)\n", "\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Los dígitos que el modelo confunde: útil para el informe\n", "y_pred_test = modelo_final.predict(X_test_s)\n", "errores = np.where(y_pred_test != y_test)[0]\n", "print(f\"El modelo se equivocó en {len(errores)} de {len(y_test)} imágenes de test \"\n", " f\"({100 * len(errores) / len(y_test):.1f}%)\\n\")\n", "\n", "if len(errores):\n", " n = min(10, len(errores))\n", " fig, axes = plt.subplots(1, n, figsize=(1.35 * n, 2.1))\n", " axes = np.atleast_1d(axes)\n", " for ax, idx in zip(axes, errores[:n]):\n", " ax.imshow(X_test[idx].reshape(8, 8), cmap=\"gray_r\")\n", " ax.set_title(f\"real {y_test[idx]}\\npred {y_pred_test[idx]}\", fontsize=8)\n", " ax.axis(\"off\")\n", " fig.suptitle(\"Errores del modelo final en el test-set\", y=1.12)\n", " plt.tight_layout(); plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 13. Tu Análisis y Conclusión\n", "\n", "### `# TU CÓDIGO AQUÍ` (en Markdown)\n", "\n", "Con la bitácora, las gráficas y el reporte final en mano, escribe tu recomendación en la celda de\n", "abajo. Guíate con estas preguntas — no hace falta responderlas una por una, pero tu conclusión\n", "debe reflejar que las pensaste:\n", "\n", "**Sobre las estrategias de búsqueda**\n", "- Con el mismo presupuesto (24 experimentos cada una), ¿cuál encontró la mejor configuración?\n", "- Mira la gráfica de convergencia: ¿se nota que la bayesiana \"aprende\" de sus pruebas anteriores?\n", " ¿Le alcanzaron 24 trials para despegarse de las otras dos?\n", "- ¿En qué situación recomendarías grid search a pesar de sus desventajas?\n", "\n", "**Sobre los frameworks**\n", "- ¿Qué arquitectura ganó? Mira también la gráfica de costo vs desempeño: ¿la diferencia en f1\n", " justifica la diferencia en tiempo de entrenamiento?\n", "- TensorFlow y PyTorch entrenaron **la misma arquitectura** con el mismo espacio de\n", " hiper-parámetros. ¿Dieron resultados parecidos? Si difieren, ¿a qué lo atribuyes?\n", "\n", "**Sobre la honestidad de los números**\n", "- Compara el `f1` de cross-validation del modelo elegido contra su `f1` de test. ¿Cuál es mayor?\n", " ¿Por qué era esperable, aunque no hubiera nada mal hecho? (piensa en el *winner's curse* del\n", " notebook 09)\n", "- ¿Qué número le reportarías al área de tecnología como estimación del desempeño en producción?\n", "\n", "**Sobre el método**\n", "- Usamos **un solo cv-set** en vez de k-fold. ¿Qué riesgo trae eso al comparar dos configuraciones\n", " cuyos f1 difieren, digamos, en 0.005? ¿Qué harías distinto si el entrenamiento fuera barato?\n", "\n", "**Tu conclusión debe incluir, como mínimo:**\n", "1. El modelo que recomiendas, con su framework, arquitectura e hiper-parámetros.\n", "2. El número que reportas como desempeño esperado, y de qué conjunto salió.\n", "3. Una comparación de las tres estrategias con datos de tu bitácora.\n", "4. Una limitación honesta de este estudio y qué harías para resolverla." ] }, { "cell_type": "markdown", "metadata": {}, "source": "### Mi conclusión\n\n- **Modelo recomendado (framework, arquitectura e hiper-parámetros):**\n El modelo elegido es **MLP-PyTorch** (framework `pytorch`), hallado por **random search**\n (experimento #47), con hiper-parámetros: `capas=2`, `unidades=185`, `dropout=0.390`,\n `lr=0.000828`. Fue la configuración con mayor `cv_f1` de las 72 probadas.\n\n- **Desempeño esperado en producción, y de qué conjunto sale ese número:**\n El número que reporto es el **f1 en el test-set: 0.9750** (accuracy 0.975, precision 0.976,\n recall 0.975), no el de cross-validation (0.9835). El cv se usó para *elegir* la configuración\n entre 72 candidatas, así que su métrica está sesgada al alza (winner's curse): la que salió\n mejor ahí tuvo, además de ser buena, algo de suerte con ese cv-set particular de 360 imágenes.\n El test-set no participó en ninguna decisión, por eso 0.975 es el número honesto para\n producción.\n\n- **Comparación de las tres estrategias, con números de mi bitácora:**\n Con el mismo presupuesto (24 experimentos cada una), las tres llegaron prácticamente al mismo\n techo:\n - Grid search: mejor f1 = **0.9834** (pytorch)\n - Random search: mejor f1 = **0.9835** (pytorch) — la ganadora, por un margen mínimo\n - Bayesiana (Optuna): mejor f1 = **0.9834** (tensorflow)\n\n De hecho, el \"top 5\" de toda la bitácora está comprimido en un rango de solo 0.0029 de f1\n (0.9835 a 0.9807), y los primeros cuatro difieren entre sí por menos de 0.0002 — una diferencia\n muchísimo menor a los 0.005 que se mencionan como umbral de riesgo, y que cae dentro del ruido\n esperable de un solo cv-set de 360 imágenes. Con este presupuesto, **ninguna estrategia le sacó\n ventaja clara a las otras**: eligiendo cualquiera de las tres me habría llevado a una\n configuración prácticamente equivalente.\n\n Sí hay evidencia de que la bayesiana \"aprendió\": de sus 24 trials, dedicó 12 a pytorch y 8 a\n tensorflow, pero solo 4 a sklearn — precisamente el framework con peor techo dentro de sus\n propios trials (f1 máximo 0.9613 en bayesiana, contra ~0.978 en grid/random). Optuna detectó\n rápido que sklearn rendía menos y reasignó su presupuesto a los MLP. Además, su mejor resultado\n (experimento #58) apareció en el décimo trial de sus 24 (no en los primeros), lo que sugiere\n que sí necesitó ese \"calentamiento\" antes de converger — con más presupuesto (por ejemplo 100\n trials) probablemente sí se habría despegado de grid y random. Recomendaría **grid search**\n cuando el espacio de hiper-parámetros es pequeño y discreto de antemano y se necesita\n *cobertura exhaustiva y reproducible*, sin depender de un sampler — por ejemplo, para un\n reporte donde hay que justificar que se probó *todo* el espacio declarado.\n\n- **Sobre los frameworks (arquitectura ganadora y costo vs desempeño):**\n Los dos MLP (TensorFlow y PyTorch) superaron consistentemente a Random Forest: el mejor f1 de\n sklearn en toda la bitácora fue 0.9780, contra 0.9835 (pytorch) y 0.9834 (tensorflow). Con el\n mismo espacio de hiper-parámetros, TensorFlow y PyTorch llegaron a resultados muy parecidos\n (0.9834 vs 0.9835, prácticamente empatados), lo que confirma que la arquitectura importa más\n que el framework — las pequeñas diferencias que sí aparecen se explican por inicialización de\n pesos y orden de los lotes distintos entre ambos. Random Forest, sin embargo, entrena en\n fracciones de segundo (0.1 s en la prueba inicial) contra ~0.5-2 s de los MLP: para este\n problema, la ganancia de ~0.005-0.006 de f1 de los MLP probablemente sí justifica el costo\n extra (el tiempo total de las 72 corridas fue de solo 49 s), pero en un dataset mucho más\n grande valdría la pena reconsiderar si esa diferencia sigue siendo rentable.\n\n- **Por qué el f1 de cross-validation y el de test difieren:**\n El f1 de cv (0.9835) es mayor que el de test (0.9750), una diferencia de -0.0086. Era esperable\n aunque no hubiera nada mal hecho: la configuración se seleccionó **por ser la mejor entre 72**\n precisamente en el cv-set, así que cualquier ruido favorable de esas 360 imágenes quedó\n \"capturado\" en la elección (winner's curse, visto en el notebook 09). El test-set, al no haber\n influido en ninguna decisión, da una estimación sin ese sesgo — por eso el número que reporto\n a producción es 0.975 y no 0.9835.\n\n- **Una limitación de este estudio y cómo la resolvería:**\n Usamos un único cv-set (holdout) en vez de k-fold, y los datos lo confirman: el top-4 de la\n bitácora difiere en menos de 0.0002 de f1, un margen totalmente dominado por qué imágenes\n cayeron en ese cv-set de 360 en particular, no por diferencias reales de calidad entre esas\n configuraciones. Si tuviera que elegir entre el experimento #47 (random) y el #58 (bayesiana)\n con esta metodología, en realidad estaría tirando una moneda. Si el entrenamiento fuera barato\n (como con Random Forest, que tarda decimas de segundo) usaría **k-fold cross-validation** para\n promediar varios splits y reducir esa varianza antes de decidir; para los MLP, donde entrenar\n es más caro, una alternativa intermedia sería repetir el holdout con 2-3 semillas distintas y\n comparar el promedio de f1 en vez de un solo número, al menos para las configuraciones que\n queden en el top-5." } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.3" } }, "nbformat": 4, "nbformat_minor": 4 }