{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"markdown","source":"Este notebook tiene como objetivo proporcionar una primera aproximación a la competición de *Cassava Leaf Disease Classification*. En concreto, abordaremos el problema de determinar si una hoja de yuca está enferma y, en caso afirmativo, identificar el tipo de enfermedad. En resumen, ¿qué desafíos enfrentamos?\n\n* Clasificación Multiclase de Imágenes: El problema se centra en la clasificación de imágenes en múltiples clases.\n\n* Cinco Clases en Total: Tenemos un total de cinco clases, cuatro de las cuales corresponden a enfermedades, y una adicional que representa una hoja sana.\n\n* Fiabilidad de las Etiquetas: Es importante destacar que las etiquetas pueden no ser 100% fiables, lo que agrega un elemento de incertidumbre al problema.\n\n* Desbalanceo de Datos: Algunas enfermedades son más frecuentes que otras, lo que resulta en un desequilibrio en la distribución de los datos.\n\n* Calidad de las Imágenes: Las imágenes presentan una calidad baja, ya que han sido capturadas con cámaras económicas.\n\n¿Podría la IA ayudar a los agricultores africanos?","metadata":{}},{"cell_type":"markdown","source":"---","metadata":{}},{"cell_type":"markdown","source":"### Índice\n\n[1. Preparar el entorno de trabajo](#sec1)\n\n[2. Cargar los datos](#sec2)\n\n[3. Exploratory Data Analysis (EDA)](#sec3)\n\n[4. Desarrollo de la solución con Fast.AI](#sec4)\n\n[5. Evaluación del modelo](#sec5)\n\n[6. Inferencia y envío de la solución](#sec6)","metadata":{}},{"cell_type":"markdown","source":"### 1. Preparar el entorno de trabajo ","metadata":{}},{"cell_type":"markdown","source":"#### 1.1 Importar librerías","metadata":{}},{"cell_type":"code","source":"import numpy as np\nimport os\nimport pandas as pd\nimport albumentations\nimport plotly_express as px\nfrom PIL import Image\nfrom timm import create_model\nfrom fastai.vision.all import *\nfrom fastai.vision.learner import _update_first_layer","metadata":{"execution":{"iopub.status.busy":"2023-10-20T15:59:13.246732Z","iopub.execute_input":"2023-10-20T15:59:13.247285Z","iopub.status.idle":"2023-10-20T15:59:20.223107Z","shell.execute_reply.started":"2023-10-20T15:59:13.247258Z","shell.execute_reply":"2023-10-20T15:59:20.222460Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### 1.2 Establecer semilla aleatoria (reproducibilidad)","metadata":{}},{"cell_type":"code","source":"set_seed(12,reproducible=True)","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:00:17.904593Z","iopub.execute_input":"2023-10-20T16:00:17.905299Z","iopub.status.idle":"2023-10-20T16:00:17.913683Z","shell.execute_reply.started":"2023-10-20T16:00:17.905257Z","shell.execute_reply":"2023-10-20T16:00:17.912795Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### 2. Cargar los datos ","metadata":{}},{"cell_type":"markdown","source":"Vamos a ver que hay dentro de la carpeta de datos de esta competición.","metadata":{}},{"cell_type":"code","source":"dataset_path = Path('../input/cassava-leaf-disease-classification')\nprint(f'En este directorio se encuentran los siguientes archivos:')\nprint(os.listdir(dataset_path))","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:01:22.704381Z","iopub.execute_input":"2023-10-20T16:01:22.704718Z","iopub.status.idle":"2023-10-20T16:01:22.710246Z","shell.execute_reply.started":"2023-10-20T16:01:22.704693Z","shell.execute_reply":"2023-10-20T16:01:22.709267Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Vemos que hay dos archivos .CSV, uno con los datos de entrenamiento, *train.csv*, y otro con los de prueba, *sample_submission.csv*. Además, observamos que hay dos directorios, *train_images* y *test_images*, con las imágenes de entrenamiento y prueba, respectivamente. Estas imágenes han sido preprocesadas por los organizadores de la competición para almacenar estos datos en un formato que hace la lectura más eficiente: los Tensorflow Records (*train_tfrecords* y *test_tfrecords*). Por último, encontramos un archivo .JSON que relaciona los códigos de las enfermedades con sus nombres, *label_num_to_disease_map.json*.\n\nCargaremos el archivo .CSV correspondiente al conjunto de datos de entrenamiento y mostraremos su contenido.","metadata":{}},{"cell_type":"code","source":"train_df = pd.read_csv(dataset_path/'train.csv')\ntrain_df.head()","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:02:58.080528Z","iopub.execute_input":"2023-10-20T16:02:58.080872Z","iopub.status.idle":"2023-10-20T16:02:58.126906Z","shell.execute_reply.started":"2023-10-20T16:02:58.080849Z","shell.execute_reply":"2023-10-20T16:02:58.125971Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Observamos que el archivo .CSV tiene dos columnas, una con el ID de la imágen, *image_id*, y otro con el codigo de la clase correspondiente, *label*. A continuación leeremos el diccionario que relaciona los codigos de las clases con sus nombres y crearemos una nueva columna, *label_desc*, con el nombre de clase que corresponde a cada imágen.","metadata":{}},{"cell_type":"code","source":"diseaseMapping = pd.read_json(dataset_path/'label_num_to_disease_map.json', typ='series')\ndiseaseMapping","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:04:02.156048Z","iopub.execute_input":"2023-10-20T16:04:02.156416Z","iopub.status.idle":"2023-10-20T16:04:02.171680Z","shell.execute_reply.started":"2023-10-20T16:04:02.156390Z","shell.execute_reply":"2023-10-20T16:04:02.170778Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df['label_desc'] = train_df.replace(diseaseMapping.to_dict())['label']\ntrain_df.head()","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:04:34.999280Z","iopub.execute_input":"2023-10-20T16:04:34.999589Z","iopub.status.idle":"2023-10-20T16:04:35.019859Z","shell.execute_reply.started":"2023-10-20T16:04:34.999566Z","shell.execute_reply":"2023-10-20T16:04:35.019066Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Además, para acceder de forma fácil a los datos lo que haremos es añadir una nueva columna, *path*, con la ruta a la imágen. ","metadata":{}},{"cell_type":"code","source":"train_df['path'] = train_df['image_id'].map(lambda x:dataset_path/'train_images'/x)\ntrain_df.head()","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:05:17.752502Z","iopub.execute_input":"2023-10-20T16:05:17.753359Z","iopub.status.idle":"2023-10-20T16:05:18.051987Z","shell.execute_reply.started":"2023-10-20T16:05:17.753319Z","shell.execute_reply":"2023-10-20T16:05:18.051143Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"En este punto ya tenemos cargados y preparados los datos, es hora de estudiarlos más a fondo.","metadata":{}},{"cell_type":"markdown","source":"### 3. Exploratory Data Analysis (EDA) ","metadata":{}},{"cell_type":"markdown","source":"Lo primero que vamos a hacer es ver cuantas imágenes hay en el conjunto de datos de entrenamiento que nos dan en la competición.","metadata":{}},{"cell_type":"code","source":"len_df = len(train_df)\nprint(f\"There are {len_df} images\")","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:05:52.679566Z","iopub.execute_input":"2023-10-20T16:05:52.680483Z","iopub.status.idle":"2023-10-20T16:05:52.685468Z","shell.execute_reply.started":"2023-10-20T16:05:52.680444Z","shell.execute_reply":"2023-10-20T16:05:52.684586Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"De las 21.397 imágenes, ¿Cuántas hay cada clase?","metadata":{}},{"cell_type":"code","source":"# Counting the Number of Training Samples for each Label\nlabelCounts = train_df['label_desc'].value_counts().reset_index()\nlabelCounts.columns = ['Label', 'Number of Observations']\n\n# Plotting a Pie Chart to show the Distribution\nfig = px.pie(labelCounts, \n names = 'Label',values='Number of Observations', \n labels = diseaseMapping.to_dict(), \n title = 'Distribution of Labels in the Training Dataset',\n color_discrete_sequence=px.colors.sequential.Blues_r)\nfig.show()","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:06:12.716937Z","iopub.execute_input":"2023-10-20T16:06:12.717250Z","iopub.status.idle":"2023-10-20T16:06:13.970692Z","shell.execute_reply.started":"2023-10-20T16:06:12.717226Z","shell.execute_reply":"2023-10-20T16:06:13.969728Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Como se puede observar, existe un fuerte desequilibrio de datos. La clase mayoritaria, *Cassava Mosaic Disease (CMD)*, está presente en el 61.5% de los ejemplos, mientras que la clase minoritaria, *Cassava Bacterial Blight (CBB)*, solo se encuentra en el 5.08%.\n\nVeamos que pinta tienen los ejemplos de cada clase.","metadata":{}},{"cell_type":"code","source":"for k, g in train_df.groupby('label_desc'): \n f, ax = plt.subplots(3, 3, figsize=(7.5, 7.5))\n ax = ax.ravel()\n for i, (_, r) in enumerate(g.sample(9).iterrows()):\n x = Image.open(r.path)\n ax[i].imshow(x)\n ax[i].axis('off')\n ax[i].set_title(r.image_id)\n f.suptitle(k)\n plt.show()","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:07:02.383901Z","iopub.execute_input":"2023-10-20T16:07:02.384414Z","iopub.status.idle":"2023-10-20T16:07:07.777377Z","shell.execute_reply.started":"2023-10-20T16:07:02.384385Z","shell.execute_reply":"2023-10-20T16:07:07.776484Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"A primera vista, resulta complicado diferenciar entre las 5 clases. Debido a la falta de un criterio común, las imágenes han sido capturadas utilizando diferentes sensores, ángulos y niveles de zoom, lo que dificulta la tarea de reconocimiento. Además, algunos usuarios de Kaggle han analizado la confiabilidad de las etiquetas y han concluido que alrededor del 8% de las imágenes están etiquetadas incorrectamente.\n\nNosotros no somos capaces de hacerlo, pero ¿será capaz la IA de clasificar correctamente estas imágenes?","metadata":{}},{"cell_type":"markdown","source":"### 4. Desarrollo de la solución con Fast.AI ","metadata":{}},{"cell_type":"markdown","source":"[Fast.AI](https://www.fast.ai/) proporciona una API de alto nivel que facilita la construcción de modelos de aprendizaje profundo, lo que permite a los usuarios enfocarse en el diseño de sus redes neuronales y la resolución de problemas en lugar de preocuparse por detalles de bajo nivel. En resumen, simplifica muchas de las tareas comunes en el desarrollo de modelos de IA, lo que facilita que los estudiantes y los desarrolladores implementen modelos de forma más rápida y sencilla.","metadata":{}},{"cell_type":"markdown","source":"Lo primero que haremos será establecer algunas constantes que utilizaremos de aquí en adelante, como la semilla aleatoria (SEED), el porcentaje de ejemplos que usaremos para validar (VALID_PCT), el tamaño del batch (BS) o el tamaño de las imágenes con las que trabajaremos (SZ).","metadata":{}},{"cell_type":"code","source":"SEED = 12\nVALID_PCT = .15\nBS = 12\nSZ = 256","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:14:13.009677Z","iopub.execute_input":"2023-10-20T16:14:13.010003Z","iopub.status.idle":"2023-10-20T16:14:13.014216Z","shell.execute_reply.started":"2023-10-20T16:14:13.009979Z","shell.execute_reply":"2023-10-20T16:14:13.013389Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Para prevenir el sobre-entrenamiento habíamos comentado que existen técnicas de regularización tales como el aumento de datos (Data Agumentation). Fast.AI dispone de un método, get_transforms(), que aplica transformaciones de manera aleatoria (recortar, rotar, voltear, hacer zoom, etc.).","metadata":{}},{"cell_type":"code","source":"# get_transforms()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Sin embargo, para obtener un mayor control de las transformaciones de datos realizadas, es muy común utilizar la librería, [Albumentations](https://albumentations.ai/). Para poder utilizarla junto a Fast.AI hay que realizar algunas modificaciones previas:","metadata":{}},{"cell_type":"code","source":"class AlbumentationsTransform(RandTransform):\n \"A transform handler for multiple `Albumentation` transforms\"\n split_idx,order=None,2\n def __init__(self, train_aug, valid_aug): store_attr()\n \n def before_call(self, b, split_idx):\n self.idx = split_idx\n \n def encodes(self, img: PILImage):\n if self.idx == 0:\n aug_img = self.train_aug(image=np.array(img))['image']\n else:\n aug_img = self.valid_aug(image=np.array(img))['image']\n return PILImage.create(aug_img)","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:15:32.465443Z","iopub.execute_input":"2023-10-20T16:15:32.465773Z","iopub.status.idle":"2023-10-20T16:15:32.472411Z","shell.execute_reply.started":"2023-10-20T16:15:32.465747Z","shell.execute_reply":"2023-10-20T16:15:32.471439Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"A continuación, definiremos las funciones *get_train_aug()* y *get_valid_aug()* que combinarán varias aumentaciones de datos para los conjuntos de entrenamiento y validación, respectivamente. \n\nEn el caso del conjunto de entrenamiento lo que haremos es cortar aleatoriamente un trozo de la imagen de tamaño SZ x SZ, rotarlo vertical y/o horizontalmente, modificar su escala, alterar el brillo, contraste, saturación, etc. entre otros.\n\nEn el caso del conjunto de validación cabe destacar que no interesa aumentarlo, puesto que de lo contrario, en cada época, validaríamos con datos distintos. Por lo tanto, lo unico que haremos será redimensionar la imágen al tamaño con el que trabajaremos SZ x SZ. ","metadata":{}},{"cell_type":"code","source":"def get_train_aug(sz): return albumentations.Compose([\n albumentations.RandomResizedCrop(sz,sz),\n albumentations.Transpose(p=0.5),\n albumentations.HorizontalFlip(p=0.5),\n albumentations.VerticalFlip(p=0.5),\n albumentations.ShiftScaleRotate(p=0.5),\n albumentations.HueSaturationValue(\n hue_shift_limit=0.2, \n sat_shift_limit=0.2, \n val_shift_limit=0.2, \n p=0.5\n ),\n albumentations.RandomBrightnessContrast(\n brightness_limit=(-0.1,0.1), \n contrast_limit=(-0.1, 0.1), \n p=0.5\n ),\n albumentations.CoarseDropout(p=0.5),\n albumentations.Cutout(p=0.5)\n])\n\ndef get_valid_aug(sz): return albumentations.Compose([\n albumentations.CenterCrop(sz,sz, p=1.),\n albumentations.Resize(sz,sz)\n], p=1.)","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:20:36.393233Z","iopub.execute_input":"2023-10-20T16:20:36.393550Z","iopub.status.idle":"2023-10-20T16:20:36.399913Z","shell.execute_reply.started":"2023-10-20T16:20:36.393526Z","shell.execute_reply":"2023-10-20T16:20:36.398842Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Las transformaciones de datos se pueden aplicar a los ejemplos por separado o a los batches. Dependiendo de cual nos interese, en Fast.AI, utilizaremos *item_tfms* o *batch_tfms*. En nuestro caso, nos interesa que cada ejemplo se aumente de manera diferente, por lo tanto las aumentaciones definidas anteriormente serán a nivel de ejemplo, item_tfms. \n\nCuando utilicemos modelos pre-entrenados es necesario pre-procesar los datos de tal manera que su formato sea similar al de los datos utilizados en el pre-entrenamiento. Generalmente, los modelos son entrenados en Imagenet, una base de datos de imagenes naturales (perros, gatos, coches, etc.). Por ello, librerías como Fast.AI proveen al usuario de dichas estadisticas, *imagenet_stats*.","metadata":{}},{"cell_type":"code","source":"item_tfms = AlbumentationsTransform(get_train_aug(SZ), get_valid_aug(SZ))\nbatch_tfms = [Normalize.from_stats(*imagenet_stats)]","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:24:10.433661Z","iopub.execute_input":"2023-10-20T16:24:10.434541Z","iopub.status.idle":"2023-10-20T16:24:13.567620Z","shell.execute_reply.started":"2023-10-20T16:24:10.434500Z","shell.execute_reply":"2023-10-20T16:24:13.566715Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Con todo listo, ya podemos definir nuestros contenedores de datos de Fast.AI, los *DataLoaders*. Específicamente, como estamos trabajando con imágenes, los *ImageDataLoaders*. Utilizando la función *from_df()*, podemos tomar un conjunto de datos (*df*) y realizar una división en un conjunto de entrenamiento y validación, en base al porcentaje especificado (*valid_pct*). Dado que esta división se realiza de manera aleatoria, es necesario indicar una semilla aleatoria (seed) para asegurar la reproducibilidad. Además, debemos indicar cuáles de las columnas del conjunto de datos que le hemos pasado hacen referencia a la ruta de la imagen (*fn_col*) y cuál a la etiqueta de la clase (*label_col*). Finalmente, tendremos que indicar el tamaño del lote (*bs*) que deseamos que nos devuelva cuando cargue los datos y qué transformaciones debe aplicar, tanto a nivel de ejemplo (*item_tfms*) como a nivel de lote (*batch_tfms*).","metadata":{}},{"cell_type":"code","source":"dls = ImageDataLoaders.from_df(\n df=train_df, \n valid_pct=VALID_PCT, \n seed=SEED, \n label_col=1, \n fn_col=3, \n bs=BS, \n item_tfms=item_tfms,\n batch_tfms=batch_tfms\n)","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:25:58.986875Z","iopub.execute_input":"2023-10-20T16:25:58.988162Z","iopub.status.idle":"2023-10-20T16:26:00.092915Z","shell.execute_reply.started":"2023-10-20T16:25:58.988130Z","shell.execute_reply":"2023-10-20T16:26:00.092189Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dls.show_batch()","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:26:13.288840Z","iopub.execute_input":"2023-10-20T16:26:13.289590Z","iopub.status.idle":"2023-10-20T16:26:14.402005Z","shell.execute_reply.started":"2023-10-20T16:26:13.289551Z","shell.execute_reply":"2023-10-20T16:26:14.401128Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Ya tenemos los DataLoaders necesarios para entrenar nuestro modelo. Como modelo utilizaremos una red neuronal pre-entrenada llamada ResNet-34 para clasificar las imágenes de las hojas de yuca. Esta red ha demostrado ser muy efectiva en una variedad de tareas de visión por computadora. En Fast.AI esto se puede hacer en dos líneas de código:","metadata":{}},{"cell_type":"code","source":"# learn = vision_learner(dls, resnet34, metrics=error_rate)\n# learn.fine_tune(10)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Sin embargo, dado que en esta competición no disponemos de acceso a internet, se complica su uso. Por ello haremos uso de la librería [Pytorch Image Models (Timm)](https://github.com/huggingface/pytorch-image-models). Para utilizar los modelos de Timm en Fast.AI es necesario realizar algunas modificaciones previas:","metadata":{}},{"cell_type":"code","source":"def create_timm_body(arch:str, pretrained=True, pretrained_cfg_overlay=None, cut=None, n_in=3):\n \"Creates a body from any model in the `timm` library.\"\n model = create_model(arch, pretrained=pretrained, pretrained_cfg_overlay=pretrained_cfg_overlay, num_classes=0, global_pool='')\n _update_first_layer(model, n_in, pretrained)\n if cut is None:\n ll = list(enumerate(model.children()))\n cut = next(i for i,o in reversed(ll) if has_pool_type(o))\n if isinstance(cut, int): return nn.Sequential(*list(model.children())[:cut])\n elif callable(cut): return cut(model)\n else: raise NamedError(\"cut must be either integer or function\")\n \ndef create_timm_model(arch:str, n_out, cut=None, pretrained=True, pretrained_cfg_overlay=None, n_in=3, init=nn.init.kaiming_normal_, custom_head=None,\n concat_pool=False, **kwargs):\n \"Create custom architecture using `arch`, `n_in` and `n_out` from the `timm` library\"\n body = create_timm_body(arch, pretrained, pretrained_cfg_overlay, None, n_in)\n if custom_head is None:\n nf = num_features_model(nn.Sequential(*body.children())) * (2 if concat_pool else 1)\n head = create_head(nf, n_out, concat_pool=concat_pool, **kwargs)\n else: head = custom_head\n model = nn.Sequential(body, head)\n if init is not None: apply_init(model[1], init)\n return model\n\ndef timm_learner(dls, arch:str, loss_func=None, pretrained=True, pretrained_cfg_overlay=None, cut=None, splitter=None,\n y_range=None, config=None, n_out=None, normalize=True, **kwargs):\n \"Build a convnet style learner from `dls` and `arch` using the `timm` library\"\n if config is None: config = {}\n if n_out is None: n_out = get_c(dls)\n assert n_out, \"`n_out` is not defined, and could not be inferred from data, set `dls.c` or pass `n_out`\"\n if y_range is None and 'y_range' in config: y_range = config.pop('y_range')\n model = create_timm_model(arch, n_out, default_split, pretrained, pretrained_cfg_overlay, y_range=y_range, **config)\n learn = Learner(dls, model, loss_func=loss_func, splitter=default_split, **kwargs)\n if pretrained: learn.freeze()\n return learn","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:30:40.827805Z","iopub.execute_input":"2023-10-20T16:30:40.828842Z","iopub.status.idle":"2023-10-20T16:30:40.839225Z","shell.execute_reply.started":"2023-10-20T16:30:40.828810Z","shell.execute_reply":"2023-10-20T16:30:40.838174Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"En Kaggle, dependiendo de la competición, se permite o no el acceso a internet. Dado que en esta competición el acceso a internet se encuentra restringido, es necesario descargar el modelo pre-entrenado previamente y subirlo como un conjunto de datos adicional. Para saber que modelo hay que descargar hay que consultar el *hf_hub_id* del modelo y consultarlo en: https://huggingface.co/hf_fub_id.","metadata":{}},{"cell_type":"code","source":"# import timm; 'https://huggingface.co/' + timm.create_model('resnet34').default_cfg['hf_hub_id']\n# > 'https://huggingface.co/timm/resnet34.a1_in1k'","metadata":{"execution":{"iopub.status.busy":"2023-10-10T18:36:08.446721Z","iopub.execute_input":"2023-10-10T18:36:08.447334Z","iopub.status.idle":"2023-10-10T18:36:08.463068Z","shell.execute_reply.started":"2023-10-10T18:36:08.447300Z","shell.execute_reply":"2023-10-10T18:36:08.461951Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Utilizaremos las funciones definidas anteriormente para instanciar un objeto de tipo *Learner* de la librería Fast.AI con la arquitectura ResNet-34, pre-entrenada con los pesos del modelo que nos hemos descargado. Para crear el Learner será necesario indicar los DataLoaders (*dls*), la arquitectura a utilizar (*arch*), el optimizador (*opt_func*), la función de coste (*loss_func*), las métricas (*metrics*), si el modelo está o no pre-entrenado (*pretrained*), y en caso afirmativo, la ubicación donde está guardado (*pretrained_cfg_overlay*). Por facilidad, en este taller hemos creado un dataset de Kaggle con los pesos del modelo pre-entrenado de Timm: *models-timm-resnet34-a1-in1k*.","metadata":{}},{"cell_type":"code","source":"learn = timm_learner(\n dls=dls, \n arch='resnet34',\n opt_func=Adam,\n loss_func=LabelSmoothingCrossEntropy(),\n metrics = [accuracy],\n pretrained=True,\n pretrained_cfg_overlay=dict(file='/kaggle/input/models-timm-resnet34-a1-in1k/model.safetensors')\n).to_fp16()","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:36:17.947833Z","iopub.execute_input":"2023-10-20T16:36:17.948167Z","iopub.status.idle":"2023-10-20T16:36:19.119838Z","shell.execute_reply.started":"2023-10-20T16:36:17.948145Z","shell.execute_reply":"2023-10-20T16:36:19.118792Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Lo primero que haremos será buscar el factor de aprendizaje óptimo, utilizando la función *lr_find()* de Fast.AI.","metadata":{}},{"cell_type":"code","source":"learn.lr_find()","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:37:12.901246Z","iopub.execute_input":"2023-10-20T16:37:12.902148Z","iopub.status.idle":"2023-10-20T16:37:25.986182Z","shell.execute_reply.started":"2023-10-20T16:37:12.902110Z","shell.execute_reply":"2023-10-20T16:37:25.985121Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Analizando la figura podemos considerar que 1e-3 es un buen factor de aprendizaje. Para más información sobre como determinar cuál es un buen factor de aprendizaje en base a la gráfica anterior podeís consultar el siguiente enlace: https://walkwithfastai.com/lr_finder.\n\nEl modelo está pre-entrenado, lo último que queremos es perder todo el conocimiento que ya tiene. Por lo tanto, lo haremos será congelar la parte pre-entrenada (se hace automaticamente al crear el Learner) y entrenar la última capa del modelo, la cabeza de clasificación, durante una época. Para ello llamaremos a la función *fit_flat_cos()*.","metadata":{}},{"cell_type":"code","source":"learn.fit_flat_cos(1, 1e-3)","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:38:45.954200Z","iopub.execute_input":"2023-10-20T16:38:45.954933Z","iopub.status.idle":"2023-10-20T16:40:20.729513Z","shell.execute_reply.started":"2023-10-20T16:38:45.954904Z","shell.execute_reply":"2023-10-20T16:40:20.728540Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Tras este primer entrenamiento estamos obteniendo una precisión del 71%. Podemos mostrar como ha evolucionado el loss durante está primera época utilizando la función *plot_loss()*.","metadata":{}},{"cell_type":"code","source":"learn.recorder.plot_loss()","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:41:19.164552Z","iopub.execute_input":"2023-10-20T16:41:19.165622Z","iopub.status.idle":"2023-10-20T16:41:19.480201Z","shell.execute_reply.started":"2023-10-20T16:41:19.165578Z","shell.execute_reply":"2023-10-20T16:41:19.479341Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**¡Atención! Dado que el tiempo de este taller es limitado, las siguientes celdas de codigo se encuentran comentadas.** El Fine-Tunning del modelo, es decir, el entrenamiento del modelo completo descongelado durá 1h aproximadamente. Para ejecutarlo simplemente hay que descongelar las siguientes celdas. Por simplicidad, en este curso hemos creado un dataset de Kaggle con el modelo entrenado durante 1h: *models-timm-resnet34-a1-in1k-cassava-ft-10ep*. Este conocimiento puede ser cargado como veremos más adelante para obtener un mejor resultado en la competición.","metadata":{}},{"cell_type":"markdown","source":"Ahora ya podemos descongelar todo el modelo con *unfreeze()*, y entrenarlo completamente. Para ello buscaremos nuevamente el ratio de aprendizaje óptimo.","metadata":{}},{"cell_type":"code","source":"# learn.unfreeze()\n# learn.lr_find()","metadata":{"execution":{"iopub.status.busy":"2023-10-10T18:44:39.821569Z","iopub.execute_input":"2023-10-10T18:44:39.821992Z","iopub.status.idle":"2023-10-10T18:44:55.466238Z","shell.execute_reply.started":"2023-10-10T18:44:39.821958Z","shell.execute_reply":"2023-10-10T18:44:55.465133Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Vemos que la gráfica tiene un aspecto muy diferente al que tenía antes. Aunque un ratio de aprendizaje bajo entre 1e-5 y 1e-4 parece la opción sugerida por Fast.AI, nosotros nos quedaremos con 1e-3. Ahora entrenaremos el modelo durante un periodo de tiempo más largo, por ejemplo 10 épocas. Además, le diremos a Fast.AI que nos guarda el mejor modelo dependiendo del loss en validación, utilizando el callback *SaveModelCallback()*.","metadata":{}},{"cell_type":"code","source":"# learn.fit_flat_cos(10, 1e-3 ,cbs=[SaveModelCallback()])","metadata":{"execution":{"iopub.status.busy":"2023-10-10T18:45:03.868151Z","iopub.execute_input":"2023-10-10T18:45:03.868718Z","iopub.status.idle":"2023-10-10T19:23:26.305117Z","shell.execute_reply.started":"2023-10-10T18:45:03.868674Z","shell.execute_reply":"2023-10-10T19:23:26.304000Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Vemos que nuestro modelo no para de mejorar, podríamos haberlo dejado más tiempo, pero 10 épocas está bien para empezar. El modelo se ha guardado en la ruta '/kaggle/working/models/model'. Vamos a mostrar de nuevo como ha ido evolucionando el loss en entrenamiento y validación durante el entrenamiento del modelo.","metadata":{}},{"cell_type":"code","source":"# learn.recorder.plot_loss()","metadata":{"execution":{"iopub.status.busy":"2023-10-10T19:24:59.618866Z","iopub.execute_input":"2023-10-10T19:24:59.619316Z","iopub.status.idle":"2023-10-10T19:25:00.174613Z","shell.execute_reply.started":"2023-10-10T19:24:59.619275Z","shell.execute_reply":"2023-10-10T19:25:00.173642Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"La gráfica tiene buen aspecto, puesto que a la vez que mejorabamos en el conjunto de entrenamiento mejorabamos en el de validación, sin incurrir en sobre-entrenamientos o infra-entrenamientos.","metadata":{}},{"cell_type":"markdown","source":"### 5. Evaluación del modelo ","metadata":{"execution":{"iopub.status.busy":"2023-10-09T18:53:32.620550Z","iopub.execute_input":"2023-10-09T18:53:32.620897Z","iopub.status.idle":"2023-10-09T18:53:32.625730Z","shell.execute_reply.started":"2023-10-09T18:53:32.620869Z","shell.execute_reply":"2023-10-09T18:53:32.624784Z"}}},{"cell_type":"markdown","source":"Ha llegado la hora de validar como de bueno o malo es nuestro modelo.","metadata":{}},{"cell_type":"markdown","source":"**Descomentar cuando se diga en el curso** Ahora vamos a cargar el modelo que ha sido entrenado durante 1h. Para ello utilizaremos la función *load()* e indicaremos la ruta en la que se ha almacenado.","metadata":{}},{"cell_type":"code","source":"learn.load('/kaggle/input/models-timm-resnet34-a1-in1k-cassava-ft-10ep/model')\n# learn.load('/kaggle/input/models-timm-resnet34-a1-in1k-cassava-ft-10ep/model')","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:44:31.118099Z","iopub.execute_input":"2023-10-20T16:44:31.118440Z","iopub.status.idle":"2023-10-20T16:44:31.874838Z","shell.execute_reply.started":"2023-10-20T16:44:31.118416Z","shell.execute_reply":"2023-10-20T16:44:31.873518Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Fast.AI dispone de una clase *ClassificationInterpretation*, para explorar las predicciones de modelos entrenados (el Learner). La utilizaremos para evaluar cuantitativamente el rendimiento de nuestro modelo utilizando la función *print_classification_report()*. ","metadata":{}},{"cell_type":"code","source":"interp = ClassificationInterpretation.from_learner(learn)\ninterp.print_classification_report()","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:44:58.073180Z","iopub.execute_input":"2023-10-20T16:44:58.073513Z","iopub.status.idle":"2023-10-20T16:45:20.910460Z","shell.execute_reply.started":"2023-10-20T16:44:58.073486Z","shell.execute_reply":"2023-10-20T16:45:20.909407Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"La precisión mide la proporción de predicciones positivas correctas con respecto a todas las predicciones positivas. \n\nEl Recall (también conocido como Sensibilidad o True Positive Rate) mide la proporción de ejemplos positivos que se predicen correctamente. \n\nEl F1-Score: El F1-score es una medida que combina precisión y recall en una sola métrica. Es útil cuando las clases están desequilibradas.\n\nEl soporte es el número de muestras reales en cada clase.\n\nEl Accuracy representa la precisión global del modelo en todo el conjunto de datos. \n\nEl Macro Avg representa las métricas promedio (precisión, recall y F1-score) calculadas tomando un promedio simple sobre todas las clases. En este caso, el promedio macro de F1-score es del 72%.\n\nEl Weighted Avg representa las métricas promedio ponderadas, donde cada clase contribuye con un peso igual al número de muestras reales en esa clase. El promedio ponderado de F1-score es del 84%.\n\nEn resumen, este modelo de clasificación tiene un buen rendimiento en la mayoría de las clases, con F1-scores sólidos y una precisión global del 84%. Sin embargo, la clase 0 tiene una precisión y un recall más bajos en comparación con las otras clases. Esto puede ser debido a que es la clase con menos ejemplos (5% del total) y la que peor etiquetada está (20% de ejemplos mal etiquetados).","metadata":{}},{"cell_type":"markdown","source":"El rendimiento del modelo también puede analizarse cuantitativamente a partir de la matriz de confusión. La matriz de confusión permite visualizar y resumir la calidad de las predicciones realizadas por el modelo en un conjunto de datos. Es especialmente útil cuando se trata de problemas de clasificación binaria o de múltiples clases. A partir de la matriz de confusión, se pueden calcular diversas métricas de evaluación, y ayuda a entender cómo el modelo está clasificando las muestras reales. Para generar la matriz de confusión podemos llamar a la función *plot_confusion_matrix()*.","metadata":{}},{"cell_type":"code","source":"interp.plot_confusion_matrix(figsize=(4, 4), dpi=100)","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:47:16.693946Z","iopub.execute_input":"2023-10-20T16:47:16.694813Z","iopub.status.idle":"2023-10-20T16:47:28.369003Z","shell.execute_reply.started":"2023-10-20T16:47:16.694771Z","shell.execute_reply":"2023-10-20T16:47:28.367634Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Analizando la matriz de confusión podemos observar, por ejemplo, que muchos de los ejemplos de la clase 0 son confundidos con la clase 4.","metadata":{}},{"cell_type":"markdown","source":"Utilizando el ClassificationInterpretation también podemos analizar el rendimiento de nuestro modelo cualitativamente. Por ejemplo, podemos mostrar aquellos ejemplos en los que mejor funciona, ordenandolos de manera ascendente en función del loss obtenido. Para ello utilizaremos la funcion *plot_top_losses()*.","metadata":{}},{"cell_type":"code","source":"interp.plot_top_losses(6, figsize=(6, 6), largest=False)","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:48:41.275594Z","iopub.execute_input":"2023-10-20T16:48:41.275966Z","iopub.status.idle":"2023-10-20T16:48:42.389772Z","shell.execute_reply.started":"2023-10-20T16:48:41.275939Z","shell.execute_reply":"2023-10-20T16:48:42.388641Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Utilizando está misma función, también podemos mostrar aquellos ejemplos en los que peor funciona, ordenandolos de manera descendente en función del loss obtenido.","metadata":{}},{"cell_type":"code","source":"interp.plot_top_losses(6, figsize=(6, 6))","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:49:20.946966Z","iopub.execute_input":"2023-10-20T16:49:20.947805Z","iopub.status.idle":"2023-10-20T16:49:22.108909Z","shell.execute_reply.started":"2023-10-20T16:49:20.947765Z","shell.execute_reply":"2023-10-20T16:49:22.107828Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Y también podemos pedirle que aleatoriamente seleccione ejemplos y nos muestre el valor predicho y la etiqueta de la clase a la que realmente pertenece. Para ello utilizaremos la función *show_results()*.","metadata":{}},{"cell_type":"code","source":"interp.show_results(torch.randint(3209, [9]), figsize=(9, 9))","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:50:56.719299Z","iopub.execute_input":"2023-10-20T16:50:56.720266Z","iopub.status.idle":"2023-10-20T16:50:58.072540Z","shell.execute_reply.started":"2023-10-20T16:50:56.720225Z","shell.execute_reply":"2023-10-20T16:50:58.071476Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### 6. Inferencia y envío de la solución ","metadata":{}},{"cell_type":"markdown","source":"Finalmente, vamos a tomar nuestro mejor modelo, predecir el conjunto de test sobre el cual se evalua esta competición y ver en que posición del ranking nos quedamos. \n\nPara ello, lo primero es leer los datos de test, que se encuentran en el archivo .CSV, *sample_submission.csv*.","metadata":{}},{"cell_type":"code","source":"sample_df = pd.read_csv(f'{dataset_path}/sample_submission.csv')\nsample_df","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:51:56.807835Z","iopub.execute_input":"2023-10-20T16:51:56.808637Z","iopub.status.idle":"2023-10-20T16:51:56.828232Z","shell.execute_reply.started":"2023-10-20T16:51:56.808608Z","shell.execute_reply":"2023-10-20T16:51:56.827492Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"De igual manera que haciamos con los datos de entrenamiento al principio de este notebook, crearemos una columna, path, con la ruta completa a cada una de las imágenes de test.","metadata":{}},{"cell_type":"code","source":"_sample_df = sample_df.copy()\n_sample_df['path'] = _sample_df['image_id'].map(lambda x:dataset_path/'test_images'/x)\n_sample_df = _sample_df.drop(columns=['image_id'])\n_sample_df","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:53:27.462126Z","iopub.execute_input":"2023-10-20T16:53:27.462424Z","iopub.status.idle":"2023-10-20T16:53:27.472638Z","shell.execute_reply.started":"2023-10-20T16:53:27.462401Z","shell.execute_reply":"2023-10-20T16:53:27.471701Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"A continuación crearemos el dataloader de test. Esta vez del valid_pct será 0, ya que no nos interesa dividir estos datos. Salvo los indices de las columnas con la ruta de las imagenes y las etiquetas de las clases, todo será igual.","metadata":{}},{"cell_type":"code","source":"test_dl = ImageDataLoaders.from_df(\n _sample_df, \n valid_pct=0., \n seed=SEED, \n label_col=0, \n fn_col=1,\n bs=1,\n item_tfms=item_tfms,\n batch_tfms=batch_tfms\n) ","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:54:28.419149Z","iopub.execute_input":"2023-10-20T16:54:28.419615Z","iopub.status.idle":"2023-10-20T16:54:28.457365Z","shell.execute_reply.started":"2023-10-20T16:54:28.419584Z","shell.execute_reply":"2023-10-20T16:54:28.456695Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Mostraremos un ejemplo a ver que pinta tiene.","metadata":{}},{"cell_type":"code","source":"test_dl.show_batch()","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:54:38.651444Z","iopub.execute_input":"2023-10-20T16:54:38.651798Z","iopub.status.idle":"2023-10-20T16:54:38.849123Z","shell.execute_reply.started":"2023-10-20T16:54:38.651772Z","shell.execute_reply":"2023-10-20T16:54:38.848298Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Finalmente, predeciremos todas las imagenes del conjunto de test. Para ello utilizaremos la función *tta()* de nuestro Learner. TTA viene de Test Time Augmentation, una técncia que lo que hace es predecir varias versiones de un mismo ejemplo y agregar los resultados, para dar una predicción mas precisa.","metadata":{}},{"cell_type":"code","source":"preds, _ = learn.tta(dl=test_dl, n=15, beta=0)","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:56:26.004952Z","iopub.execute_input":"2023-10-20T16:56:26.005934Z","iopub.status.idle":"2023-10-20T16:56:30.490989Z","shell.execute_reply.started":"2023-10-20T16:56:26.005887Z","shell.execute_reply":"2023-10-20T16:56:30.489692Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"preds","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:56:55.809090Z","iopub.execute_input":"2023-10-20T16:56:55.809439Z","iopub.status.idle":"2023-10-20T16:56:55.821497Z","shell.execute_reply.started":"2023-10-20T16:56:55.809409Z","shell.execute_reply":"2023-10-20T16:56:55.820627Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Guardaremos las predicciones, *preds*, en la columna *label* de nuestra solución y lo guardaremos como un archivo .CSV. Este archivo debe de llamarse *submission.csv* para que Kaggle automatice la evaluación de la solución enviada.","metadata":{}},{"cell_type":"code","source":"sample_df['label'] = preds.argmax(dim=-1).numpy()\nsample_df.to_csv('submission.csv',index=False)","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:57:40.573219Z","iopub.execute_input":"2023-10-20T16:57:40.573566Z","iopub.status.idle":"2023-10-20T16:57:40.583058Z","shell.execute_reply.started":"2023-10-20T16:57:40.573539Z","shell.execute_reply":"2023-10-20T16:57:40.582206Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"sample_df","metadata":{"execution":{"iopub.status.busy":"2023-10-20T16:57:47.873284Z","iopub.execute_input":"2023-10-20T16:57:47.874118Z","iopub.status.idle":"2023-10-20T16:57:47.882465Z","shell.execute_reply.started":"2023-10-20T16:57:47.874088Z","shell.execute_reply":"2023-10-20T16:57:47.881329Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Con todo esto habremos obtenido un resultado de 0.1341 (ranking 3837) entrenando 1 época y de 0.4351 (ranking 3728) entrenando 10 épocas.**","metadata":{}}]}