{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "EybOZ6hSjpCF" }, "source": [ "

TINTOlib: Converting Tidy Data into Image for Classification with 2-Dimensional Convolutional Neural Networks

\n", "\n", "\n", "\n", "

How to read TINTO images

\n", "\n", "

\n", "
\n", "Manuel Castillo-Cara
\n", "Raúl García-Castro
\n", "Luis Orozco-Barbosa
\n", "
" ] }, { "cell_type": "markdown", "metadata": { "id": "2l5nFzsdjpCW" }, "source": [ "---\n", "\n", "\n", "

Index

\n", "\n", "* [0. Context](#section0)\n", "* [1. Description](#section1)\n", " * [1.1. Main Features](#section12)\n", " * [1.2. Citation](#section12)\n", "* [2. Libraries](#section2)\n", "* [3. Data processing](#section3)\n", " * [3.1. Read images](#section31)\n", " * [3.2. Data Curation](#section32)\n", "* [4. Pre-modelling phase](#section4)\n", " * [4.1. Resize images](#section41)\n", " * [4.2. Iteradores](#section42)\n", "* [5. Modelling with CNN](#section5)\n", " * [5.1. CNN](#section51)\n", " * [5.2. Compile and fit](#section52)\n", " * [5.3. Results](#section53)" ] }, { "cell_type": "markdown", "metadata": { "id": "SxTpMExHjpCa" }, "source": [ "---\n", "\n", "# 0. Context" ] }, { "cell_type": "markdown", "metadata": { "id": "JlVYt3MRrl_V" }, "source": [ "This is a tutorial on how to read the images created by TINTO and pass them to a very simple pretrained Convolutional Neural Network (CNN). The images must already be created by the TINTO software. See the documentation in GITHUB for how to create the images from tabular data.\n", "\n", "Remember that when using CNN you can set the training to be done with GPUs to improve performance." ] }, { "cell_type": "markdown", "metadata": { "id": "WaA-_OjsjpCe" }, "source": [ "
\n", " \n", "\n", "See the paper from [Information Fusion Journal](https://doi.org/10.1016/j.inffus.2022.10.011)" ] }, { "cell_type": "markdown", "metadata": { "id": "28TFDkl5jpCi" }, "source": [ "
\n", " \n", "\n", "See the paper from [SoftwareX](https://doi.org/10.1016/j.softx.2023.101391)" ] }, { "cell_type": "markdown", "metadata": { "id": "i3tgsO0BjpCj" }, "source": [ "
\n", " \n", "\n", "You can see all information about TINTO in [GitHub](https://github.com/oeg-upm/TINTO)" ] }, { "cell_type": "markdown", "metadata": { "id": "4RKBgDwzjpCl" }, "source": [ "---\n", "
\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": { "id": "kpU7pi6yjpCn" }, "source": [ "\n", "# 1. Description" ] }, { "cell_type": "markdown", "metadata": { "id": "NL9RoFkEjpCq" }, "source": [ "The growing interest in the use of algorithms-based machine learning for predictive tasks has generated a large and diverse development of algorithms. However, it is widely known that not all of these algorithms are adapted to efficient solutions in certain tidy data format datasets. For this reason, novel techniques are currently being developed to convert tidy data into images with the aim of using Convolutional Neural Networks (CNNs). TINTO offers the opportunity to convert tidy data into images through the representation of characteristic pixels by implementing two dimensional reduction algorithms: PCA and _t_-SNE. Our proposal also includes a blurring technique, which adds more ordered information to the image and can improve the classification task in CNNs." ] }, { "cell_type": "markdown", "metadata": { "id": "HFrF4C89jpCt" }, "source": [ "---\n", "\n", "# 1.1. Main Features" ] }, { "cell_type": "markdown", "metadata": { "id": "1gruE0_sjpCu" }, "source": [ "- Supports all CSV data in **[Tidy Data](https://www.jstatsoft.org/article/view/v059i10)** format.\n", "- For now, the algorithm converts tabular data for binary and multi-class classification problems into machine learning.\n", "- Input data formats:\n", " - **Tabular files**: The input data must be in **[CSV](https://en.wikipedia.org/wiki/Comma-separated_values)**, taking into account the **[Tidy Data](https://www.jstatsoft.org/article/view/v059i10)** format.\n", " - **Tidy Data**: The **target** (variable to be predicted) should be set as the last column of the dataset. Therefore, the first columns will be the features.\n", " - All data must be in numerical form. TINTO does not accept data in string or any other non-numeric format.\n", "- Two dimensionality reduction algorithms are used in image creation, **[PCA](https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html#sklearn.decomposition.PCA)** and **[*t*-SNE](https://scikit-learn.org/stable/modules/generated/sklearn.manifold.TSNE.html)** from the Scikit-learn Python library.\n", "- The synthetic images to be created will be in black and white, i.e. in 1 channel.\n", "- The synthetic image **dimensions** can be set as a parameter when creating them.\n", "- The synthetic images can be created using **characteristic pixels** or **blurring** painting technique (expressing an overlap of pixels as the **maximum** or **average**).\n", "- Runs on **Linux**, **Windows** and **macOS** systems.\n", "- Compatible with **[Python](https://www.python.org/)** 3.7 or higher." ] }, { "cell_type": "markdown", "metadata": { "id": "Z3EzYcjJjpC6" }, "source": [ "---\n", "
\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": { "id": "qwYF5A2njpC8" }, "source": [ "\n", "# 2. Libraries" ] }, { "cell_type": "markdown", "metadata": { "id": "5AdHKnWYsEq_" }, "source": [ "The first thing we need to do is to declare the libraries" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "id": "PeeBbGxlpjFp", "tags": [] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/9h/d3b8zc6j5019cyvmb_h929xm0000gn/T/ipykernel_1637/1751275948.py:2: DeprecationWarning: \n", "Pyarrow will become a required dependency of pandas in the next major release of pandas (pandas 3.0),\n", "(to allow more performant data types, such as the Arrow string type, and better interoperability with other libraries)\n", "but was not found to be installed on your system.\n", "If this would cause problems for you,\n", "please provide us feedback at https://github.com/pandas-dev/pandas/issues/54466\n", " \n", " import pandas as pd\n", "/Users/manwest/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:35: NotOpenSSLWarning: urllib3 v2 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", " warnings.warn(\n" ] } ], "source": [ "import os\n", "import pandas as pd\n", "import numpy as np\n", "from tqdm import tqdm\n", "#import cv2\n", "import gc\n", "import matplotlib.pyplot as plt\n", "#import openslide\n", "#from openslide.deepzoom import DeepZoomGenerator\n", "import tifffile as tifi\n", "import sklearn\n", "import tensorflow as tf\n", "import seaborn as sns\n", "from PIL import Image\n", "\n", "\n", "from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score,mean_absolute_percentage_error\n", "\n", "from keras_preprocessing.image import ImageDataGenerator\n", "from tensorflow.keras.models import load_model\n", "\n", "from sklearn.model_selection import train_test_split\n", "from tensorflow.keras.applications import vgg16, vgg19, resnet50, mobilenet, inception_resnet_v2, densenet, inception_v3, xception, nasnet, ResNet152V2\n", "from tensorflow.keras.models import Sequential, Model, load_model\n", "from tensorflow.keras.layers import Dense, Conv2D, MaxPool2D, Flatten, Dropout, BatchNormalization, InputLayer, LayerNormalization\n", "from tensorflow.keras.callbacks import ModelCheckpoint, ReduceLROnPlateau, EarlyStopping\n", "from tensorflow.keras.optimizers import SGD, Adam, Adadelta, Adamax\n", "from tensorflow.keras import layers, models, Model\n", "from tensorflow.keras.losses import MeanAbsoluteError, MeanAbsolutePercentageError\n", "from tensorflow.keras.layers import Input, Activation,MaxPooling2D, concatenate\n", "\n", "from torchmetrics import MeanAbsolutePercentageError\n", "import torch\n", "import torch.nn as nn\n", "from torch.utils.data import Dataset, DataLoader, random_split\n", "from torchvision import transforms\n", "\n", "import pytorch_lightning as pl\n", "from pytorch_lightning.loggers import TensorBoardLogger\n", "from pytorch_lightning.callbacks.early_stopping import EarlyStopping\n", "\n", "\n", "from imblearn.over_sampling import RandomOverSampler\n", "\n", "#Models of TINTOlib\n", "from TINTOlib.tinto import TINTO\n", "from TINTOlib.supertml import SuperTML\n", "from TINTOlib.igtd import IGTD\n", "from TINTOlib.refined import REFINED\n", "from TINTOlib.barGraph import BarGraph\n", "from TINTOlib.distanceMatrix import DistanceMatrix\n", "from TINTOlib.combination import Combination\n", "import TINTOlib.utils" ] }, { "cell_type": "markdown", "metadata": { "id": "NwS-cKUxjpDQ" }, "source": [ "---\n", "
\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": { "id": "aDL4LARWjpDT" }, "source": [ "\n", "# 3. Data processing" ] }, { "cell_type": "markdown", "metadata": { "id": "jXcRw78ljpDU" }, "source": [ "The first thing to do is to read all the images created by TINTO. TINTO creates a folder which contains subfolders corresponding to each target that has the problem. Each image corresponds to a sample of the original dataset." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "# 3.1. Create images with TINTOlib" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "#Select the model and the parameters\n", "problem_type = \"supervised\"\n", "size = 20\n", "image_model = TINTO(problem=problem_type,verbose=True,blur=True,pixels=size,)\n", "\n", "#Define the dataset path and the folder where the images will be saved\n", "dataset_path = \"/Users/manwest/Carpeta DIGI storage/Jupyter Notebooks/Localizacion/TFG Beatriz/Tx_4.csv\"\n", "images_folder = \"hybridclassification\"\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Normalize dataset" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
B1B2B3B4B5B6Sector
0-60-88-78-76-91-761
1-60-75-76-74-88-741
\n", "
" ], "text/plain": [ " B1 B2 B3 B4 B5 B6 Sector\n", "0 -60 -88 -78 -76 -91 -76 1\n", "1 -60 -75 -76 -74 -88 -74 1" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df = pd.read_csv(dataset_path)\n", "df.head(2)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
B1B2B3B4B5B6Sector
00.9130430.3043480.4680850.5625000.2444440.561
10.9130430.5869570.5106380.6041670.3111110.601
\n", "
" ], "text/plain": [ " B1 B2 B3 B4 B5 B6 Sector\n", "0 0.913043 0.304348 0.468085 0.562500 0.244444 0.56 1\n", "1 0.913043 0.586957 0.510638 0.604167 0.311111 0.60 1" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Select all the attributes to normalize\n", "columns_to_normalize = df.columns[:-1]\n", "\n", "\n", "# Normalize between 0 and 1\n", "df_normalized = (df[columns_to_normalize] - df[columns_to_normalize].min()) / (df[columns_to_normalize].max() - df[columns_to_normalize].min())\n", "\n", "# Combine the attributes and the label\n", "df_normalized = pd.concat([df_normalized, df[df.columns[-1]]], axis=1)\n", "\n", "df_normalized.head(2)\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Generate thet images\n", "image_model.generateImages(df, images_folder)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "hybridclassification/supervised.csv\n" ] } ], "source": [ "img_paths = os.path.join(images_folder,problem_type+\".csv\")\n", "print(img_paths)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "# 3.2. Data Analysis" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHHCAYAAABZbpmkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAzJElEQVR4nO3de5xNZf//8fd2mI05OmQOYYxDOauIplGUybmIijuV3OKuZsopMt05TUnpQCQ63dQdKe6QDkrj1GGIkSgSmgwxo2hmGM1wz1y/P/zs770bI/Zs9p6r1/PxWI/HrGtd61qfWVZ5W+taezuMMUYAAACWKufrAgAAAM4nwg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDmCRunXr6u677/Z1GX5lwoQJcjgcF+RYHTp0UIcOHVzrq1evlsPh0KJFiy7I8e+++27VrVv3ghwLKEsIO0AZsHv3bv3jH/9QvXr1VKlSJYWEhCguLk7PP/+8fv/9d1+Xd8HMnTtXDofDtVSqVElRUVHq3Lmzpk+friNHjnjlOPv379eECRO0efNmr4znTf5cG+CvKvi6AABn9sEHH+jWW2+V0+nUXXfdpWbNmun48eP6/PPPNWrUKH333Xd6+eWXfV3mBZWcnKyYmBidOHFCmZmZWr16tYYNG6bnnntO7733nlq0aOHq++ijj2rMmDHnNP7+/fs1ceJE1a1bV5dddtlZ7/fJJ5+c03E8cabaXnnlFRUVFZ33GoCyhrAD+LH09HT169dP0dHRWrlypSIjI13bEhIStGvXLn3wwQc+rNA3unbtqtatW7vWk5KStHLlSvXo0UM33XSTtm/frsqVK0uSKlSooAoVzu//6o4dO6YqVaooICDgvB7nz1SsWNGnxwf8FY+xAD82ZcoUHT16VK+99ppb0DmlQYMGGjp0aIn7Hz58WA899JCaN2+uoKAghYSEqGvXrvrmm2+K9Z0xY4aaNm2qKlWqqGrVqmrdurXmz5/v2n7kyBENGzZMdevWldPpVM2aNXXDDTdo06ZNbuOsX79eXbp0UWhoqKpUqaL27dvriy++cOtztmOdi+uvv15jx47Vnj179Oabb7raTzdnZ8WKFWrXrp3CwsIUFBSkSy+9VI888oikk/NsrrzySknSwIEDXY/M5s6dK+nkvJxmzZopLS1N1157rapUqeLa949zdk4pLCzUI488ooiICAUGBuqmm27S3r173fqUNN/qf8f8s9pON2cnLy9PI0eOVO3ateV0OnXppZfqmWeekTHGrZ/D4VBiYqKWLFmiZs2ayel0qmnTplq+fPnpTzhQhnBnB/Bjy5YtU7169XT11Vd7tP+PP/6oJUuW6NZbb1VMTIyysrL00ksvqX379tq2bZuioqIknXz88eCDD+qWW27R0KFDlZ+fry1btmj9+vW6/fbbJUn33nuvFi1apMTERDVp0kSHDh3S559/ru3bt+uKK66QJK1cuVJdu3ZVq1atNH78eJUrV05z5szR9ddfr88++0xt2rQ567E8ceedd+qRRx7RJ598osGDB5+2z3fffacePXqoRYsWSk5OltPp1K5du1yBrHHjxkpOTta4ceM0ZMgQXXPNNZLk9mdw6NAhde3aVf369dMdd9yh8PDwM9Y1adIkORwOPfzwwzp48KCmTZum+Ph4bd682XUH6mycTW3/yxijm266SatWrdKgQYN02WWX6eOPP9aoUaP0888/a+rUqW79P//8c7377ru6//77FRwcrOnTp6tPnz7KyMhQ9erVz7pOwO8YAH4pJyfHSDI9e/Y8632io6PNgAEDXOv5+fmmsLDQrU96erpxOp0mOTnZ1dazZ0/TtGnTM44dGhpqEhISStxeVFRkGjZsaDp37myKiopc7ceOHTMxMTHmhhtuOOuxSjJnzhwjyWzYsOGMdV5++eWu9fHjx5v//V/d1KlTjSTzyy+/lDjGhg0bjCQzZ86cYtvat29vJJnZs2efdlv79u1d66tWrTKSzMUXX2xyc3Nd7e+8846RZJ5//nlX2x//7Eoa80y1DRgwwERHR7vWlyxZYiSZxx9/3K3fLbfcYhwOh9m1a5erTZIJCAhwa/vmm2+MJDNjxoxixwLKEh5jAX4qNzdXkhQcHOzxGE6nU+XKnfzPvLCwUIcOHXI9tvnfR0ZhYWHat2+fNmzYUOJYYWFhWr9+vfbv33/a7Zs3b9bOnTt1++2369ChQ/r111/166+/Ki8vTx07dtTatWtdk2f/bKzSCAoKOuNbWWFhYZKkpUuXejyZ1+l0auDAgWfd/6677nL7c7zlllsUGRmpDz/80KPjn60PP/xQ5cuX14MPPujWPnLkSBlj9NFHH7m1x8fHq379+q71Fi1aKCQkRD/++ON5rRM43wg7gJ8KCQmRpFK9Tl1UVKSpU6eqYcOGcjqdqlGjhi666CJt2bJFOTk5rn4PP/ywgoKC1KZNGzVs2FAJCQnF5tlMmTJF3377rWrXrq02bdpowoQJbn8J7ty5U5I0YMAAXXTRRW7Lq6++qoKCAtcx/2ys0jh69OgZA2Lfvn0VFxene+65R+Hh4erXr5/eeeedcwo+F1988TlNRm7YsKHbusPhUIMGDfTTTz+d9Rie2LNnj6Kiooqdj8aNG7u2/686deoUG6Nq1ar67bffzl+RwAVA2AH8VEhIiKKiovTtt996PMYTTzyhESNG6Nprr9Wbb76pjz/+WCtWrFDTpk3d/nJv3LixduzYoQULFqhdu3b6z3/+o3bt2mn8+PGuPrfddpt+/PFHzZgxQ1FRUXr66afVtGlT192BU+M9/fTTWrFixWmXoKCgsxrLU/v27VNOTo4aNGhQYp/KlStr7dq1+vTTT3XnnXdqy5Yt6tu3r2644QYVFhae1XHOZZ7N2Srpgw/PtiZvKF++/GnbzR8mMwNlDWEH8GM9evTQ7t27lZqa6tH+ixYt0nXXXafXXntN/fr1U6dOnRQfH6/s7OxifQMDA9W3b1/NmTNHGRkZ6t69uyZNmqT8/HxXn8jISN1///1asmSJ0tPTVb16dU2aNEmSXI8/QkJCFB8ff9rlf1+NPtNYnvr3v/8tSercufMZ+5UrV04dO3bUc889p23btmnSpElauXKlVq1aJank4OGpU3e9TjHGaNeuXW5vTlWtWvW0fy5/vPtyLrVFR0dr//79xe4Ofv/9967twF8BYQfwY6NHj1ZgYKDuueceZWVlFdu+e/duPf/88yXuX758+WL/Kl+4cKF+/vlnt7ZDhw65rQcEBKhJkyYyxujEiRMqLCx0e+wlSTVr1lRUVJQKCgokSa1atVL9+vX1zDPP6OjRo8Vq+eWXXyTprMbyxMqVK/XYY48pJiZG/fv3L7Hf4cOHi7Wd+nC+U8cPDAyUpNOGD0+88cYbboFj0aJFOnDggLp27epqq1+/vtatW6fjx4+72t5///1ir6ifS23dunVTYWGhXnjhBbf2qVOnyuFwuB0fsBmvngN+rH79+po/f7769u2rxo0bu32C8pdffqmFCxee8buwevTooeTkZA0cOFBXX321tm7dqnnz5qlevXpu/Tp16qSIiAjFxcUpPDxc27dv1wsvvKDu3bsrODhY2dnZqlWrlm655Ra1bNlSQUFB+vTTT7VhwwY9++yzkk7eLXn11VfVtWtXNW3aVAMHDtTFF1+sn3/+WatWrVJISIiWLVumI0eO/OlYf+ajjz7S999/r//+97/KysrSypUrtWLFCkVHR+u9995TpUqVStw3OTlZa9euVffu3RUdHa2DBw/qxRdfVK1atdSuXTvXeQ8LC9Ps2bMVHByswMBAtW3bVjExMWdV3x9Vq1ZN7dq108CBA5WVlaVp06apQYMGbq/H33PPPVq0aJG6dOmi2267Tbt379abb77pNmH4XGu78cYbdd111+mf//ynfvrpJ7Vs2VKffPKJli5dqmHDhhUbG7CWT98FA3BWfvjhBzN48GBTt25dExAQYIKDg01cXJyZMWOGyc/Pd/U73avnI0eONJGRkaZy5comLi7OpKamFnud+aWXXjLXXnutqV69unE6naZ+/fpm1KhRJicnxxhjTEFBgRk1apRp2bKlCQ4ONoGBgaZly5bmxRdfLFbr119/bXr37u0aKzo62tx2220mJSXlnMf6o1Ovnp9aAgICTEREhLnhhhvM888/7/Z69yl/fPU8JSXF9OzZ00RFRZmAgAATFRVl/va3v5kffvjBbb+lS5eaJk2amAoVKri96t2+ffsSX9Mv6dXzt956yyQlJZmaNWuaypUrm+7du5s9e/YU2//ZZ581F198sXE6nSYuLs5s3Lix2Jhnqu2Pr54bY8yRI0fM8OHDTVRUlKlYsaJp2LChefrpp90+HsCYk6+en+7jAEp6JR4oSxzGMPMMAADYizk7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABW40MFdfI7ffbv36/g4GCvf0w8AAA4P4wxOnLkiKKiolSuXMn3bwg7kvbv36/atWv7ugwAAOCBvXv3qlatWiVuJ+xICg4OlnTyZIWEhPi4GgAAcDZyc3NVu3Zt19/jJSHs6P++RTgkJISwAwBAGfNnU1CYoAwAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAVvNp2Fm7dq1uvPFGRUVFyeFwaMmSJW7bjTEaN26cIiMjVblyZcXHx2vnzp1ufQ4fPqz+/fsrJCREYWFhGjRokI4ePXoBfwsAAODPfBp28vLy1LJlS82cOfO026dMmaLp06dr9uzZWr9+vQIDA9W5c2fl5+e7+vTv31/fffedVqxYoffff19r167VkCFDLtSvAAAA/JzDGGN8XYR08ku8Fi9erF69ekk6eVcnKipKI0eO1EMPPSRJysnJUXh4uObOnat+/fpp+/btatKkiTZs2KDWrVtLkpYvX65u3bpp3759ioqKOqtj5+bmKjQ0VDk5OXwRKAAAZcTZ/v3tt3N20tPTlZmZqfj4eFdbaGio2rZtq9TUVElSamqqwsLCXEFHkuLj41WuXDmtX7/+gtcMAAD8TwVfF1CSzMxMSVJ4eLhbe3h4uGtbZmamatas6ba9QoUKqlatmqvP6RQUFKigoMC1npub662yAQCAn/HbsHM+TZ48WRMnTvR1GWel7pgPzqn/T09299r+57pvaff35bFLuz+1+2Z/avfN/tRe+mOXdv+yXLsv+O1jrIiICElSVlaWW3tWVpZrW0REhA4ePOi2/b///a8OHz7s6nM6SUlJysnJcS179+71cvUAAMBf+G3YiYmJUUREhFJSUlxtubm5Wr9+vWJjYyVJsbGxys7OVlpamqvPypUrVVRUpLZt25Y4ttPpVEhIiNsCAADs5NPHWEePHtWuXbtc6+np6dq8ebOqVaumOnXqaNiwYXr88cfVsGFDxcTEaOzYsYqKinK9sdW4cWN16dJFgwcP1uzZs3XixAklJiaqX79+Z/0mFgAAsJtPw87GjRt13XXXudZHjBghSRowYIDmzp2r0aNHKy8vT0OGDFF2drbatWun5cuXq1KlSq595s2bp8TERHXs2FHlypVTnz59NH369Av+uwAAAP/k07DToUMHneljfhwOh5KTk5WcnFxin2rVqmn+/PnnozwAAGABv52zAwAA4A2EHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrEXYAAIDVCDsAAMBqhB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrEXYAAIDVCDsAAMBqhB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYza/DTmFhocaOHauYmBhVrlxZ9evX12OPPSZjjKuPMUbjxo1TZGSkKleurPj4eO3cudOHVQMAAH/i12Hnqaee0qxZs/TCCy9o+/bteuqppzRlyhTNmDHD1WfKlCmaPn26Zs+erfXr1yswMFCdO3dWfn6+DysHAAD+ooKvCziTL7/8Uj179lT37t0lSXXr1tVbb72lr776StLJuzrTpk3To48+qp49e0qS3njjDYWHh2vJkiXq16+fz2oHAAD+wa/v7Fx99dVKSUnRDz/8IEn65ptv9Pnnn6tr166SpPT0dGVmZio+Pt61T2hoqNq2bavU1NQSxy0oKFBubq7bAgAA7OTXd3bGjBmj3NxcNWrUSOXLl1dhYaEmTZqk/v37S5IyMzMlSeHh4W77hYeHu7adzuTJkzVx4sTzVzgAAPAbfn1n55133tG8efM0f/58bdq0Sa+//rqeeeYZvf7666UaNykpSTk5Oa5l7969XqoYAAD4G7++szNq1CiNGTPGNfemefPm2rNnjyZPnqwBAwYoIiJCkpSVlaXIyEjXfllZWbrssstKHNfpdMrpdJ7X2gEAgH/w6zs7x44dU7ly7iWWL19eRUVFkqSYmBhFREQoJSXFtT03N1fr169XbGzsBa0VAAD4J7++s3PjjTdq0qRJqlOnjpo2baqvv/5azz33nP7+979LkhwOh4YNG6bHH39cDRs2VExMjMaOHauoqCj16tXLt8UDAAC/4NdhZ8aMGRo7dqzuv/9+HTx4UFFRUfrHP/6hcePGufqMHj1aeXl5GjJkiLKzs9WuXTstX75clSpV8mHlAADAX/h12AkODta0adM0bdq0Evs4HA4lJycrOTn5whUGAADKDL+eswMAAFBahB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrEXYAAIDVCDsAAMBqhB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrEXYAAIDVCDsAAMBqhB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsJrfh52ff/5Zd9xxh6pXr67KlSurefPm2rhxo2u7MUbjxo1TZGSkKleurPj4eO3cudOHFQMAAH/i12Hnt99+U1xcnCpWrKiPPvpI27Zt07PPPquqVau6+kyZMkXTp0/X7NmztX79egUGBqpz587Kz8/3YeUAAMBfVPB1AWfy1FNPqXbt2pozZ46rLSYmxvWzMUbTpk3To48+qp49e0qS3njjDYWHh2vJkiXq16/fBa8ZAAD4F7++s/Pee++pdevWuvXWW1WzZk1dfvnleuWVV1zb09PTlZmZqfj4eFdbaGio2rZtq9TUVF+UDAAA/IxHYWfv3r3at2+fa/2rr77SsGHD9PLLL3utMEn68ccfNWvWLDVs2FAff/yx7rvvPj344IN6/fXXJUmZmZmSpPDwcLf9wsPDXdtOp6CgQLm5uW4LAACwk0dh5/bbb9eqVasknQwcN9xwg7766iv985//VHJysteKKyoq0hVXXKEnnnhCl19+uYYMGaLBgwdr9uzZpRp38uTJCg0NdS21a9f2UsUAAMDfeBR2vv32W7Vp00aS9M4776hZs2b68ssvNW/ePM2dO9drxUVGRqpJkyZubY0bN1ZGRoYkKSIiQpKUlZXl1icrK8u17XSSkpKUk5PjWvbu3eu1mgEAgH/xKOycOHFCTqdTkvTpp5/qpptukiQ1atRIBw4c8FpxcXFx2rFjh1vbDz/8oOjoaEknJytHREQoJSXFtT03N1fr169XbGxsieM6nU6FhIS4LQAAwE4ehZ2mTZtq9uzZ+uyzz7RixQp16dJFkrR//35Vr17da8UNHz5c69at0xNPPKFdu3Zp/vz5evnll5WQkCBJcjgcGjZsmB5//HG999572rp1q+666y5FRUWpV69eXqsDAACUXR69ev7UU0/p5ptv1tNPP60BAwaoZcuWkk6+PXXq8ZY3XHnllVq8eLGSkpKUnJysmJgYTZs2Tf3793f1GT16tPLy8jRkyBBlZ2erXbt2Wr58uSpVquS1OgAAQNnlUdjp0KGDfv31V+Xm5rp9wN+QIUNUpUoVrxUnST169FCPHj1K3O5wOJScnOzVidEAAMAeHn/OjjFGaWlpeumll3TkyBFJUkBAgNfDDgAAQGl4dGdnz5496tKlizIyMlRQUKAbbrhBwcHBeuqpp1RQUFDqV8MBAAC8xaM7O0OHDlXr1q3122+/qXLlyq72m2++2e3NKAAAAF/z6M7OZ599pi+//FIBAQFu7XXr1tXPP//slcIAAAC8waM7O0VFRSosLCzWvm/fPgUHB5e6KAAAAG/xKOx06tRJ06ZNc607HA4dPXpU48ePV7du3bxVGwAAQKl59Bjr2WefVefOndWkSRPl5+fr9ttv186dO1WjRg299dZb3q4RAADAYx6FnVq1aumbb77RggULtGXLFh09elSDBg1S//793SYsAwAA+JpHYUeSKlSooDvuuMObtQAAAHjdWYed995776wHPfXFoAAAAL521mHnbL9Y0+FwnPZNLQAAAF8467BTVFR0PusAAAA4Lzz+biwAAICywOOwk5KSoh49eqh+/fqqX7++evTooU8//dSbtQEAAJSaR2HnxRdfVJcuXRQcHKyhQ4dq6NChCgkJUbdu3TRz5kxv1wgAAOAxj149f+KJJzR16lQlJia62h588EHFxcXpiSeeUEJCgtcKBAAAKA2P7uxkZ2erS5cuxdo7deqknJycUhcFAADgLR6FnZtuukmLFy8u1r506VL16NGj1EUBAAB4i0ePsZo0aaJJkyZp9erVio2NlSStW7dOX3zxhUaOHKnp06e7+j744IPeqRQAAMADHoWd1157TVWrVtW2bdu0bds2V3tYWJhee+0117rD4SDsAAAAn/Io7KSnp3u7DgAAgPOCDxUEAABW8+jOjjFGixYt0qpVq3Tw4MFiXyXx7rvveqU4AACA0vIo7AwbNkwvvfSSrrvuOoWHh8vhcHi7LgAAAK/wKOz8+9//1rvvvqtu3bp5ux4AAACv8mjOTmhoqOrVq+ftWgAAALzOo7AzYcIETZw4Ub///ru36wEAAPAqjx5j3XbbbXrrrbdUs2ZN1a1bVxUrVnTbvmnTJq8UBwAAUFoehZ0BAwYoLS1Nd9xxBxOUAQCAX/Mo7HzwwQf6+OOP1a5dO2/XAwAA4FUezdmpXbu2QkJCvF0LAACA13kUdp599lmNHj1aP/30k5fLAQAA8C6PHmPdcccdOnbsmOrXr68qVaoUm6B8+PBhrxQHAABQWh6FnWnTpnm5DAAAgPPD47exAAAAygKPws7/ys/P1/Hjx93amLwMAAD8hUcTlPPy8pSYmKiaNWsqMDBQVatWdVsAAAD8hUdhZ/To0Vq5cqVmzZolp9OpV199VRMnTlRUVJTeeOMNb9cIAADgMY8eYy1btkxvvPGGOnTooIEDB+qaa65RgwYNFB0drXnz5ql///7erhMAAMAjHt3ZOXz4sOtbz0NCQlyvmrdr105r1671XnUAAACl5FHYqVevntLT0yVJjRo10jvvvCPp5B2fsLAwrxUHAABQWh6FnYEDB+qbb76RJI0ZM0YzZ85UpUqVNHz4cI0aNcqrBQIAAJSGR3N2hg8f7vo5Pj5e33//vdLS0tSgQQO1aNHCa8UBAACU1jnd2UlNTdX777/v1nZqovK9996rF154QQUFBV4tEAAAoDTOKewkJyfru+++c61v3bpVgwYNUnx8vJKSkrRs2TJNnjzZ60UCAAB46pzCzubNm9WxY0fX+oIFC9S2bVu98sorGj58uKZPn+6arAwAAOAPzins/PbbbwoPD3etr1mzRl27dnWtX3nlldq7d6/3qgMAACilcwo74eHhrlfOjx8/rk2bNumqq65ybT9y5IgqVqzo3QoBAABK4ZzCTrdu3TRmzBh99tlnSkpKUpUqVXTNNde4tm/ZskX169f3epEAAACeOqdXzx977DH17t1b7du3V1BQkF5//XUFBAS4tv/rX/9Sp06dvF4kAACAp84p7NSoUUNr165VTk6OgoKCVL58ebftCxcuVFBQkFcLBAAAKA2PPlQwNDT0tO3VqlUrVTEAAADe5tHXRQAAAJQVhB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNXKVNh58skn5XA4NGzYMFdbfn6+EhISVL16dQUFBalPnz7KysryXZEAAMCvlJmws2HDBr300ktq0aKFW/vw4cO1bNkyLVy4UGvWrNH+/fvVu3dvH1UJAAD8TZkIO0ePHlX//v31yiuvqGrVqq72nJwcvfbaa3ruued0/fXXq1WrVpozZ46+/PJLrVu3zocVAwAAf1Emwk5CQoK6d++u+Ph4t/a0tDSdOHHCrb1Ro0aqU6eOUlNTSxyvoKBAubm5bgsAALCTR18EeiEtWLBAmzZt0oYNG4pty8zMVEBAgMLCwtzaw8PDlZmZWeKYkydP1sSJE71dKgAA8EN+fWdn7969Gjp0qObNm6dKlSp5bdykpCTl5OS4lr1793ptbAAA4F/8OuykpaXp4MGDuuKKK1ShQgVVqFBBa9as0fTp01WhQgWFh4fr+PHjys7OdtsvKytLERERJY7rdDoVEhLitgAAADv59WOsjh07auvWrW5tAwcOVKNGjfTwww+rdu3aqlixolJSUtSnTx9J0o4dO5SRkaHY2FhflAwAAPyMX4ed4OBgNWvWzK0tMDBQ1atXd7UPGjRII0aMULVq1RQSEqIHHnhAsbGxuuqqq3xRMgAA8DN+HXbOxtSpU1WuXDn16dNHBQUF6ty5s1588UVflwUAAPxEmQs7q1evdluvVKmSZs6cqZkzZ/qmIAAA4Nf8eoIyAABAaRF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrEXYAAIDVCDsAAMBqhB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrEXYAAIDVCDsAAMBqhB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrEXYAAIDVCDsAAMBqfh12Jk+erCuvvFLBwcGqWbOmevXqpR07drj1yc/PV0JCgqpXr66goCD16dNHWVlZPqoYAAD4G78OO2vWrFFCQoLWrVunFStW6MSJE+rUqZPy8vJcfYYPH65ly5Zp4cKFWrNmjfbv36/evXv7sGoAAOBPKvi6gDNZvny52/rcuXNVs2ZNpaWl6dprr1VOTo5ee+01zZ8/X9dff70kac6cOWrcuLHWrVunq666yhdlAwAAP+LXd3b+KCcnR5JUrVo1SVJaWppOnDih+Ph4V59GjRqpTp06Sk1NLXGcgoIC5ebmui0AAMBOZSbsFBUVadiwYYqLi1OzZs0kSZmZmQoICFBYWJhb3/DwcGVmZpY41uTJkxUaGupaateufT5LBwAAPlRmwk5CQoK+/fZbLViwoNRjJSUlKScnx7Xs3bvXCxUCAAB/5Ndzdk5JTEzU+++/r7Vr16pWrVqu9oiICB0/flzZ2dlud3eysrIUERFR4nhOp1NOp/N8lgwAAPyEX9/ZMcYoMTFRixcv1sqVKxUTE+O2vVWrVqpYsaJSUlJcbTt27FBGRoZiY2MvdLkAAMAP+fWdnYSEBM2fP19Lly5VcHCwax5OaGioKleurNDQUA0aNEgjRoxQtWrVFBISogceeECxsbG8iQUAACT5ediZNWuWJKlDhw5u7XPmzNHdd98tSZo6darKlSunPn36qKCgQJ07d9aLL754gSsFAAD+yq/DjjHmT/tUqlRJM2fO1MyZMy9ARQAAoKzx6zk7AAAApUXYAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrEXYAAIDVCDsAAMBqhB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrEXYAAIDVCDsAAMBqhB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrWRN2Zs6cqbp166pSpUpq27atvvrqK1+XBAAA/IAVYeftt9/WiBEjNH78eG3atEktW7ZU586ddfDgQV+XBgAAfMyKsPPcc89p8ODBGjhwoJo0aaLZs2erSpUq+te//uXr0gAAgI+V+bBz/PhxpaWlKT4+3tVWrlw5xcfHKzU11YeVAQAAf1DB1wWU1q+//qrCwkKFh4e7tYeHh+v7778/7T4FBQUqKChwrefk5EiScnNzz1+hHioqOHZO/f/4O5Rm/3Pdt7T7+/LYpd2f2n2zP7X7Zn9qL/2xS7t/Wa7dm06Na4w5c0dTxv38889Gkvnyyy/d2keNGmXatGlz2n3Gjx9vJLGwsLCwsLBYsOzdu/eMWaHM39mpUaOGypcvr6ysLLf2rKwsRUREnHafpKQkjRgxwrVeVFSkw4cPq3r16nI4HGd13NzcXNWuXVt79+5VSEiI57/AXwznzTOcN89x7jzDefMM581znpw7Y4yOHDmiqKioM/Yr82EnICBArVq1UkpKinr16iXpZHhJSUlRYmLiafdxOp1yOp1ubWFhYR4dPyQkhAvaA5w3z3DePMe58wznzTOcN8+d67kLDQ390z5lPuxI0ogRIzRgwAC1bt1abdq00bRp05SXl6eBAwf6ujQAAOBjVoSdvn376pdfftG4ceOUmZmpyy67TMuXLy82aRkAAPz1WBF2JCkxMbHEx1bng9Pp1Pjx44s9DsOZcd48w3nzHOfOM5w3z3DePHc+z53DmD97XwsAAKDsKvMfKggAAHAmhB0AAGA1wg4AALAaYQcAAFiNsOOBmTNnqm7duqpUqZLatm2rr776ytcl+b0JEybI4XC4LY0aNfJ1WX5n7dq1uvHGGxUVFSWHw6ElS5a4bTfGaNy4cYqMjFTlypUVHx+vnTt3+qZYP/Jn5+3uu+8udv116dLFN8X6kcmTJ+vKK69UcHCwatasqV69emnHjh1uffLz85WQkKDq1asrKChIffr0KfaJ9X81Z3PeOnToUOyau/fee31Usf+YNWuWWrRo4frgwNjYWH300Ueu7efreiPsnKO3335bI0aM0Pjx47Vp0ya1bNlSnTt31sGDB31dmt9r2rSpDhw44Fo+//xzX5fkd/Ly8tSyZUvNnDnztNunTJmi6dOna/bs2Vq/fr0CAwPVuXNn5efnX+BK/cufnTdJ6tKli9v199Zbb13ACv3TmjVrlJCQoHXr1mnFihU6ceKEOnXqpLy8PFef4cOHa9myZVq4cKHWrFmj/fv3q3fv3j6s2vfO5rxJ0uDBg92uuSlTpvioYv9Rq1YtPfnkk0pLS9PGjRt1/fXXq2fPnvruu+8kncfrzSvfxvkX0qZNG5OQkOBaLywsNFFRUWby5Mk+rMr/jR8/3rRs2dLXZZQpkszixYtd60VFRSYiIsI8/fTTrrbs7GzjdDrNW2+95YMK/dMfz5sxxgwYMMD07NnTJ/WUJQcPHjSSzJo1a4wxJ6+vihUrmoULF7r6bN++3UgyqampvirT7/zxvBljTPv27c3QoUN9V1QZUrVqVfPqq6+e1+uNOzvn4Pjx40pLS1N8fLyrrVy5coqPj1dqaqoPKysbdu7cqaioKNWrV0/9+/dXRkaGr0sqU9LT05WZmel2/YWGhqpt27Zcf2dh9erVqlmzpi699FLdd999OnTokK9L8js5OTmSpGrVqkmS0tLSdOLECbdrrlGjRqpTpw7X3P/443k7Zd68eapRo4aaNWumpKQkHTt2zBfl+a3CwkItWLBAeXl5io2NPa/XmzWfoHwh/PrrryosLCz2NRTh4eH6/vvvfVRV2dC2bVvNnTtXl156qQ4cOKCJEyfqmmuu0bfffqvg4GBfl1cmZGZmStJpr79T23B6Xbp0Ue/evRUTE6Pdu3frkUceUdeuXZWamqry5cv7ujy/UFRUpGHDhikuLk7NmjWTdPKaCwgIKPZFyVxz/+d0502Sbr/9dkVHRysqKkpbtmzRww8/rB07dujdd9/1YbX+YevWrYqNjVV+fr6CgoK0ePFiNWnSRJs3bz5v1xthBxdE165dXT+3aNFCbdu2VXR0tN555x0NGjTIh5Xhr6Bfv36un5s3b64WLVqofv36Wr16tTp27OjDyvxHQkKCvv32W+bSnaOSztuQIUNcPzdv3lyRkZHq2LGjdu/erfr161/oMv3KpZdeqs2bNysnJ0eLFi3SgAEDtGbNmvN6TB5jnYMaNWqofPnyxWaGZ2VlKSIiwkdVlU1hYWG65JJLtGvXLl+XUmacusa4/kqvXr16qlGjBtff/5eYmKj3339fq1atUq1atVztEREROn78uLKzs936c82dVNJ5O522bdtKEtecpICAADVo0ECtWrXS5MmT1bJlSz3//PPn9Xoj7JyDgIAAtWrVSikpKa62oqIipaSkKDY21oeVlT1Hjx7V7t27FRkZ6etSyoyYmBhFRES4XX+5ublav34919852rdvnw4dOvSXv/6MMUpMTNTixYu1cuVKxcTEuG1v1aqVKlas6HbN7dixQxkZGX/pa+7PztvpbN68WZL+8tfc6RQVFamgoOD8Xm+lm0P917NgwQLjdDrN3LlzzbZt28yQIUNMWFiYyczM9HVpfm3kyJFm9erVJj093XzxxRcmPj7e1KhRwxw8eNDXpfmVI0eOmK+//tp8/fXXRpJ57rnnzNdff2327NljjDHmySefNGFhYWbp0qVmy5YtpmfPniYmJsb8/vvvPq7ct8503o4cOWIeeughk5qaatLT082nn35qrrjiCtOwYUOTn5/v69J96r777jOhoaFm9erV5sCBA67l2LFjrj733nuvqVOnjlm5cqXZuHGjiY2NNbGxsT6s2vf+7Lzt2rXLJCcnm40bN5r09HSzdOlSU69ePXPttdf6uHLfGzNmjFmzZo1JT083W7ZsMWPGjDEOh8N88sknxpjzd70RdjwwY8YMU6dOHRMQEGDatGlj1q1b5+uS/F7fvn1NZGSkCQgIMBdffLHp27ev2bVrl6/L8jurVq0ykootAwYMMMacfP187NixJjw83DidTtOxY0ezY8cO3xbtB8503o4dO2Y6depkLrroIlOxYkUTHR1tBg8ezD9QjDntOZNk5syZ4+rz+++/m/vvv99UrVrVVKlSxdx8883mwIEDvivaD/zZecvIyDDXXnutqVatmnE6naZBgwZm1KhRJicnx7eF+4G///3vJjo62gQEBJiLLrrIdOzY0RV0jDl/15vDGGNKd28IAADAfzFnBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOgDLP4XBoyZIlvi4DgJ8i7ADwe5mZmXrggQdUr149OZ1O1a5dWzfeeKPbd+gAQEkq+LoAADiTn376SXFxcQoLC9PTTz+t5s2b68SJE/r444+VkJCg77//3tclAvBz3NkB4Nfuv/9+ORwOffXVV+rTp48uueQSNW3aVCNGjNC6detOu8/DDz+sSy65RFWqVFG9evU0duxYnThxwrX9m2++0XXXXafg4GCFhISoVatW2rhxoyRpz549uvHGG1W1alUFBgaqadOm+vDDDy/I7wrg/ODODgC/dfjwYS1fvlyTJk1SYGBgse1hYWGn3S84OFhz585VVFSUtm7dqsGDBys4OFijR4+WJPXv31+XX365Zs2apfLly2vz5s2qWLGiJCkhIUHHjx/X2rVrFRgYqG3btikoKOi8/Y4Azj/CDgC/tWvXLhlj1KhRo3Pa79FHH3X9XLduXT300ENasGCBK+xkZGRo1KhRrnEbNmzo6p+RkaE+ffqoefPmkqR69eqV9tcA4GM8xgLgt4wxHu339ttvKy4uThEREQoKCtKjjz6qjIwM1/YRI0bonnvuUXx8vJ588knt3r3bte3BBx/U448/rri4OI0fP15btmwp9e8BwLcIOwD8VsOGDeVwOM5pEnJqaqr69++vbt266f3339fXX3+tf/7znzp+/Lirz4QJE/Tdd9+pe/fuWrlypZo0aaLFixdLku655x79+OOPuvPOO7V161a1bt1aM2bM8PrvBuDCcRhP/+kEABdA165dtXXrVu3YsaPYvJ3s7GyFhYXJ4XBo8eLF6tWrl5599lm9+OKLbndr7rnnHi1atEjZ2dmnPcbf/vY35eXl6b333iu2LSkpSR988AF3eIAyjDs7APzazJkzVVhYqDZt2ug///mPdu7cqe3bt2v69OmKjY0t1r9hw4bKyMjQggULtHv3bk2fPt1110aSfv/9dyUmJmr16tXas2ePvvjiC23YsEGNGzeWJA0bNkwff/yx0tPTtWnTJq1atcq1DUDZxARlAH6tXr162rRpkyZNmqSRI0fqwIEDuuiii9SqVSvNmjWrWP+bbrpJw4cPV2JiogoKCtS9e3eNHTtWEyZMkCSVL19ehw4d0l133aWsrCzVqFFDvXv31sSJEyVJhYWFSkhI0L59+xQSEqIuXbpo6tSpF/JXBuBlPMYCAABW4zEWAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrEXYAAIDVCDsAAMBqhB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFb7f0EWIQVDYn6JAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "target_values = df.Sector\n", "class_counts = np.bincount(target_values)\n", "class_labels = np.arange(1, len(class_counts) + 1)\n", "\n", "# Crea el gráfico de barras\n", "plt.bar(class_labels, class_counts)\n", "\n", "# Personaliza el gráfico\n", "plt.xlabel('Class')\n", "plt.ylabel('Samples')\n", "plt.title('Classes Distribution')\n", "\n", "# Muestra el gráfico\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "id": "klS9PZsUjpDV" }, "source": [ "\n", "# 3.3. Read images" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
imagesB1B2B3B4B5B6
0hybridclassification/01/000000.png0.9130430.3043480.4680850.5625000.2444440.56
1hybridclassification/01/000001.png0.9130430.5869570.5106380.6041670.3111110.60
\n", "
" ], "text/plain": [ " images B1 B2 B3 B4 \\\n", "0 hybridclassification/01/000000.png 0.913043 0.304348 0.468085 0.562500 \n", "1 hybridclassification/01/000001.png 0.913043 0.586957 0.510638 0.604167 \n", "\n", " B5 B6 \n", "0 0.244444 0.56 \n", "1 0.311111 0.60 " ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "imgs = pd.read_csv(img_paths)\n", "\n", "#imgs[\"images\"]= images_folder + \"\\\\\" + imgs[\"images\"]\n", "imgs[\"images\"]= images_folder + \"/\" + imgs[\"images\"]\n", "\n", "combined_dataset = pd.concat([imgs,df_normalized[columns_to_normalize]],axis=1)\n", "combined_dataset\n", "\n", "df_x = combined_dataset.drop(\"class\",axis=1)\n", "df_y = combined_dataset[\"class\"].replace(-1, 0)\n", "\n", "df_x.head(2)" ] }, { "cell_type": "markdown", "metadata": { "id": "_haEKIo7jpD1" }, "source": [ "---\n", "
\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": { "id": "uF1lJWbojpD3" }, "source": [ "\n", "# 4. Pre-modelling phase" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Image shape (20, 20, 3)\n", "Attributes 6\n", "Classes 28\n" ] } ], "source": [ "import cv2\n", "X_train, X_val, y_train, y_val = train_test_split(df_x, df_y, test_size = 0.40, random_state = 123,stratify=df_y)\n", "X_val, X_test, y_val, y_test = train_test_split(X_val, y_val, test_size = 0.50, random_state = 123, stratify=y_val)\n", "\n", "X_train_num = X_train.drop(\"images\",axis=1)\n", "X_val_num = X_val.drop(\"images\",axis=1)\n", "X_test_num = X_test.drop(\"images\",axis=1)\n", "\n", "X_train_img = np.array([cv2.imread(img) for img in X_train[\"images\"]])\n", "X_val_img = np.array([cv2.imread(img) for img in X_val[\"images\"]])\n", "X_test_img = np.array([cv2.imread(img) for img in X_test[\"images\"]])\n", "\n", "\"\"\"X_train_img = np.array([cv2.resize(cv2.imread(img),(60,60)) for img in X_train[\"images\"]])\n", "X_val_img = np.array([cv2.resize(cv2.imread(img),(60,60)) for img in X_val[\"images\"]])\n", "X_test_img = np.array([cv2.resize(cv2.imread(img),(60,60)) for img in X_test[\"images\"]])\"\"\"\n", "\n", "n_class = df['Sector'].value_counts().count()\n", "attributes = len(X_train_num.columns)\n", "print(\"Image shape\",X_train_img[0].shape)\n", "print(\"Attributes\",attributes)\n", "print(\"Classes\",n_class)\n" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#SPLITS CLASS DISTRIBUTION\n", "\n", "train_class_counts = np.bincount(y_train)\n", "val_class_counts = np.bincount(y_val)\n", "test_class_counts = np.bincount(y_test)\n", "\n", "width = 0.35 \n", "#plt.bar(class_labels, train_class_counts, width, label='Train')\n", "plt.bar(class_labels + width, val_class_counts, width, label='Validation')\n", "plt.bar(class_labels + width*2, test_class_counts, width, label='Test')\n", "\n", "plt.xlabel('Class')\n", "plt.ylabel('Samples')\n", "plt.title('Classes distribution')\n", "#plt.xticks(class_labels + width / 2, class_labels)\n", "plt.legend()\n", "\n", "# Mostrar el gráfico\n", "plt.show()\n" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "#ONE HOT ENCODING FOR MULTICLASS PROBLEMS\n", "from tensorflow.keras.utils import to_categorical\n", "\n", "# y-1 because target is between [1,28] and not [0,27]\n", "y_train_oh = to_categorical(y_train-1,n_class)\n", "y_val_oh = to_categorical(y_val-1,n_class)\n", "y_test_oh = to_categorical(y_test-1,n_class)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1202 13\n", "250 3\n", "1328 14\n", "2158 22\n", "591 6\n", " ..\n", "1883 19\n", "2092 21\n", "1415 15\n", "2199 22\n", "438 5\n", "Name: class, Length: 560, dtype: int64" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y_val" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.,\n", " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y_val_oh[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "# 5. Modeling hybrid network" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [], "source": [ "dropout = 0.3" ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [], "source": [ "filters_ffnn = [64,32,16]\n", "\n", "ff_model = Sequential()\n", "ff_model.add(Input(shape=(attributes,)))\n", "\n", "for layer in filters_ffnn:\n", " ff_model.add(Dense(layer, activation=\"relu\"))\n", " #ff_model.add(BatchNormalization())\n", " ff_model.add(Dropout(dropout))" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [], "source": [ "filters_cnn = [16,32, 64]\n", "\n", "cnn_model = Sequential()\n", "cnn_model.add(Input(shape=(size,size, 3)))\n", "\n", "for layer in filters_cnn:\n", " cnn_model.add(Conv2D(layer, (3, 3), padding=\"same\"))\n", " cnn_model.add(Activation(\"relu\"))\n", " #cnn_model.add(BatchNormalization())\n", " cnn_model.add(MaxPooling2D(pool_size=(2, 2)))\n", "\n", "# flatten the volume, then FC => RELU => BN => DROPOUT\n", "cnn_model.add(Flatten())\n", "cnn_model.add(Dense(128))\n", "cnn_model.add(Activation(\"relu\"))\n", "#cnn_model.add(BatchNormalization())\n", "cnn_model.add(Dropout(dropout))\n", "\n", "# apply another FC layer, this one to match the number of nodes\n", "# coming out of the MLP\n", "cnn_model.add(Dense(64))\n", "cnn_model.add(Activation(\"relu\"))\n", "cnn_model.add(Dropout(dropout))\n", "\n" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [], "source": [ "combinedInput = concatenate([ff_model.output, cnn_model.output])\n", "x = Dense(32, activation=\"relu\")(combinedInput)\n", "#x = BatchNormalization()(x)\n", "x = Dropout(dropout)(x)\n", "x = Dense(n_class, activation=\"softmax\")(x)\n", "\n", "model = Model(inputs=[ff_model.input, cnn_model.input], outputs=x)" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [], "source": [ "METRICS = [\n", " #tf.keras.metrics.TruePositives(name = 'tp'),\n", " #tf.keras.metrics.FalsePositives(name = 'fp'),\n", " #tf.keras.metrics.TrueNegatives(name = 'tn'),\n", " #tf.keras.metrics.FalseNegatives(name = 'fn'), \n", " tf.keras.metrics.CategoricalAccuracy(name ='accuracy'),\n", " tf.keras.metrics.Precision(name = 'precision'),\n", " tf.keras.metrics.Recall(name = 'recall'),\n", " tf.keras.metrics.AUC(name = 'auc'),\n", "]" ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [], "source": [ "#HYPERPARAMETERS\n", "opt = tf.keras.optimizers.legacy.Adam(learning_rate=1e-5)\n", "model.compile(\n", " loss=\"categorical_crossentropy\", \n", " optimizer=opt,\n", " metrics = METRICS\n", ")\n", "epochs = 500" ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [], "source": [ "# Define EarlyStopping callback\n", "early_stopping = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=10, mode=\"max\" ,restore_best_weights=True)" ] }, { "cell_type": "code", "execution_count": 55, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 1/500\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "210/210 [==============================] - 5s 22ms/step - loss: 3.4466 - accuracy: 0.0393 - precision: 0.0000e+00 - recall: 0.0000e+00 - auc: 0.4981 - val_loss: 3.3613 - val_accuracy: 0.0339 - val_precision: 0.0000e+00 - val_recall: 0.0000e+00 - val_auc: 0.4912\n", "Epoch 2/500\n", "210/210 [==============================] - 4s 20ms/step - loss: 3.4218 - accuracy: 0.0464 - precision: 0.0000e+00 - recall: 0.0000e+00 - auc: 0.5034 - val_loss: 3.3563 - val_accuracy: 0.0357 - val_precision: 0.0000e+00 - val_recall: 0.0000e+00 - val_auc: 0.4973\n", "Epoch 3/500\n", "210/210 [==============================] - 4s 20ms/step - loss: 3.4103 - accuracy: 0.0399 - precision: 0.0000e+00 - recall: 0.0000e+00 - auc: 0.5084 - val_loss: 3.3530 - val_accuracy: 0.0339 - val_precision: 0.0000e+00 - val_recall: 0.0000e+00 - val_auc: 0.5036\n", "Epoch 4/500\n", "210/210 [==============================] - 4s 20ms/step - loss: 3.4061 - accuracy: 0.0446 - precision: 0.0000e+00 - recall: 0.0000e+00 - auc: 0.5027 - val_loss: 3.3505 - val_accuracy: 0.0357 - val_precision: 0.0000e+00 - val_recall: 0.0000e+00 - val_auc: 0.4946\n", "Epoch 5/500\n", "210/210 [==============================] - 4s 20ms/step - loss: 3.4099 - accuracy: 0.0405 - precision: 0.0000e+00 - recall: 0.0000e+00 - auc: 0.4936 - val_loss: 3.3492 - val_accuracy: 0.0357 - val_precision: 0.0000e+00 - val_recall: 0.0000e+00 - val_auc: 0.4938\n", "Epoch 6/500\n", "210/210 [==============================] - 4s 20ms/step - loss: 3.4086 - accuracy: 0.0375 - precision: 0.0000e+00 - recall: 0.0000e+00 - auc: 0.4982 - val_loss: 3.3484 - val_accuracy: 0.0393 - val_precision: 0.0000e+00 - val_recall: 0.0000e+00 - val_auc: 0.4980\n", "Epoch 7/500\n", "210/210 [==============================] - 4s 20ms/step - loss: 3.4042 - accuracy: 0.0446 - precision: 0.0000e+00 - recall: 0.0000e+00 - auc: 0.5045 - val_loss: 3.3485 - val_accuracy: 0.0411 - val_precision: 0.0000e+00 - val_recall: 0.0000e+00 - val_auc: 0.5062\n", "Epoch 8/500\n", "210/210 [==============================] - 4s 20ms/step - loss: 3.4011 - accuracy: 0.0369 - precision: 0.0000e+00 - recall: 0.0000e+00 - auc: 0.5038 - val_loss: 3.3472 - val_accuracy: 0.0393 - val_precision: 0.0000e+00 - val_recall: 0.0000e+00 - val_auc: 0.4966\n", "Epoch 9/500\n", "210/210 [==============================] - 4s 20ms/step - loss: 3.4028 - accuracy: 0.0363 - precision: 0.0000e+00 - recall: 0.0000e+00 - auc: 0.5029 - val_loss: 3.3467 - val_accuracy: 0.0446 - val_precision: 0.0000e+00 - val_recall: 0.0000e+00 - val_auc: 0.4931\n", "Epoch 10/500\n", "209/210 [============================>.] - ETA: 0s - loss: 3.3999 - accuracy: 0.0449 - precision: 0.0000e+00 - recall: 0.0000e+00 - auc: 0.5067" ] }, { "ename": "KeyboardInterrupt", "evalue": "", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", "Cell \u001b[0;32mIn[55], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m model_history\u001b[38;5;241m=\u001b[39m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mX_train_num\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mX_train_img\u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[38;5;241;43m255\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43my_train_oh\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43mX_val_num\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mX_val_img\u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[38;5;241;43m255\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_val_oh\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mepochs\u001b[49m\u001b[43m \u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m8\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m#steps_per_epoch = X_train_num.shape[0]//batch_size,\u001b[39;49;00m\n\u001b[1;32m 7\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m#validation_steps = X_train_num.shape[0]//batch_size,\u001b[39;49;00m\n\u001b[1;32m 8\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m#callbacks=[early_stopping]\u001b[39;49;00m\n\u001b[1;32m 9\u001b[0m \u001b[43m)\u001b[49m\n", "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/keras/src/utils/traceback_utils.py:65\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 63\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 64\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 65\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 66\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 67\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n", "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/keras/src/engine/training.py:1856\u001b[0m, in \u001b[0;36mModel.fit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m 1840\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_eval_data_handler\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m) \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 1841\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_eval_data_handler \u001b[38;5;241m=\u001b[39m data_adapter\u001b[38;5;241m.\u001b[39mget_data_handler(\n\u001b[1;32m 1842\u001b[0m x\u001b[38;5;241m=\u001b[39mval_x,\n\u001b[1;32m 1843\u001b[0m y\u001b[38;5;241m=\u001b[39mval_y,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1854\u001b[0m pss_evaluation_shards\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pss_evaluation_shards,\n\u001b[1;32m 1855\u001b[0m )\n\u001b[0;32m-> 1856\u001b[0m val_logs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mevaluate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1857\u001b[0m \u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mval_x\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1858\u001b[0m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mval_y\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1859\u001b[0m \u001b[43m \u001b[49m\u001b[43msample_weight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mval_sample_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1860\u001b[0m \u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvalidation_batch_size\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1861\u001b[0m \u001b[43m \u001b[49m\u001b[43msteps\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvalidation_steps\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1862\u001b[0m \u001b[43m \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcallbacks\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1863\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_queue_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_queue_size\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1864\u001b[0m \u001b[43m \u001b[49m\u001b[43mworkers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mworkers\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1865\u001b[0m \u001b[43m \u001b[49m\u001b[43muse_multiprocessing\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_multiprocessing\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1866\u001b[0m \u001b[43m \u001b[49m\u001b[43mreturn_dict\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 1867\u001b[0m \u001b[43m \u001b[49m\u001b[43m_use_cached_eval_dataset\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 1868\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1869\u001b[0m val_logs \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m 1870\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mval_\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m name: val \u001b[38;5;28;01mfor\u001b[39;00m name, val \u001b[38;5;129;01min\u001b[39;00m val_logs\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 1871\u001b[0m }\n\u001b[1;32m 1872\u001b[0m epoch_logs\u001b[38;5;241m.\u001b[39mupdate(val_logs)\n", "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/keras/src/utils/traceback_utils.py:65\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 63\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 64\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 65\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 66\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 67\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n", "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/keras/src/engine/training.py:2296\u001b[0m, in \u001b[0;36mModel.evaluate\u001b[0;34m(self, x, y, batch_size, verbose, sample_weight, steps, callbacks, max_queue_size, workers, use_multiprocessing, return_dict, **kwargs)\u001b[0m\n\u001b[1;32m 2292\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m tf\u001b[38;5;241m.\u001b[39mprofiler\u001b[38;5;241m.\u001b[39mexperimental\u001b[38;5;241m.\u001b[39mTrace(\n\u001b[1;32m 2293\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtest\u001b[39m\u001b[38;5;124m\"\u001b[39m, step_num\u001b[38;5;241m=\u001b[39mstep, _r\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 2294\u001b[0m ):\n\u001b[1;32m 2295\u001b[0m callbacks\u001b[38;5;241m.\u001b[39mon_test_batch_begin(step)\n\u001b[0;32m-> 2296\u001b[0m logs \u001b[38;5;241m=\u001b[39m \u001b[43mtest_function_runner\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun_step\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2297\u001b[0m \u001b[43m \u001b[49m\u001b[43mdataset_or_iterator\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2298\u001b[0m \u001b[43m \u001b[49m\u001b[43mdata_handler\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2299\u001b[0m \u001b[43m \u001b[49m\u001b[43mstep\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2300\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_pss_evaluation_shards\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2301\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2303\u001b[0m logs \u001b[38;5;241m=\u001b[39m tf_utils\u001b[38;5;241m.\u001b[39msync_to_numpy_or_python_type(logs)\n\u001b[1;32m 2304\u001b[0m \u001b[38;5;66;03m# Override with model metrics instead of last step logs\u001b[39;00m\n", "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/keras/src/engine/training.py:4108\u001b[0m, in \u001b[0;36m_TestFunction.run_step\u001b[0;34m(self, dataset_or_iterator, data_handler, step, unused_shards)\u001b[0m\n\u001b[1;32m 4107\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrun_step\u001b[39m(\u001b[38;5;28mself\u001b[39m, dataset_or_iterator, data_handler, step, unused_shards):\n\u001b[0;32m-> 4108\u001b[0m tmp_logs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdataset_or_iterator\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 4109\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m data_handler\u001b[38;5;241m.\u001b[39mshould_sync:\n\u001b[1;32m 4110\u001b[0m context\u001b[38;5;241m.\u001b[39masync_wait()\n", "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/tensorflow/python/util/traceback_utils.py:150\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 148\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 149\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 150\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 151\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 152\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n", "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:832\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 829\u001b[0m compiler \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mxla\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnonXla\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 831\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m OptionalXlaContext(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile):\n\u001b[0;32m--> 832\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 834\u001b[0m new_tracing_count \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexperimental_get_tracing_count()\n\u001b[1;32m 835\u001b[0m without_tracing \u001b[38;5;241m=\u001b[39m (tracing_count \u001b[38;5;241m==\u001b[39m new_tracing_count)\n", "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:877\u001b[0m, in \u001b[0;36mFunction._call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 874\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39mrelease()\n\u001b[1;32m 875\u001b[0m \u001b[38;5;66;03m# In this case we have not created variables on the first call. So we can\u001b[39;00m\n\u001b[1;32m 876\u001b[0m \u001b[38;5;66;03m# run the first trace but we should fail if variables are created.\u001b[39;00m\n\u001b[0;32m--> 877\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[43mtracing_compilation\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 878\u001b[0m \u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_variable_creation_config\u001b[49m\n\u001b[1;32m 879\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 880\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_created_variables:\n\u001b[1;32m 881\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCreating variables on a non-first call to a function\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 882\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m decorated with tf.function.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/tensorflow/python/eager/polymorphic_function/tracing_compilation.py:139\u001b[0m, in \u001b[0;36mcall_function\u001b[0;34m(args, kwargs, tracing_options)\u001b[0m\n\u001b[1;32m 137\u001b[0m bound_args \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mbind(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 138\u001b[0m flat_inputs \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39munpack_inputs(bound_args)\n\u001b[0;32m--> 139\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# pylint: disable=protected-access\u001b[39;49;00m\n\u001b[1;32m 140\u001b[0m \u001b[43m \u001b[49m\u001b[43mflat_inputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcaptured_inputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcaptured_inputs\u001b[49m\n\u001b[1;32m 141\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/tensorflow/python/eager/polymorphic_function/concrete_function.py:1323\u001b[0m, in \u001b[0;36mConcreteFunction._call_flat\u001b[0;34m(self, tensor_inputs, captured_inputs)\u001b[0m\n\u001b[1;32m 1319\u001b[0m possible_gradient_type \u001b[38;5;241m=\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPossibleTapeGradientTypes(args)\n\u001b[1;32m 1320\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (possible_gradient_type \u001b[38;5;241m==\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPOSSIBLE_GRADIENT_TYPES_NONE\n\u001b[1;32m 1321\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m executing_eagerly):\n\u001b[1;32m 1322\u001b[0m \u001b[38;5;66;03m# No tape is watching; skip to running the function.\u001b[39;00m\n\u001b[0;32m-> 1323\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_inference_function\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_preflattened\u001b[49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1324\u001b[0m forward_backward \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_select_forward_and_backward_functions(\n\u001b[1;32m 1325\u001b[0m args,\n\u001b[1;32m 1326\u001b[0m possible_gradient_type,\n\u001b[1;32m 1327\u001b[0m executing_eagerly)\n\u001b[1;32m 1328\u001b[0m forward_function, args_with_tangents \u001b[38;5;241m=\u001b[39m forward_backward\u001b[38;5;241m.\u001b[39mforward()\n", "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py:216\u001b[0m, in \u001b[0;36mAtomicFunction.call_preflattened\u001b[0;34m(self, args)\u001b[0m\n\u001b[1;32m 214\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcall_preflattened\u001b[39m(\u001b[38;5;28mself\u001b[39m, args: Sequence[core\u001b[38;5;241m.\u001b[39mTensor]) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[1;32m 215\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Calls with flattened tensor inputs and returns the structured output.\"\"\"\u001b[39;00m\n\u001b[0;32m--> 216\u001b[0m flat_outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 217\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mpack_output(flat_outputs)\n", "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py:251\u001b[0m, in \u001b[0;36mAtomicFunction.call_flat\u001b[0;34m(self, *args)\u001b[0m\n\u001b[1;32m 249\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m record\u001b[38;5;241m.\u001b[39mstop_recording():\n\u001b[1;32m 250\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mexecuting_eagerly():\n\u001b[0;32m--> 251\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_bound_context\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 252\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 253\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 254\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunction_type\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mflat_outputs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 255\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 256\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 257\u001b[0m outputs \u001b[38;5;241m=\u001b[39m make_call_op_in_graph(\n\u001b[1;32m 258\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 259\u001b[0m \u001b[38;5;28mlist\u001b[39m(args),\n\u001b[1;32m 260\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mfunction_call_options\u001b[38;5;241m.\u001b[39mas_attrs(),\n\u001b[1;32m 261\u001b[0m )\n", "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/tensorflow/python/eager/context.py:1486\u001b[0m, in \u001b[0;36mContext.call_function\u001b[0;34m(self, name, tensor_inputs, num_outputs)\u001b[0m\n\u001b[1;32m 1484\u001b[0m cancellation_context \u001b[38;5;241m=\u001b[39m cancellation\u001b[38;5;241m.\u001b[39mcontext()\n\u001b[1;32m 1485\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cancellation_context \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 1486\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mexecute\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1487\u001b[0m \u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecode\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mutf-8\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1488\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_outputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1489\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtensor_inputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1490\u001b[0m \u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1491\u001b[0m \u001b[43m \u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1492\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1493\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1494\u001b[0m outputs \u001b[38;5;241m=\u001b[39m execute\u001b[38;5;241m.\u001b[39mexecute_with_cancellation(\n\u001b[1;32m 1495\u001b[0m name\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mutf-8\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[1;32m 1496\u001b[0m num_outputs\u001b[38;5;241m=\u001b[39mnum_outputs,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1500\u001b[0m cancellation_manager\u001b[38;5;241m=\u001b[39mcancellation_context,\n\u001b[1;32m 1501\u001b[0m )\n", "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/tensorflow/python/eager/execute.py:53\u001b[0m, in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m 51\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 52\u001b[0m ctx\u001b[38;5;241m.\u001b[39mensure_initialized()\n\u001b[0;32m---> 53\u001b[0m tensors \u001b[38;5;241m=\u001b[39m \u001b[43mpywrap_tfe\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mTFE_Py_Execute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_handle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mop_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 54\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 55\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_NotOkStatusException \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 56\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], "source": [ "model_history=model.fit(\n", " x=[X_train_num, X_train_img/255], y=y_train_oh,\n", " validation_data=([X_val_num, X_val_img/255], y_val_oh),\n", " epochs=epochs , \n", " batch_size=8,\n", " #steps_per_epoch = X_train_num.shape[0]//batch_size,\n", " #validation_steps = X_train_num.shape[0]//batch_size,\n", " #callbacks=[early_stopping]\n", ")" ] }, { "cell_type": "code", "execution_count": 92, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dict_keys(['loss', 'accuracy', 'precision', 'recall', 'auc', 'val_loss', 'val_accuracy', 'val_precision', 'val_recall', 'val_auc'])\n" ] } ], "source": [ "print(model_history.history.keys())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "# 6. Results" ] }, { "cell_type": "code", "execution_count": 101, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#print(model_history.history['loss'])\n", "plt.plot(model_history.history['loss'], color = 'red', label = 'loss')\n", "plt.plot(model_history.history['val_loss'], color = 'green', label = 'val loss')\n", "plt.legend(loc = 'upper right')\n", "plt.ylim(0,5)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 99, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(model_history.history['accuracy'], color = 'red', label = 'accuracy')\n", "plt.plot(model_history.history['val_accuracy'], color = 'green', label = 'val accuracy')\n", "plt.legend(loc = 'upper right')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 123, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "18/18 [==============================] - 0s 4ms/step\n", "[[15, 8], [15, 12], [18, 16], [2, 25], [4, 4], [18, 9], [25, 19], [0, 11], [7, 7], [16, 12], [0, 0], [22, 21], [6, 20], [5, 5], [6, 6], [11, 11], [16, 18], [13, 17], [26, 21], [15, 8], [8, 0], [4, 5], [0, 7], [20, 21], [27, 25], [4, 24], [3, 1], [4, 2], [22, 18], [25, 22], [14, 17], [1, 17], [0, 0], [27, 27], [27, 25], [16, 17], [15, 17], [5, 4], [16, 8], [16, 12], [3, 24], [22, 17], [14, 14], [4, 5], [22, 22], [27, 23], [0, 0], [1, 10], [7, 12], [3, 4], [22, 24], [18, 12], [20, 20], [3, 2], [8, 12], [7, 12], [11, 12], [26, 26], [6, 20], [22, 27], [27, 19], [8, 9], [0, 10], [3, 19], [22, 26], [14, 21], [22, 22], [25, 26], [22, 24], [25, 25], [6, 25], [14, 17], [1, 1], [16, 16], [6, 5], [16, 15], [15, 13], [22, 19], [9, 9], [15, 21], [11, 11], [16, 15], [11, 11], [11, 9], [25, 23], [13, 10], [3, 2], [22, 24], [7, 10], [4, 19], [6, 6], [22, 27], [3, 2], [4, 3], [6, 5], [14, 21], [1, 1], [25, 22], [13, 2], [11, 16], [3, 26], [11, 0], [3, 4], [22, 18], [0, 9], [27, 22], [1, 13], [1, 16], [14, 17], [25, 24], [6, 6], [27, 27], [3, 18], [7, 7], [22, 22], [11, 10], [8, 15], [8, 14], [26, 21], [6, 6], [7, 11], [4, 5], [7, 14], [23, 22], [26, 26], [22, 22], [22, 21], [25, 25], [0, 0], [22, 25], [3, 2], [3, 3], [0, 10], [18, 18], [18, 25], [16, 16], [19, 27], [3, 2], [11, 16], [16, 23], [7, 7], [18, 18], [21, 17], [7, 7], [3, 24], [15, 22], [27, 26], [4, 6], [16, 16], [16, 13], [26, 20], [22, 26], [7, 7], [5, 24], [2, 2], [3, 20], [14, 27], [22, 19], [5, 23], [3, 21], [3, 2], [11, 12], [8, 10], [3, 4], [7, 7], [7, 15], [8, 14], [11, 9], [22, 22], [16, 1], [15, 8], [3, 24], [4, 4], [22, 26], [11, 14], [23, 18], [22, 19], [13, 15], [3, 20], [2, 18], [0, 0], [14, 12], [0, 15], [20, 25], [27, 26], [3, 2], [3, 2], [8, 0], [11, 16], [18, 18], [18, 12], [1, 9], [5, 24], [25, 26], [3, 2], [20, 20], [20, 21], [25, 27], [14, 14], [7, 7], [11, 9], [20, 17], [11, 8], [22, 26], [13, 21], [7, 11], [8, 18], [8, 17], [1, 1], [14, 14], [25, 24], [22, 27], [0, 10], [5, 24], [6, 6], [11, 16], [26, 20], [15, 11], [0, 0], [13, 21], [8, 14], [1, 1], [8, 16], [8, 13], [25, 24], [22, 22], [3, 16], [3, 3], [25, 19], [14, 14], [3, 21], [9, 9], [5, 20], [6, 5], [4, 3], [3, 1], [9, 10], [18, 21], [3, 3], [15, 8], [3, 3], [6, 6], [7, 14], [4, 20], [11, 8], [11, 10], [26, 17], [5, 23], [25, 22], [14, 17], [15, 17], [16, 18], [16, 18], [16, 18], [4, 5], [0, 18], [3, 4], [8, 15], [14, 14], [27, 21], [16, 13], [3, 10], [3, 1], [16, 18], [16, 16], [0, 9], [18, 21], [13, 20], [3, 3], [15, 8], [0, 0], [0, 10], [0, 11], [16, 21], [27, 22], [4, 25], [0, 9], [16, 10], [7, 7], [2, 4], [4, 4], [11, 9], [11, 1], [8, 13], [18, 23], [22, 21], [12, 12], [4, 5], [7, 9], [0, 7], [3, 2], [6, 6], [4, 5], [8, 13], [18, 19], [7, 7], [27, 27], [15, 10], [15, 17], [27, 13], [7, 10], [13, 17], [16, 14], [22, 23], [22, 23], [27, 17], [25, 26], [11, 10], [11, 12], [22, 21], [2, 27], [20, 25], [17, 22], [22, 25], [8, 15], [0, 11], [25, 24], [22, 24], [22, 22], [0, 15], [0, 10], [22, 20], [15, 10], [7, 12], [14, 27], [25, 24], [5, 5], [16, 16], [18, 18], [18, 24], [11, 9], [6, 5], [6, 6], [27, 24], [7, 12], [6, 24], [3, 1], [0, 10], [16, 19], [4, 4], [16, 17], [25, 26], [4, 4], [0, 9], [16, 18], [4, 2], [7, 7], [11, 12], [0, 8], [3, 2], [3, 8], [25, 24], [0, 1], [25, 22], [27, 27], [20, 20], [27, 25], [7, 8], [22, 19], [8, 27], [7, 12], [1, 8], [15, 13], [11, 1], [4, 3], [8, 11], [6, 6], [3, 2], [22, 25], [0, 9], [25, 26], [22, 19], [11, 21], [27, 27], [1, 2], [25, 3], [5, 6], [11, 9], [20, 22], [16, 18], [22, 19], [4, 4], [4, 2], [7, 14], [27, 25], [22, 27], [11, 0], [4, 5], [18, 21], [25, 22], [22, 27], [13, 13], [14, 17], [15, 8], [15, 8], [1, 3], [11, 1], [11, 16], [18, 26], [8, 17], [7, 7], [22, 26], [22, 12], [2, 27], [16, 13], [9, 7], [7, 11], [22, 27], [8, 18], [2, 18], [22, 4], [11, 12], [0, 9], [25, 23], [0, 9], [1, 1], [11, 9], [7, 7], [0, 11], [22, 26], [4, 3], [16, 15], [11, 1], [6, 4], [6, 6], [25, 25], [3, 20], [6, 6], [6, 6], [4, 4], [15, 14], [0, 0], [8, 13], [23, 21], [27, 27], [9, 9], [22, 19], [15, 21], [3, 1], [20, 20], [2, 3], [1, 19], [14, 14], [19, 25], [26, 20], [16, 2], [6, 26], [25, 22], [6, 6], [15, 21], [16, 18], [7, 11], [4, 4], [7, 9], [3, 24], [0, 1], [6, 5], [1, 0], [4, 2], [22, 23], [22, 20], [13, 13], [14, 22], [3, 2], [6, 20], [0, 0], [25, 22], [4, 19], [25, 5], [13, 13], [16, 1], [11, 10], [25, 27], [22, 22], [0, 0], [8, 13], [11, 11], [1, 23], [27, 15], [0, 0], [11, 8], [25, 27], [4, 4], [25, 6], [16, 21], [20, 21], [3, 3], [25, 26], [22, 19], [4, 3], [14, 14], [16, 14], [11, 11], [8, 13], [22, 24], [4, 3], [0, 7], [4, 24], [4, 5], [22, 23], [3, 3], [7, 15], [9, 8], [14, 22], [3, 3], [1, 10], [14, 14], [6, 6], [6, 6], [3, 2], [13, 17], [25, 22], [20, 17], [4, 4], [8, 8], [11, 11], [11, 11], [7, 14], [3, 10], [11, 0], [15, 20], [27, 25], [27, 26], [12, 18], [6, 6], [6, 20], [6, 20], [0, 21], [0, 8], [22, 20], [27, 17], [3, 4], [3, 2], [4, 5], [25, 23], [11, 1], [4, 3], [1, 1], [27, 14], [15, 18], [11, 11], [11, 12], [4, 2], [26, 20], [7, 11], [8, 10], [3, 1], [6, 5], [7, 17], [22, 23], [3, 4], [11, 9], [8, 21], [1, 3], [20, 17], [25, 24], [8, 15], [7, 7], [16, 16], [4, 6]]\n" ] } ], "source": [ "prediction = model.predict([X_test_num,X_test_img/255],)\n", "real_values= y_test.values-1\n", "predicted_classes = np.argmax(prediction, axis = 1)\n", "\n", "result = [list(t) for t in zip(predicted_classes, real_values)]\n", "#print(np.round(prediction))\n", "print(result)" ] }, { "cell_type": "code", "execution_count": 125, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 125, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from sklearn.metrics import confusion_matrix\n", "true_classes = real_values\n", "\n", "cm = confusion_matrix(true_classes, predicted_classes)\n", "disp = sklearn.metrics.ConfusionMatrixDisplay(confusion_matrix = cm)\n", "disp.plot()\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 126, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " precision recall f1-score support\n", "\n", " 0 0.28 0.65 0.39 17\n", " 1 0.32 0.29 0.30 21\n", " 2 0.12 0.04 0.06 24\n", " 3 0.16 0.42 0.23 19\n", " 4 0.26 0.50 0.34 20\n", " 5 0.20 0.11 0.14 18\n", " 6 0.52 0.80 0.63 20\n", " 7 0.37 0.76 0.50 17\n", " 8 0.04 0.06 0.04 18\n", " 9 0.50 0.13 0.21 23\n", " 10 0.00 0.00 0.00 23\n", " 11 0.18 0.42 0.25 19\n", " 12 0.50 0.05 0.09 20\n", " 13 0.25 0.19 0.21 16\n", " 14 0.40 0.40 0.40 20\n", " 15 0.00 0.00 0.00 13\n", " 16 0.17 0.40 0.24 15\n", " 17 0.00 0.00 0.00 25\n", " 18 0.25 0.17 0.21 23\n", " 19 0.00 0.00 0.00 17\n", " 20 0.31 0.17 0.22 23\n", " 21 0.00 0.00 0.00 28\n", " 22 0.15 0.33 0.21 24\n", " 23 0.00 0.00 0.00 14\n", " 24 0.00 0.00 0.00 24\n", " 25 0.09 0.17 0.11 18\n", " 26 0.22 0.10 0.14 20\n", " 27 0.24 0.29 0.26 21\n", "\n", " accuracy 0.22 560\n", " macro avg 0.20 0.23 0.19 560\n", "weighted avg 0.20 0.22 0.18 560\n", "\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\Borja\\anaconda3\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n", "C:\\Users\\Borja\\anaconda3\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n", "C:\\Users\\Borja\\anaconda3\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n" ] } ], "source": [ "report = sklearn.metrics.classification_report(true_classes, \n", " predicted_classes)\n", "print(report) " ] }, { "cell_type": "code", "execution_count": 131, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Test accuracy: 0.22142857142857142\n" ] } ], "source": [ "from sklearn.metrics import roc_auc_score,accuracy_score,precision_score, recall_score\n", "\n", "test_accuracy = accuracy_score(true_classes, predicted_classes)\n", "#test_auc = roc_auc_score(true_classes, predicted_classes)\n", "#test_precision = precision_score(true_classes, predicted_classes)\n", "#test_recall = recall_score(true_classes, predicted_classes)\n", "\n", "print(\"Test accuracy:\",test_accuracy)\n", "#print(\"Test AUC:\",test_auc)\n", "#print(\"Test precision:\",test_precision)\n", "#print(\"Test recall:\",test_recall)" ] }, { "cell_type": "code", "execution_count": 129, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train accuracy: 0.9642219543457031\n", "Train AUC: 0.8031144738197327\n", "Train precision: 0.2857142984867096\n", "Train recall: 0.0011904762359336019\n", "Train loss: 2.751965284347534\n" ] } ], "source": [ "train_accuracy = model_history.history[\"accuracy\"][-1]\n", "train_auc = model_history.history[\"auc\"][-1]\n", "train_precision = model_history.history[\"precision\"][-1]\n", "train_recall = model_history.history[\"recall\"][-1]\n", "train_loss = model_history.history[\"loss\"][-1]\n", "\n", "print(\"Train accuracy:\",train_accuracy)\n", "print(\"Train AUC:\",train_auc)\n", "print(\"Train precision:\",train_precision)\n", "print(\"Train recall:\",train_recall)\n", "print(\"Train loss:\",train_loss)" ] }, { "cell_type": "code", "execution_count": 130, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Validation accuracy: 0.9642857313156128\n", "Validation AUC: 0.8785466551780701\n", "Validation precision: 0.0\n", "Validation recall: 0.0\n", "Validation loss: 2.4721860885620117\n" ] } ], "source": [ "validation_accuracy = model_history.history[\"val_accuracy\"][-1]\n", "validation_auc = model_history.history[\"val_auc\"][-1]\n", "validation_precision = model_history.history[\"val_precision\"][-1]\n", "validation_recall = model_history.history[\"val_recall\"][-1]\n", "validation_loss = model_history.history[\"val_loss\"][-1]\n", "\n", "print(\"Validation accuracy:\",validation_accuracy)\n", "print(\"Validation AUC:\",validation_auc)\n", "print(\"Validation precision:\",validation_precision)\n", "print(\"Validation recall:\",validation_recall)\n", "print(\"Validation loss:\",validation_loss)" ] }, { "cell_type": "code", "execution_count": 83, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['TINTO1000', 'TINTO', 1000, '[32, 16, 16]', '[32, 16, 16]', 0.8947368421052632, 0.8788077301015396, 0.8974358974358975, 0.813953488372093, 0.041176450252532956, 0.03854489326477051, 0.908823549747467, 0.9624514579772949, 0.875, 0.8677685856819153, 0.2325555980205536, 0.9473684430122375, 0.9680850505828857, 0.9767441749572754, 0.8936170339584351, 0.20427170395851135]\n" ] } ], "source": [ "import csv\n", "\n", "experiments_csv = \"C:\\\\Users\\\\Borja\\\\EXP_TINTOLIB\\\\Classification\\\\Classification_Cancer.csv\"\n", "model_name = \"TINTO1000\"\n", "preprocess = \"TINTO\"\n", "\n", "FFNN = str(filters_ffnn)\n", "CNN = str(filters_cnn)\n", "BIAS = (1-train_accuracy-0.05)\n", "VARIANCE = (1-train_accuracy)-(1-validation_accuracy)\n", "metrics = [model_name,preprocess,epochs,FFNN,CNN,test_accuracy,test_auc,test_precision,test_recall,BIAS,VARIANCE,\n", " train_accuracy,train_auc,train_precision,train_recall,train_loss,\n", " validation_accuracy,validation_auc,validation_precision,validation_recall,validation_loss]\n", "print(metrics)\n" ] }, { "cell_type": "code", "execution_count": 85, "metadata": {}, "outputs": [], "source": [ "with open(experiments_csv, 'a', newline='') as archivo:\n", " escritor_csv = csv.writer(archivo)\n", " escritor_csv.writerow(metrics)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "colab": { "provenance": [ { "file_id": "1plFq1CpEXIdc9LankaLPiOObRg0_y5l2", "timestamp": 1684250343977 } ] }, "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.9.6" } }, "nbformat": 4, "nbformat_minor": 1 }