{"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":"code","source":"# Importar el módulo de matemáticas para realizar operaciones matemáticas\nimport math\n# Importar el módulo os para interactuar con el sistema operativo\nimport os\n# Importar la función glob para encontrar todos los nombres de ruta que coincidan con un patrón especificado\nfrom glob import glob\n# Importar el módulo random para generar números aleatorios\nimport random\n# Importar la biblioteca OpenCV para trabajar con imágenes y videos\nimport cv2\n# Importar la biblioteca NumPy para trabajar con matrices y operaciones matemáticas de alto nivel\nimport numpy as np\n# Importar la biblioteca pandas para trabajar con datos estructurados\nimport pandas as pd\n# Importar la biblioteca TensorFlow para construir y entrenar modelos de aprendizaje automático\nimport tensorflow as tf\n# Importar la biblioteca TensorFlow Hub para reutilizar modelos previamente entrenados\nimport tensorflow_hub as tfhub\n# Importar la clase KaggleDatasets para trabajar con conjuntos de datos de Kaggle\nfrom kaggle_datasets import KaggleDatasets\n# Importar la clase DataFrameIterator para iterar sobre un DataFrame de pandas y generar lotes de datos de imagen aumentados en tiempo real\nfrom keras_preprocessing.image.dataframe_iterator import DataFrameIterator\n# Importar la clase Model del módulo tensorflow.keras para construir modelos de aprendizaje automático\nfrom tensorflow.keras import Model\n# Importar la clase EfficientNetB3 del módulo tensorflow.keras.applications para utilizar una red neuronal previamente entrenada como base para un nuevo modelo\nfrom tensorflow.keras.applications import EfficientNetB3\n# Importar varias clases de devolución de llamada del módulo tensorflow.keras.callbacks para detener el entrenamiento temprano, ajustar la tasa de aprendizaje, guardar el mejor modelo y reducir la tasa de aprendizaje en una meseta\nfrom tensorflow.keras.callbacks import EarlyStopping, LearningRateScheduler, ModelCheckpoint, ReduceLROnPlateau\n# Importar varias capas del módulo tensorflow.keras.layers para construir modelos de aprendizaje automático, incluyendo capas de normalización por lotes, convolución 2D, densas, abandono, aplanamiento, agrupación global promedio 2D, capa de entrada y agrupación máxima 2D.\nfrom tensorflow.keras.layers import BatchNormalization, Conv2D, Dense, Dropout, Flatten, GlobalAveragePooling2D, InputLayer, MaxPooling2D\n# Importar varias métricas del módulo tensorflow.keras.metrics para evaluar modelos de aprendizaje automático, incluyendo AUC (área bajo la curva), Recall (sensibilidad) y Precision (precisión)\nfrom tensorflow.keras.metrics import AUC, Recall, Precision\n# Importar la clase RMSprop del módulo tensorflow.keras.optimizers para utilizar el optimizador RMSprop en el entrenamiento del modelo.\nfrom tensorflow.keras.optimizers import RMSprop\n# Importar la clase ImageDataGenerator del módulo tensorflow.keras.preprocessing.image para generar lotes de datos de imagen aumentados en tiempo real.\nfrom tensorflow.keras.preprocessing.image import ImageDataGenerator\n# Importar las funciones f1_score y matthews_corrcoef del módulo sklearn.metrics para calcular métricas adicionales al evaluar modelos de aprendizaje automático.\nfrom sklearn.metrics import f1_score, matthews_corrcoef, brier_score_loss\n# Importa pydicom para leer archivos DICOM (imágenes médicas)\nimport pydicom\n#Importa matplotlib.pyplot para visualizar gráficos e imágenes \nimport matplotlib.pyplot as plt\n##nuevos sin comentar\nimport sklearn\nfrom tensorflow.keras.layers import GlobalAveragePooling2D\nfrom IPython.display import display\nimport tensorflow as tf\nfrom tensorflow.keras.callbacks import ModelCheckpoint, ReduceLROnPlateau\nfrom tensorflow.keras.layers import GlobalAveragePooling2D, BatchNormalization, Dense, Dropout\nfrom tensorflow.keras.models import Model\n#from efficientnet.tfkeras import EfficientNetB3\nfrom tensorflow.keras.utils import plot_model\nimport cupy as cp\nimport matplotlib.pyplot as plt\nfrom tensorflow.keras.optimizers import Adam\n\n\n\n# Confirmar si tenemos activa la GPU. Si hay una GPU disponible se imprime un mensaje indicando que está disponible; si no se encontró una GPU se imprime un mensaje indicando que no se encontró una GPU.\nif tf.test.gpu_device_name():\n    print('GPU disponible')\nelse:\n    print('No se encontró GPU')\n    \nall_test_preds = []","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2023-06-20T21:29:37.585521Z","iopub.execute_input":"2023-06-20T21:29:37.585953Z","iopub.status.idle":"2023-06-20T21:29:48.871753Z","shell.execute_reply.started":"2023-06-20T21:29:37.585843Z","shell.execute_reply":"2023-06-20T21:29:48.870851Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Establecer la ruta de la base de datos\nbase_datos = '/kaggle/input/rsna-miccai-brain-tumor-radiogenomic-classification/'\n# Listar los archivos y directorios en la ruta de la base de datos\nos.listdir(base_datos)\n# Establecer las rutas para los conjuntos de datos de entrenamiento y prueba\ntrain = base_datos+'train'\ntest  = base_datos+'test'\n# Leer los archivos CSV para los conjuntos de datos de entrenamiento y prueba utilizando la biblioteca pandas\ntrain_csv = pd.read_csv(base_datos+'train_labels.csv')\ntest_csv  = pd.read_csv(base_datos+'sample_submission.csv')\n# Imprimir las primeras 10 filas de los DataFrames de entrenamiento y prueba\nprint('\\033[1;32;48;5;82m' + '\\033[1m' + '--------------TRAIN--------------' + '\\033[0m')\ndisplay(train_csv)\nprint('\\033[1;32;48;5;82m' + '\\033[1m' + '--------------TEST--------------' + '\\033[0m')\ndisplay(test_csv)","metadata":{"execution":{"iopub.status.busy":"2023-06-20T21:29:48.873380Z","iopub.execute_input":"2023-06-20T21:29:48.874036Z","iopub.status.idle":"2023-06-20T21:29:48.933397Z","shell.execute_reply.started":"2023-06-20T21:29:48.873994Z","shell.execute_reply":"2023-06-20T21:29:48.932565Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Obtener el número de valores faltantes por columna en el DataFrame de entrenamiento utilizando el método isnull() y sum()\nvalores_faltantes_train = train_csv.isnull().sum()\n# Imprimir el número de valores faltantes en las primeras dos columnas del DataFrame de entrenamiento\nvalores_faltantes_train[0:2]","metadata":{"execution":{"iopub.status.busy":"2023-06-20T21:29:48.935319Z","iopub.execute_input":"2023-06-20T21:29:48.935924Z","iopub.status.idle":"2023-06-20T21:29:48.944237Z","shell.execute_reply.started":"2023-06-20T21:29:48.935870Z","shell.execute_reply":"2023-06-20T21:29:48.943080Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Definir una función para completar los IDs con ceros a la izquierda hasta tener una longitud de 5 caracteres\ndef full_ids(data):\n    return str(data).zfill(5)\n\n# Aplicar la función full_ids a la columna 'BraTS21ID' del DataFrame de entrenamiento y guardar el resultado en una nueva columna llamada 'BraTS21ID_full'\ntrain_csv['BraTS21ID_full'] = train_csv['BraTS21ID'].apply(full_ids)\n# Establecer la ruta base para los datos de entrenamiento\nbase_path = base_datos + 'train/'\n# Crear nuevas columnas en el DataFrame de entrenamiento para las rutas completas a diferentes tipos de secuencias de imágenes para cada ID\ntrain_csv['flair'] = base_path + train_csv['BraTS21ID_full'] + '/FLAIR/'\ntrain_csv['t1w'] = base_path + train_csv['BraTS21ID_full'] + '/T1w/'\ntrain_csv['t1wce'] = base_path + train_csv['BraTS21ID_full'] + '/T1wCE/'\ntrain_csv['t2w'] = base_path + train_csv['BraTS21ID_full'] + '/T2w/'\n#train_csv.to_csv('nuevo_train_labels.csv', index=False)\nprint('\\033[1;32;48;5;82m' + '\\033[1m' + '                                                   TRAIN                                                                         ' + '\\033[0m')\ndisplay(train_csv)\n\n#test_csv\n\n# Aplicar la función full_ids a la columna 'BraTS21ID' del DataFrame de prueba y guardar el resultado en una nueva columna llamada 'BraTS21ID_full'\ntest_csv['BraTS21ID_full'] = test_csv['BraTS21ID'].apply(full_ids)\n# Establecer la ruta base para los datos de prueba\nbase_path = base_datos + 'test/'\n# Crear nuevas columnas en el DataFrame de prueba para las rutas completas a diferentes tipos de secuencias de imágenes para cada ID\ntest_csv['flair'] = base_path + test_csv['BraTS21ID_full'] + '/FLAIR/'\ntest_csv['t1w'] = base_path + test_csv['BraTS21ID_full'] + '/T1w/'\ntest_csv['t1wce'] = base_path + test_csv['BraTS21ID_full'] + '/T1wCE/'\ntest_csv['t2w'] = base_path + test_csv['BraTS21ID_full'] + '/T2w/'\n\nprint('\\033[1;32;48;5;82m' + '\\033[1m' + '                                                     TEST                                                        ' + '\\033[0m')\ndisplay(test_csv)","metadata":{"execution":{"iopub.status.busy":"2023-06-20T21:29:48.946318Z","iopub.execute_input":"2023-06-20T21:29:48.946765Z","iopub.status.idle":"2023-06-20T21:29:49.013606Z","shell.execute_reply.started":"2023-06-20T21:29:48.946725Z","shell.execute_reply":"2023-06-20T21:29:49.012668Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Definir una función para obtener los DataFrames de entrenamiento y validación para un tipo específico de MRI\ndef get_train_val_dataframe(mri_type):\n    # Crear listas vacías para almacenar los archivos de imagen, etiquetas e ID de pacientes\n    all_img_files = []\n    all_img_labels = []\n    all_img_patient_ids = []\n    # Iterar sobre cada fila del DataFrame de entrenamiento\n    for row in train_csv.iterrows():\n        # Verificar si el valor en la columna 'BraTS21ID_full' es igual a '00109' y si el valor de la variable mri_type es igual a 'flair'\n        if row[1]['BraTS21ID_full'] == '00109' and mri_type == 'flair':\n        # Si ambas condiciones se cumplen, pasar a la siguiente iteración del bucle\n             continue\n        # Verificar si el valor en la columna 'BraTS21ID_full' es igual a '00123' y si el valor de la variable mri_type es igual a 't1w'\n        if row[1]['BraTS21ID_full'] == '00123' and mri_type == 't1w':\n        # Si ambas condiciones se cumplen, pasar a la siguiente iteración del bucle\n             continue\n        # Verificar si el valor en la columna 'BraTS21ID_full' es igual a '00709' y si el valor de la variable mri_type es igual a 'flair'\n        if row[1]['BraTS21ID_full'] == '00709' and mri_type == 'flair':\n        # Si ambas condiciones se cumplen, pasar a la siguiente iteración del bucle\n             continue   \n            \n            \n        # Obtener el directorio de imágenes para el tipo de MRI especificado\n        img_dir = row[1][mri_type]\n        # Enumerar los archivos en el directorio de imágenes\n        img_files = os.listdir(img_dir)\n        # Extraer y ordenar los números de imagen de los nombres de archivo\n        img_nums = sorted([int(ele.replace('Image-', '').replace('.dcm', '')) for ele in img_files])\n        # Calcular el punto medio de la lista de números de imagen\n        mid_point = int(len(img_nums)/2)\n        # Establecer los puntos de inicio y finalización para seleccionar un subconjunto de imágenes alrededor del punto medio\n        start_point = mid_point - max(int(mid_point*1e-12), 1)\n        end_point = mid_point + max(int(mid_point*1e-12), 1)\n        # Generar los nombres de archivo para las imágenes seleccionadas\n        img_names = [f'Image-{img_nums[i]}.dcm' for i in range(start_point, end_point+1)]\n        # Concatenar la ruta del directorio con los nombres de archivo para obtener las rutas completas a las imágenes\n        img_paths = [img_dir+ele for ele in img_names]\n        # Generar listas de etiquetas e ID de pacientes para las imágenes seleccionadas\n        img_labels = [row[1]['MGMT_value']]*len(img_paths)\n        img_patient_ids = [row[1]['BraTS21ID']]*len(img_paths)\n        # Agregar las listas a las listas all_img_files, all_img_labels y all_img_patient_ids\n        all_img_files.extend(img_paths)\n        all_img_labels.extend(img_labels)\n        all_img_patient_ids.extend(img_patient_ids)\n    # Crear un DataFrame con las listas all_img_patient_ids, all_img_labels y all_img_files\n    train_val_df = pd.DataFrame({'patient_ids': all_img_patient_ids,\n                  'labels': all_img_labels,\n                  'file_paths': all_img_files})\n    # Mapear la columna 'labels' a cadenas\n    train_val_df['labels'] = train_val_df['labels'].map({1: '1', 0: '0'})\n    # Establecer la proporción de división entre entrenamiento y validación\n    class_prop= 0.90\n    # Crear un diccionario vacío para almacenar los conjuntos de entrenamiento y validación por clase\n    classes_splits  = {}\n    # Iterar sobre las clases 0 y 1\n    for i in range(2):\n        # Seleccionar las filas del DataFrame train_val_df que corresponden a la clase actual\n        train_val_label_class = train_val_df[train_val_df['labels']==f'{i}']\n        # Obtener una lista única de ID de pacientes para la clase actual\n        train_val_list_ids =  list(train_val_label_class['patient_ids'].unique())\n        # Calcular el umbral para dividir la lista en conjuntos de entrenamiento y validación\n        train_threshold = math.ceil(class_prop*len(train_val_list_ids))\n        # Dividir la lista en conjuntos de entrenamiento y validación\n        train_ids = train_val_list_ids[:train_threshold]\n        val_ids = train_val_list_ids[train_threshold:]\n        # Seleccionar las filas del DataFrame que corresponden a los ID de pacientes en cada conjunto y agregarlas al diccionario classes_splits\n        classes_splits[f'train_{i}'] = train_val_label_class[train_val_label_class['patient_ids'].isin(train_ids)]\n        classes_splits[f'val_{i}'] = val_df = train_val_label_class[train_val_label_class['patient_ids'].isin(val_ids)]   \n    # Concatenar las filas correspondientes a cada clase para crear los DataFrames de entrenamiento y validación\n    train_df = pd.concat([classes_splits['train_0'], classes_splits['train_1']], axis=0)\n    val_df = pd.concat([classes_splits['val_0'], classes_splits['val_1']], axis=0)\n    # Devolver los DataFrames de entrenamiento y validación como salida\n    return train_df, val_df\nmri_type='t2w'\ntrain_df, val_df = get_train_val_dataframe(mri_type)\n\n# Establecer la anchura máxima de la columna para mostrar toda la información\npd.set_option('display.max_colwidth', None)\n\nprint('\\033[1;32;48;5;82m' + '\\033[1m' + '                 90% de pacientes de los Datos de TRAIN para entrenamiento                       ' + '\\033[0m')\ndisplay(train_df)\n\nprint('\\033[1;32;48;5;82m' + '\\033[1m' + '                 10% de pacientes de los Datos de TRAIN para validacion                          ' + '\\033[0m')\ndisplay(val_df)","metadata":{"execution":{"iopub.status.busy":"2023-06-20T21:29:49.015061Z","iopub.execute_input":"2023-06-20T21:29:49.015619Z","iopub.status.idle":"2023-06-20T21:30:41.412871Z","shell.execute_reply.started":"2023-06-20T21:29:49.015582Z","shell.execute_reply":"2023-06-20T21:30:41.411831Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def procesar_data_frame(df):\n    contador = 0\n    columnas_eliminar = []\n    imagenes_eliminar = []\n    imagenes_no_eliminar = []\n\n    for i, row in df.iterrows():\n        url = row['file_paths']\n        patient_id = row['patient_ids']  # Nueva variable para obtener el valor de la columna patient_ids\n        label = row['labels']  # Nueva variable para obtener el valor de la columna labels\n        \n        try:\n            dataset = pydicom.dcmread(url)\n            imagen = cp.array(dataset.pixel_array)\n            suma_pixeles = cp.sum(imagen)\n\n            if suma_pixeles <= 0:\n                contador += 1\n                columnas_eliminar.append(i)\n                imagenes_eliminar.append((imagen, patient_id, label))  # Guardar también patient_id y label de las imágenes eliminadas\n            else:\n                imagenes_no_eliminar.append((imagen, patient_id, label))  # Guardar las imágenes no eliminadas junto con patient_id y label\n                \n        except:\n            contador += 1\n            columnas_eliminar.append(i)\n\n    df = df.drop(columnas_eliminar)\n\n    return df, contador, imagenes_eliminar, imagenes_no_eliminar\n\n# Procesamiento del DataFrame train_df\ntrain_df, contador_train, imagenes_elim_train, imagenes_no_elim_train = procesar_data_frame(train_df)\n\n# Procesamiento del DataFrame val_df\nval_df, contador_val, imagenes_elim_val, imagenes_no_elim_val = procesar_data_frame(val_df)\n\n\nprint(f\"Imágenes sin información eliminadas en train_df: {contador_train}\")\nprint(f\"Imágenes sin información eliminadas en val_df: {contador_val}\")\n\n\n# Imprimir la cantidad de imágenes no eliminadas\nprint(f\"Cantidad de imágenes no eliminadas en train_df: {len(imagenes_no_elim_train)}\")\nprint(f\"Cantidad de imágenes no eliminadas en val_df: {len(imagenes_no_elim_val)}\")\n\nprint('\\033[1;32;48;5;82m' + '\\033[1m' + '                 Imágenes eliminadas Train DataFrame                          ' + '\\033[0m')\n\nfor imagen, patient_id, label in imagenes_elim_train:\n    print(f\"Patient ID: {patient_id}, Label: {label}\")  # Imprimir información adicional\n    plt.imshow(cp.asnumpy(imagen), cmap='gray')\n    plt.show()\nprint('\\033[1;32;48;5;82m' + '\\033[1m' + '                 Imágenes eliminadas validacion DataFrame                          ' + '\\033[0m')\n\nfor imagen, patient_id, label in imagenes_elim_val:\n    print(f\"Patient ID: {patient_id}, Label: {label}\")  # Imprimir información adicional\n    plt.imshow(cp.asnumpy(imagen), cmap='gray')\n    plt.show()\n\nprint('\\033[1;32;48;5;82m' + '\\033[1m' + '                Imágenes no eliminadas                          ' + '\\033[0m')\n\nprint(\"Imágenes no eliminadas:\")\nprint(\"Train DataFrame:\")\nfor imagen, patient_id, label in imagenes_no_elim_train:\n    print(f\"Patient ID: {patient_id}, Label: {label}\")  # Imprimir información adicional\n    plt.imshow(cp.asnumpy(imagen), cmap='gray')\n    plt.show()\n\nprint(\"Val DataFrame:\")\nfor imagen, patient_id, label in imagenes_no_elim_val:\n    print(f\"Patient ID: {patient_id}, Label: {label}\")  # Imprimir información adicional\n    plt.imshow(cp.asnumpy(imagen), cmap='gray')\n    plt.show()\n","metadata":{"execution":{"iopub.status.busy":"2023-06-20T21:30:41.414447Z","iopub.execute_input":"2023-06-20T21:30:41.414830Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Definir una función para obtener el DataFrame de prueba para un tipo específico de MRI\ndef get_test_dataframe(mri_type):\n    # Crear listas vacías para almacenar los archivos de imagen, etiquetas e ID de pacientes\n    all_test_img_files = []\n    all_test_img_labels = []\n    all_test_img_patient_ids = []\n    # Iterar sobre cada fila del DataFrame de prueba\n    for row in test_csv.iterrows():\n        # Obtener el directorio de imágenes para el tipo de MRI especificado\n        img_dir = row[1][mri_type]\n        # Enumerar los archivos en el directorio de imágenes\n        img_files = os.listdir(img_dir)\n        # Extraer y ordenar los números de imagen de los nombres de archivo\n        img_nums = sorted([int(ele.replace('Image-', '').replace('.dcm', '')) for ele in img_files])\n        # Calcular el punto medio de la lista de números de imagen\n        mid_point = int(len(img_nums)/2)\n        # Establecer los puntos de inicio y finalización para seleccionar un subconjunto de imágenes alrededor del punto medio\n        start_point = mid_point - max(int(mid_point*1e-12), 1)\n        end_point = mid_point + max(int(mid_point*1e-12), 1)\n        # Generar los nombres de archivo para las imágenes seleccionadas\n        img_names = [f'Image-{img_nums[i]}.dcm' for i in range(start_point, end_point+1)]\n        # Concatenar la ruta del directorio con los nombres de archivo para obtener las rutas completas a las imágenes\n        img_paths = [img_dir+ele for ele in img_names]\n        # Generar listas de etiquetas e ID de pacientes para las imágenes seleccionadas\n        img_labels = [row[1]['MGMT_value']]*len(img_paths)\n        img_patient_ids = [row[1]['BraTS21ID']]*len(img_paths)\n        # Agregar las listas a las listas all_test_img_files, all_test_img_labels y all_test_img_patient_ids\n        all_test_img_files.extend(img_paths)\n        all_test_img_labels.extend(img_labels)\n        all_test_img_patient_ids.extend(img_patient_ids)\n    # Crear un DataFrame con las listas all_test_img_patient_ids, all_test_img_labels y all_test_img_files\n    test_df = pd.DataFrame({'patient_ids': all_test_img_patient_ids,\n                  'labels': all_test_img_labels,\n                  'file_paths': all_test_img_files})\n    # Establecer la columna 'labels' a una lista de unos seguida por un cero (solución temporal para generar datos de prueba)\n    test_df['labels'] = ['1']*(len(test_df)-1) + ['0']\n    # Devolver el DataFrame de prueba como salida\n    return test_df\n\n\n\nmri_type='t2w'\ntest_df = get_test_dataframe(mri_type)\n\n# Establecer la anchura máxima de la columna para mostrar toda la información\npd.set_option('display.max_colwidth', None)\n\nprint('\\033[1;32;48;5;82m' + '\\033[1m' + '                 CSV DE TEST EN LA CARPETA T2W                       ' + '\\033[0m')\ndisplay(test_df)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Procesamiento del DataFrame test_df\ntest_df, contador_test, imagenes_elim_test, imagenes_no_elim_test = procesar_data_frame(test_df)\n\nprint(f\"Imágenes sin información eliminadas en test_df: {contador_test}\")\n\n# Imprimir la cantidad de imágenes no eliminadas\nprint(f\"Cantidad de imágenes no eliminadas en test_df: {len(imagenes_no_elim_test)}\")\n\nprint('\\033[1;32;48;5;82m' + '\\033[1m' + '                 Imágenes eliminadas Test DataFrame                          ' + '\\033[0m')\n\nfor imagen, patient_id, label in imagenes_elim_test:\n    print(f\"Patient ID: {patient_id}, Label: {label}\")  # Imprimir información adicional\n    plt.imshow(cp.asnumpy(imagen), cmap='gray')\n    plt.show()\n\nprint('\\033[1;32;48;5;82m' + '\\033[1m' + '                Imágenes no eliminadas                          ' + '\\033[0m')\n\nprint(\"Imágenes no eliminadas:\")\nprint(\"Test DataFrame:\")\nfor imagen, patient_id, label in imagenes_no_elim_test:\n    print(f\"Patient ID: {patient_id}, Label: {label}\")  # Imprimir información adicional\n    plt.imshow(cp.asnumpy(imagen), cmap='gray')\n    plt.show()","metadata":{"execution":{"iopub.status.idle":"2023-06-20T21:36:31.695940Z","shell.execute_reply.started":"2023-06-20T21:35:47.768724Z","shell.execute_reply":"2023-06-20T21:36:31.694994Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Importar las bibliotecas necesarias\nimport numpy as np\nimport pydicom\nimport cv2\nfrom keras_preprocessing.image import DataFrameIterator\n\n# Definir una clase DCMDataFrameIterator que herede de la clase DataFrameIterator de keras_preprocessing.image\nclass DCMDataFrameIterator(DataFrameIterator):\n    # Definir el método __init__ para inicializar la instancia de la clase\n    def __init__(self, *args, **kwargs):\n        # Establecer el atributo white_list_formats a una tupla que contiene solo 'dcm'\n        self.white_list_formats = ('dcm',)\n        # Llamar al método __init__ de la clase base para inicializar los atributos heredados\n        super(DCMDataFrameIterator, self).__init__(*args, **kwargs)\n        # Establecer los atributos dataframe, x e y utilizando los valores pasados como argumentos de palabra clave\n        self.dataframe = kwargs['dataframe']\n        self.x = self.dataframe[kwargs['x_col']]\n        self.y = self.dataframe[kwargs['y_col']]\n        # Establecer los atributos color_mode y target_size utilizando los valores pasados como argumentos de palabra clave\n        self.color_mode = kwargs['color_mode']\n        self.target_size = kwargs['target_size']\n    # Definir el método _get_batches_of_transformed_samples para generar lotes de datos de imagen aumentados en tiempo real\n    def _get_batches_of_transformed_samples(self, indices_array):\n        # Obtener un lote de imágenes leyendo los archivos DICOM especificados por indices_array y convirtiéndolos en matrices NumPy\n        batch_x = np.array([self.read_dcm_as_array(dcm_path, self.target_size, color_mode=self.color_mode)\n                            for dcm_path in self.x.iloc[indices_array]])\n        # Obtener las etiquetas correspondientes a las imágenes en el lote\n        batch_y = np.array(self.y.iloc[indices_array].astype(np.uint8))  # astype porque y se pasó como str\n        # Si se especificó un generador de datos de imagen, aplicar transformaciones aleatorias a las imágenes en el lote\n        if self.image_data_generator is not None:\n            for i, (x, y) in enumerate(zip(batch_x, batch_y)):\n                transform_params = self.image_data_generator.get_random_transform(x.shape)\n                batch_x[i] = self.image_data_generator.apply_transform(x, transform_params)\n                # Puedes cambiar y aquí también, por ejemplo, en segmentación semántica quieres transformar las máscaras también\n                # utilizando las mismas transformaciones del generador de datos de imagen.\n        # Devolver el lote de imágenes y etiquetas como salida\n        return batch_x, batch_y\n    # Definir un método estático para leer un archivo DICOM y convertirlo en una matriz NumPy\n    @staticmethod\n    def read_dcm_as_array(dcm_path, target_size=(300, 300), color_mode='rgb'):\n        # Leer el archivo DICOM utilizando la biblioteca pydicom\n        image_array = pydicom.dcmread(dcm_path).pixel_array\n        # Normalizar la matriz de imagen para tener valores entre 0 y 1\n        pixels = image_array - np.min(image_array)\n        pixels = pixels / np.max(pixels)\n        # Convertir la matriz normalizada\n                # Convertir la matriz normalizada a valores enteros entre 0 y 255\n        image_manual_norm = (pixels * 255).astype(np.uint8)\n        # Cambiar el tamaño de la matriz de imagen al tamaño objetivo utilizando interpolación más cercana\n        image_array = cv2.resize(image_manual_norm, target_size, interpolation=cv2.INTER_NEAREST)  # esto devuelve una matriz 2D\n        # Si se especificó el modo de color 'rgb', convertir la matriz de imagen a una imagen en color\n        if color_mode == 'rgb':\n            image_array = np.expand_dims(image_array, -1)  # Expandir dimensiones para que sea una matriz 3D (escala de grises)\n            image_array = np.repeat(image_array, 3, axis=-1)  # Repetir la matriz en los 3 canales para crear una imagen en color\n        # Devolver la matriz de imagen como salida\n        return image_array","metadata":{"execution":{"iopub.status.busy":"2023-06-20T21:36:31.697717Z","iopub.execute_input":"2023-06-20T21:36:31.698060Z","iopub.status.idle":"2023-06-20T21:36:31.711335Z","shell.execute_reply.started":"2023-06-20T21:36:31.698023Z","shell.execute_reply":"2023-06-20T21:36:31.710200Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def build_model(weights_path):\n    top_dropout_rate = 0.2    \n    model = EfficientNetB3(include_top=False, weights=weights_path)\n    model.trainable = False\n    \n    x = GlobalAveragePooling2D(name=\"avg_pool\")(model.output)\n    x = BatchNormalization()(x)\n    top_dropout_rate = 0.4\n    x = BatchNormalization()(x)\n    x = Dense(32, activation=\"relu\")(x)\n    x = Dropout(top_dropout_rate)(x)\n    x = BatchNormalization()(x)\n    x = Dense(32, activation=\"relu\")(x)\n    x = BatchNormalization()(x)\n    x = Dropout(top_dropout_rate)(x)\n    x = BatchNormalization()(x)\n    outputs = Dense(1, activation=\"sigmoid\", name=\"pred\")(x)\n       \n    # Compile\n    model = Model(model.inputs, outputs, name=\"EfficientNet\")\n    \n    # Compile\n    optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)\n     \n    #model.compile(optimizer=optimizer, loss=\"binary_crossentropy\", metrics=[\"binary_accuracy\",AUC()])\n    model.compile(optimizer=optimizer, loss=\"binary_crossentropy\", metrics=[\"binary_accuracy\", tf.keras.metrics.AUC()])\n \n    return model\n\nfrom tensorflow.keras.utils import plot_model\nmodel = build_model(\"../input/efficentnet-b0b5-tensorflow-24-notop/efficientnet-b3_tf24_imagenet_1000_notop.h5\") # Construir el modelo utilizando una función personalizada build_model\n# Crear una representación gráfica del modelo\n#plot_model(model, to_file='model_graph.png', show_shapes=True)","metadata":{"execution":{"iopub.status.busy":"2023-06-20T21:36:31.712452Z","iopub.execute_input":"2023-06-20T21:36:31.712784Z","iopub.status.idle":"2023-06-20T21:36:35.585695Z","shell.execute_reply.started":"2023-06-20T21:36:31.712737Z","shell.execute_reply":"2023-06-20T21:36:35.584765Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"SEED = 369\nBATCH_SIZE = 128\nCLASS_MODE = 'binary'\nCOLOR_MODE = 'rgb'\nTARGET_SIZE = (300, 300)","metadata":{"execution":{"iopub.status.busy":"2023-06-20T21:36:35.586926Z","iopub.execute_input":"2023-06-20T21:36:35.587204Z","iopub.status.idle":"2023-06-20T21:36:35.591442Z","shell.execute_reply.started":"2023-06-20T21:36:35.587176Z","shell.execute_reply":"2023-06-20T21:36:35.590605Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def get_data_generators(train_df,val_df, test_df):\n    train_augmentation_parameters = dict(\n        rescale=1.0/255,\n        zoom_range=0.2,\n        rotation_range=0.2,\n        fill_mode='nearest',\n        height_shift_range= 0.1,\n        width_shift_range=0.1,\n        horizontal_flip=True,\n        brightness_range = [0.8, 1.2]\n    )\n    \n    val_augmentation_parameters = dict(\n        rescale=1.0/255.0\n    )\n\n    test_augmentation_parameters = dict(\n        rescale=1.0/255.0\n    )\n\n    train_consts = {\n        'seed': SEED,\n        'batch_size': BATCH_SIZE,\n        'class_mode': CLASS_MODE,\n        'color_mode': COLOR_MODE,\n        'target_size': TARGET_SIZE,  \n    }\n    \n    val_consts = {\n    'batch_size': BATCH_SIZE,\n    'class_mode': CLASS_MODE,\n    'color_mode': COLOR_MODE,\n    'target_size': TARGET_SIZE,\n    'shuffle': False\n    }\n\n    test_consts = {\n        'batch_size': BATCH_SIZE,\n        'class_mode': CLASS_MODE,\n        'color_mode': COLOR_MODE,\n        'target_size': TARGET_SIZE,\n        'shuffle': False\n    }\n\n    train_augmenter = ImageDataGenerator(**train_augmentation_parameters)\n    val_augmenter = ImageDataGenerator(**val_augmentation_parameters)\n    test_augmenter = ImageDataGenerator(**test_augmentation_parameters)\n\n    train_generator = DCMDataFrameIterator(dataframe=train_df,\n                                 x_col='file_paths',\n                                 y_col='labels',\n                                 image_data_generator=train_augmenter,\n                                 **train_consts)\n    \n    val_generator = DCMDataFrameIterator(dataframe=val_df,\n                                 x_col='file_paths',\n                                 y_col='labels',\n                                 image_data_generator=val_augmenter,\n                                 **val_consts)\n    \n    test_generator = DCMDataFrameIterator(dataframe=test_df,\n                                 x_col='file_paths',\n                                 y_col='labels',\n                                 image_data_generator=test_augmenter,\n                                 **test_consts)\n    \n    return train_generator, val_generator, test_generator","metadata":{"execution":{"iopub.status.busy":"2023-06-20T21:36:35.592843Z","iopub.execute_input":"2023-06-20T21:36:35.593493Z","iopub.status.idle":"2023-06-20T21:36:35.604588Z","shell.execute_reply.started":"2023-06-20T21:36:35.593451Z","shell.execute_reply":"2023-06-20T21:36:35.603659Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"checkpoint_filepath = 'best_model.h5'\n\ndef train_model(model_name, train_generator, val_generator, epochs):\n\n    print('training', model_name)\n\n    model = build_model(\"../input/efficentnet-b0b5-tensorflow-24-notop/efficientnet-b3_tf24_imagenet_1000_notop.h5\")\n    \n    # Resto del código...\n    \n    #callbacks\n    checkpoint_cb=ModelCheckpoint(\n        filepath=checkpoint_filepath,\n        save_weights_only=False,\n        monitor='val_loss',\n        mode='min',\n        save_best_only=True,\n        save_freq='epoch',\n        verbose=1)\n    \n    early_stopping_cb = tf.keras.callbacks.EarlyStopping(monitor='val_loss',\n                                                  patience=5,\n                                                  mode='min',\n                                                  verbose=1,\n                                                  restore_best_weights=True)\n\n    reduce_lr_cb=ReduceLROnPlateau(monitor='val_loss', factor=0.5,\n                                   patience=2, min_lr=0.0000001,\n                                  verbose=1)\n\n    history = model.fit(\n                        train_generator,\n                        steps_per_epoch=len(train_generator),\n                        validation_data=val_generator,\n                        validation_steps=len(val_generator),\n                        epochs=epochs,\n                        workers=2,\n                        callbacks=[checkpoint_cb, reduce_lr_cb, early_stopping_cb]\n                        )\n\n    return model, history\nmodel = build_model(\"../input/efficentnet-b0b5-tensorflow-24-notop/efficientnet-b3_tf24_imagenet_1000_notop.h5\")\n#plot_model(model, to_file='model_graph.png', show_shapes=True)","metadata":{"execution":{"iopub.status.busy":"2023-06-20T21:36:35.606129Z","iopub.execute_input":"2023-06-20T21:36:35.606486Z","iopub.status.idle":"2023-06-20T21:36:39.296234Z","shell.execute_reply.started":"2023-06-20T21:36:35.606452Z","shell.execute_reply":"2023-06-20T21:36:39.295303Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#all_test_preds = []\nfor mt in ['t2w']:\n    train_df, val_df = get_train_val_dataframe(mt)\n    \n    test_df = get_test_dataframe(mt)\n\n    train_g, val_g, test_g = get_data_generators(train_df, val_df, test_df)\n    best_model, history = train_model(mt, train_g, val_g, epochs=10)\n  \n   # Evaluate the model and calculate various metrics\n    results = best_model.evaluate(test_g, steps=len(test_g))\n    test_pred = best_model.predict(test_g, steps=len(test_g))\n    y_true = test_g.labels\n    y_pred = (test_pred > 0.5).astype(int)\n    \n    accuracy = sklearn.metrics.accuracy_score(y_true, y_pred)\n    precision = sklearn.metrics.precision_score(y_true, y_pred)\n    recall = sklearn.metrics.recall_score(y_true, y_pred)\n    f1_score = sklearn.metrics.f1_score(y_true, y_pred)\n    mcc = sklearn.metrics.matthews_corrcoef(y_true, y_pred)\n    auc_roc = sklearn.metrics.roc_auc_score(y_true, y_pred)\n    auc_pr = sklearn.metrics.average_precision_score(y_true, y_pred)\n    brier_score = np.mean((y_pred - y_true)**2)\n\n    print(f\"Modelo {mt}: test loss = ,{results[0]}, test acc = {accuracy}, test AUC-ROC = {auc_roc}, test AUC-PR = {auc_pr}, test precision = {precision}, test recall = {recall}, test F1-score = {f1_score}, test MCC = {mcc}, test Brier score = {brier_score}\")\n    print(results[0], accuracy, auc_roc, auc_pr, precision, recall, f1_score, mcc, brier_score)\n    test_df['pred_y'] = test_pred\n    mean_pred = test_pred.mean()\n\n    test_pred_agg = test_df.groupby('patient_ids').apply(\n        lambda x: x['pred_y'].max() if (x['pred_y'].max() - mean_pred) > (mean_pred - x['pred_y'].min()) else x['pred_y'].min())\n\n    all_test_preds.append(test_pred_agg.values)","metadata":{"execution":{"iopub.status.busy":"2023-06-20T21:36:39.297629Z","iopub.execute_input":"2023-06-20T21:36:39.298005Z","iopub.status.idle":"2023-06-20T21:43:20.495092Z","shell.execute_reply.started":"2023-06-20T21:36:39.297967Z","shell.execute_reply":"2023-06-20T21:43:20.493993Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"history_df = pd.DataFrame(history.history)\nhistory_df.loc[:, ['loss', 'val_loss']].plot(title=\"Cross-entropy\")\nhistory_df.loc[:, ['binary_accuracy', 'val_binary_accuracy']].plot(title=\"Accuracy\")","metadata":{"execution":{"iopub.status.busy":"2023-06-20T21:43:20.499064Z","iopub.execute_input":"2023-06-20T21:43:20.499432Z","iopub.status.idle":"2023-06-20T21:43:21.299054Z","shell.execute_reply.started":"2023-06-20T21:43:20.499393Z","shell.execute_reply":"2023-06-20T21:43:21.298203Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"all_test_preds = np.array(all_test_preds) # Convertir la lista de predicciones de prueba en un array de NumPy\nplt.hist(all_test_preds.mean(0)) # Crear un histograma con la media de las predicciones de prueba a lo largo del primer eje\nsubm = pd.read_csv(base_datos+'sample_submission.csv') # Leer el archivo CSV de ejemplo de envío utilizando la biblioteca Pandas\nsubm['MGMT_value'] = all_test_preds.mean(0) # Asignar la media de las predicciones de prueba a la columna 'MGMT_value' del dataframe\nsubm.to_csv(\"submission.csv\", index=False) # Guardar el dataframe en un archivo CSV para enviarlo a la competición\nsubm # Mostrar el dataframe resultante\n","metadata":{"_kg_hide-output":true,"execution":{"iopub.status.busy":"2023-06-20T21:43:21.300408Z","iopub.execute_input":"2023-06-20T21:43:21.300764Z","iopub.status.idle":"2023-06-20T21:43:21.944988Z","shell.execute_reply.started":"2023-06-20T21:43:21.300725Z","shell.execute_reply":"2023-06-20T21:43:21.944050Z"},"trusted":true},"execution_count":null,"outputs":[]}]}