{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.7.10","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Importe Librerias","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2023-06-28T05:25:16.6468Z","iopub.execute_input":"2023-06-28T05:25:16.64728Z","iopub.status.idle":"2023-06-28T05:25:21.913978Z","shell.execute_reply.started":"2023-06-28T05:25:16.647175Z","shell.execute_reply":"2023-06-28T05:25:21.912968Z"}}},{"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, porcentaje):\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* porcentaje), 1)\n        end_point = mid_point + max(int(mid_point* porcentaje), 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    \n       \n    # Establecer la anchura máxima de la columna para mostrar toda la información\n    pd.set_option('display.max_colwidth', None)\n    print('\\033[1;32;48;5;82m' + '\\033[1m' + '                 CSV DE TEST EN LA CARPETA T2W                       ' + '\\033[0m')\n    display(test_df)\n    \n    # Devolver el DataFrame de prueba como salida\n    return test_df","metadata":{"execution":{"iopub.status.busy":"2023-09-05T10:13:47.716578Z","iopub.execute_input":"2023-09-05T10:13:47.716922Z","iopub.status.idle":"2023-09-05T10:13:47.735563Z","shell.execute_reply.started":"2023-09-05T10:13:47.716842Z","shell.execute_reply":"2023-09-05T10:13:47.734585Z"},"trusted":true},"execution_count":null,"outputs":[]},{"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, Adam\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# Importar la biblioteca sklearn para herramientas de aprendizaje automático\nimport sklearn\n# Importar la capa GlobalAveragePooling2D de TensorFlow para el promedio global de características\nfrom tensorflow.keras.layers import GlobalAveragePooling2D  \n# Importar la función display de IPython para mostrar objetos visualmente\nfrom IPython.display import display  \n# Importar la función plot_model de TensorFlow para generar el diagrama del modelo\nfrom tensorflow.keras.utils import plot_model  \n# Importar la biblioteca cupy para cálculos en paralelo en la GPU\nimport cupy as cp  \nfrom tensorflow.keras.utils import plot_model\nfrom IPython.display import FileLink\nfrom sklearn.model_selection import train_test_split\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.\n#tf.config.set_visible_devices(tf.config.list_physical_devices('GPU'), 'GPU')\n\nif tf.test.is_gpu_available():\n    print('Se encontró al menos una GPU')\n    print('Dispositivos GPU disponibles:')\n    gpu_devices = tf.config.list_physical_devices('GPU')\n    for device in gpu_devices:\n        print(device)\nelse:\n    print('No se encontró GPU')","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2023-09-05T10:13:47.738177Z","iopub.execute_input":"2023-09-05T10:13:47.738775Z"},"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":{"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":{"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":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def create_dataframe(train_csv, mt):\n    all_img_files = []\n    all_img_labels = []\n    all_img_patient_ids = []\n    \n    for index, row in train_csv.iterrows():\n        img_dir = row[mt]\n        img_files = os.listdir(img_dir)\n        \n        img_paths = [os.path.join(img_dir, img_file) for img_file in img_files]\n        img_labels = [row['MGMT_value']] * len(img_paths)\n        img_patient_ids = [row['BraTS21ID']] * len(img_paths)\n\n        all_img_files.extend(img_paths)\n        all_img_labels.extend(img_labels)\n        all_img_patient_ids.extend(img_patient_ids)\n        \n    train_original = pd.DataFrame({\n        'patient_ids': all_img_patient_ids,\n        'labels': all_img_labels,\n        'file_paths': all_img_files\n    })\n    \n    train_original['labels'] = train_original['labels'].map({1: '1', 0: '0'})\n    \n    pd.set_option('display.max_colwidth', None)\n    print('\\033[1;32;48;5;82m' + '\\033[1m' + '                 Dataframe con todas las imagenes                       ' + '\\033[0m')\n    display(train_original)\n    \n    return train_original","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def create_dataframe_with_percentage(train_csv, mt, porcentaje): \n    #remaining_df_filtered = filter_patients(train_csv, mt)\n    \n    remaining_df_filtered =  train_csv\n    \n    all_img_files_filtered = []\n    all_img_labels_filtered = []\n    all_img_patient_ids_filtered = []\n    \n    for index, row in remaining_df_filtered.iterrows():\n        img_dir = row[mt]\n        img_files = os.listdir(img_dir)\n        \n        img_nums = sorted([int(ele.replace('Image-', '').replace('.dcm', '')) for ele in img_files])\n        mid_point = int(len(img_nums) / 2)\n        start_point = mid_point - max(int(mid_point * (porcentaje)), 1)\n        end_point = mid_point + max(int(mid_point * (porcentaje)), 1)\n        img_names = [f'Image-{img_nums[i]}.dcm' for i in range(start_point, end_point + 1)]\n        img_paths = [os.path.join(img_dir, ele) for ele in img_names]\n        img_labels = [row['MGMT_value']] * len(img_paths)\n        img_patient_ids = [row['BraTS21ID']] * len(img_paths)\n\n        all_img_files_filtered.extend(img_paths)\n        all_img_labels_filtered.extend(img_labels)\n        all_img_patient_ids_filtered.extend(img_patient_ids)\n        \n    train_val_df_filtered = pd.DataFrame({\n        'patient_ids': all_img_patient_ids_filtered,\n        'labels': all_img_labels_filtered,\n        'file_paths': all_img_files_filtered\n    })\n    \n    train_val_df_filtered['labels'] = train_val_df_filtered['labels'].map({1: '1', 0: '0'})\n    \n    pd.set_option('display.max_colwidth', None)\n    print('\\033[1;32;48;5;82m' + '\\033[1m' + '                 Dataframe con porcentaje                       ' + '\\033[0m')\n    display(train_val_df_filtered)\n    \n    \n    return train_val_df_filtered","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def filter_patients(remaining_df, mt):\n    # Definir las condiciones de pacientes a eliminar\n    patients_to_exclude = [\n        ('00109', 'flair'),\n        ('00123', 't1w'),\n        ('00709', 'flair')\n    ]\n    # Aplicar las condiciones y filtrar los pacientes\n    for patient_id, mri in patients_to_exclude:\n        remaining_df = remaining_df[~((remaining_df['BraTS21ID_full'] == patient_id) & (mt == mri))]\n    return remaining_df","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def extract_all_images(train_csv, mri_type):\n    train_csv_filtered = filter_patients(train_csv.copy(), mri_type)\n    all_img_files_all = []\n    all_img_labels_all = []\n    all_img_patient_ids_all = []\n    \n    for index, row in train_csv_filtered.iterrows():\n        img_dir = row[mri_type]\n        img_files = os.listdir(img_dir)\n        \n        img_paths_all = [os.path.join(img_dir, img_file) for img_file in img_files]\n        img_labels_all = [row['MGMT_value']] * len(img_paths_all)\n        img_patient_ids_all = [row['BraTS21ID']] * len(img_paths_all)\n        \n        all_img_files_all.extend(img_paths_all)\n        all_img_labels_all.extend(img_labels_all)\n        all_img_patient_ids_all.extend(img_patient_ids_all)\n    \n    train_val_df_all = pd.DataFrame({\n        'patient_ids': all_img_patient_ids_all,\n        'labels': all_img_labels_all,\n        'file_paths': all_img_files_all\n    })\n    \n    train_val_df_all['labels'] = train_val_df_all['labels'].map({1: '1', 0: '0'})\n    \n    pd.set_option('display.max_colwidth', None)\n    print('\\033[1;32;48;5;82m' + '\\033[1m' + '                 dataframe original                       ' + '\\033[0m')\n    display(train_val_df_all)\n        \n    return train_val_df_all","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Eliminacion de imagenes sin informacion DINAMICA \n'''\ndef analyze_and_remove_zero_sum_images(train_val_df):\n    images_to_keep = []\n    removed_values = []\n    removed_rows = []\n    \n    for index, row in train_val_df.iterrows():\n        img_path = row['file_paths']\n        \n        try:\n            dcm = pydicom.dcmread(img_path)\n            img_array = dcm.pixel_array.astype(np.float32)\n            img_array_gpu = cp.asarray(img_array)\n            \n            if cp.sum(img_array_gpu) != 0:\n                images_to_keep.append(row)\n            else:\n                removed_values.append(row['labels'])  # Guardar el valor de la imagen eliminada\n                removed_rows.append(row)  # Guardar toda la fila de la imagen eliminada\n        except Exception as e:\n            print(f\"Error processing image {img_path}: {e}\")\n    \n    remaining_df = pd.DataFrame(images_to_keep)\n    removed_df = pd.DataFrame(removed_rows)  # Crear DataFrame de imágenes eliminadas\n    \n    removed_count = len(removed_values)\n    remaining_count = len(images_to_keep)\n    \n    print(f\"Se eliminaron {removed_count} imágenes con una suma de cero píxeles.\")\n    print(f\"Quedaron {remaining_count} imágenes después de la eliminación.\")\n    \n    pd.set_option('display.max_colwidth', None)\n    print('\\033[1;32;48;5;82m' + '\\033[1m' + '                 dataframe original                       ' + '\\033[0m')\n    display(remaining_df)\n    \n    removed_csv = 'removed_images.csv'\n    removed_df.to_csv(removed_csv, index=False)\n    print(f\"Se guardó el DataFrame de imágenes eliminadas en {removed_csv}\")\n    \n    print('\\033[1;31;48;5;82m' + '\\033[1m' + '                 dataframe de imágenes eliminadas                ' + '\\033[0m')\n    display(removed_df)\n    \n    # Mostrar el enlace de descarga\n    \n    file_link = FileLink('removed_images.csv')\n    display(file_link)\n    \n    return remaining_df, removed_values\n'''\ndef analyze_and_remove_zero_sum_images(train_val_df_all, mt):\n    # Carpeta predeterminada donde se encuentran los archivos CSV\n    dataset_dir = '/kaggle/input/datos-negros/'\n\n    # Validar que mt sea una de las secuencias de IRM válidas\n    valid_mt_values = ['flair', 't1w', 't2w', 't1wce']\n    if mt not in valid_mt_values:\n        raise ValueError(f\"mt debe ser uno de {', '.join(valid_mt_values)}\")\n\n    # Obtener el nombre del archivo CSV correspondiente a la secuencia de IRM\n    csv_filename = f\"{mt}.csv\"\n    csv_path = os.path.join(dataset_dir, csv_filename)\n\n    # Verificar si el archivo CSV existe en la ubicación especificada\n    if not os.path.isfile(csv_path):\n        raise ValueError(f\"No se encontró el archivo CSV correspondiente a '{mt}' en '{dataset_dir}'\")\n\n    # Cargar el DataFrame del archivo CSV\n    df = pd.read_csv(csv_path)\n    \n    pd.set_option('display.max_colwidth', None)\n    print('\\033[1;32;48;5;82m' + '\\033[1m' + '                 Datos de las imagenes sin informacion                       ' + '\\033[0m')\n    display(df)\n\n    # Obtener una lista de las URLs de imágenes en la columna correspondiente a mt\n    mt_urls = df['file_paths'].tolist()\n    \n    # Filtrar las filas de train_val_df_all que no contienen las URLs en mt_urls\n    remaining_df = train_val_df_all[~train_val_df_all['file_paths'].isin(mt_urls)]\n    \n    pd.set_option('display.max_colwidth', None)\n    print('\\033[1;32;48;5;82m' + '\\033[1m' + '                 Dataframe restante                       ' + '\\033[0m')\n    display(remaining_df)\n    \n\n    # Mostrar estadísticas\n    removed_count = len(train_val_df_all) - len(remaining_df)\n    remaining_count = len(remaining_df)\n\n    print(f\"Se eliminaron {removed_count} imágenes con suma de cero píxeles.\")\n    print(f\"Quedaron {remaining_count} imágenes después de la eliminación.\")\n\n    return remaining_df","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def split_train_val_data(train_val_df, class_prop, random_state):\n       \n    # Verificar el tipo de datos en la columna 'labels'\n    print(f'Tipo de datos en la columna \"labels\": {train_val_df[\"labels\"].dtype}')\n    \n    # Contar el número de ejemplos de cada clase utilizando value_counts()\n    class_counts = train_val_df['labels'].value_counts()\n    num_class_0 = class_counts.get(0, 0)\n    num_class_1 = class_counts.get(1, 0)\n    \n    # Imprimir el número de ejemplos de cada clase\n    print(f'Número de ejemplos de clase 0: {num_class_0}')\n    print(f'Número de ejemplos de clase 1: {num_class_1}')\n        \n    # Divide el DataFrame en dos DataFrames, uno para cada clase\n    class_0_df = train_val_df[train_val_df['labels'].eq('0')]\n    class_1_df = train_val_df[train_val_df['labels'].eq('1')]\n#--------------------------------------------------------------------------\n    pd.set_option('display.max_colwidth', None)\n    print('\\033[1;32;48;5;82m' + '\\033[1m' + f'                 ejemplo de la entrada para  separar clase 1 y 0                      ' + '\\033[0m')\n    display(train_val_df)\n    \n    pd.set_option('display.max_colwidth', None)\n    print('\\033[1;32;48;5;82m' + '\\033[1m' + f'                 clase 0                       ' + '\\033[0m')\n    display(class_0_df)\n    \n    pd.set_option('display.max_colwidth', None)\n    print('\\033[1;32;48;5;82m' + '\\033[1m' + f'                 clase 1                       ' + '\\033[0m')\n    display(class_1_df)\n#--------------------------------------------------------------------------\n    # Divide cada DataFrame en conjuntos de entrenamiento y validación según class_prop\n    #train_class_0, val_class_0 = train_test_split(class_0_df, train_size=class_prop, random_state=42)\n    #train_class_1, val_class_1 = train_test_split(class_1_df, train_size=class_prop, random_state=42)\n    \n    train_class_0, val_class_0 = train_test_split(class_0_df, train_size=class_prop, random_state=random_state)\n    train_class_1, val_class_1 = train_test_split(class_1_df, train_size=class_prop, random_state=random_state)\n\n    # Concatena los DataFrames de cada clase para obtener los conjuntos finales\n    train_df = pd.concat([train_class_0, train_class_1], axis=0)\n    val_df = pd.concat([val_class_0, val_class_1], axis=0)\n    \n    # Calcula el porcentaje final\n    final_percentage = class_prop * 100\n    \n    print(f'Porcentaje de datos de entrenamiento para esta clase: {class_prop * 100:.2f}%')\n\n    pd.set_option('display.max_colwidth', None)\n    print('\\033[1;32;48;5;82m' + '\\033[1m' + f'                 {final_percentage:.2f}% de pacientes de los Datos de TRAIN para entrenamiento                       ' + '\\033[0m')\n    display(train_df)\n    print('\\033[1;32;48;5;82m' + '\\033[1m' + f'                 {(100 - final_percentage):.2f}% de pacientes de los Datos de TRAIN para validación                          ' + '\\033[0m')\n    display(val_df) \n        \n    # Contar el número de ejemplos de cada clase utilizando value_counts()\n    class_counts_1 = train_df['labels'].value_counts()\n    num_class_0_1 = class_counts_1.get(0, 0)\n    num_class_1_1 = class_counts_1.get(1, 0)\n    \n    # Imprimir el número de ejemplos de cada clase\n    print(f'Número de ejemplos de clase 0 en train_df: {num_class_0_1}')\n    print(f'Número de ejemplos de clase 1 en train_df: {num_class_1_1}')\n    \n    # Contar el número de ejemplos de cada clase utilizando value_counts()\n    class_counts_2 = val_df['labels'].value_counts()\n    num_class_0_2 = class_counts_2.get(0, 0)\n    num_class_1_2 = class_counts_2.get(1, 0)\n    \n    # Imprimir el número de ejemplos de cada clase\n    print(f'Número de ejemplos de clase 0 en val_df: {num_class_0_2}')\n    print(f'Número de ejemplos de clase 1 en val_df: {num_class_1_2}')\n\n    return train_df, val_df","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# 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    \n    \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":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def get_data_generators(train_df,val_df, test_df, brightness_range):\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=brightness_range\n        \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    \n    CLASS_MODE = 'binary'\n    COLOR_MODE = 'rgb'\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":{"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-4)\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","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"checkpoint_filepath = 'best_model.h5'\n\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    #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.00001,\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\n'''\n\n# Define la estrategia de distribución para aprovechar dos GPU\nstrategy = tf.distribute.MirroredStrategy()\n\n'''\n# Define la función para entrenar el modelo\ndef train_model(model_name, train_generator, val_generator, epochs):\n\n    print('training', model_name)\n\n    # Crear el modelo dentro del alcance de la estrategia\n    with strategy.scope():\n        model = build_model(\"../input/efficentnet-b0b5-tensorflow-24-notop/efficientnet-b3_tf24_imagenet_1000_notop.h5\")\n\n        # Resto de tu código de callbacks\n        checkpoint_cb = tf.keras.callbacks.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\n        early_stopping_cb = tf.keras.callbacks.EarlyStopping(\n            monitor='val_loss',\n            patience=5,\n            mode='min',\n            verbose=1,\n            restore_best_weights=True\n        )\n\n        reduce_lr_cb = tf.keras.callbacks.ReduceLROnPlateau(\n            monitor='val_loss',\n            factor=0.5,\n            patience=2,\n            min_lr=0.00001,\n            verbose=1\n        )\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\n'''\n\n# Modifica la función train_model para aceptar estos argumentos opcionales con valores predeterminados\ndef train_model(model_name, train_generator, val_generator, epochs, patience, factor, min_lr):\n    print('training', model_name)\n\n    # Crear el modelo dentro del alcance de la estrategia\n    with strategy.scope():\n        model = build_model(\"../input/efficentnet-b0b5-tensorflow-24-notop/efficientnet-b3_tf24_imagenet_1000_notop.h5\")\n\n        # Resto de tu código de callbacks\n        checkpoint_cb = tf.keras.callbacks.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\n        early_stopping_cb = tf.keras.callbacks.EarlyStopping(\n            monitor='val_loss',\n            patience=patience,  # Usa el valor proporcionado como argumento\n            mode='min',\n            verbose=1,\n            restore_best_weights=True\n        )\n\n        reduce_lr_cb = tf.keras.callbacks.ReduceLROnPlateau(\n            monitor='val_loss',\n            factor=factor,  # Usa el valor proporcionado como argumento\n            patience=2,\n            min_lr=min_lr,  # Usa el valor proporcionado como argumento\n            verbose=1\n        )\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","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"all_test_preds = []\n\n#for mt in ['flair', 't1w', 't1wce', 't2w']:\nfor mt in ['t1w']:\n\n    '''\n    #Porcentaje para la extracion de las imagenes\n    porcentaje = 0.1\n    class_prop = 0.80\n    \n    # HIPERPARÁMETROS\n    epochs=10\n    SEED = 500  # Puedes cambiar el valor de la semilla aleatoria si es necesario\n    BATCH_SIZE = 350  # Puedes ajustar el tamaño del lote según tus necesidades\n    TARGET_SIZE = (300, 300)  # Puedes cambiar el tamaño de destino de las imágenes\n    brightness_range = [0.8, 1.2]  # Puedes ajustar el rango de brillo de las imágenes\n    learning_rate = 1e-2  # Puedes modificar la tasa de aprendizaje\n    top_dropout_rate = 0.2  # Puedes ajustar la tasa de abandono en la parte superior de la red\n    patience = 3  # Puedes cambiar la paciencia para el entrenamiento temprano (early stopping)\n    factor = 0.2  # Puedes ajustar el factor para la reducción de la tasa de aprendizaje\n    min_lr = 1e-5  # Puedes establecer el valor mínimo para la tasa de aprendizaje\n    '''    \n\n    \n    # HIPERPARÁMETROS\n    random_state=42\n    porcentaje = 0.4 #porcentaje de la base de datos que se va a utilizar\n    class_prop = 0.90 #divivion de dataframe en train y validacion \n    epochs=10\n    SEED = 500  \n    BATCH_SIZE = 450  \n    TARGET_SIZE = (300, 300)\n    brightness_range = [0.8, 1.2]  \n    learning_rate = 1e-1  \n    top_dropout_rate = 0.3  \n    patience = 1  \n    factor = 0.2  \n    min_lr = 1e-4  \n\n    \n    train_original = create_dataframe(train_csv, mt)    \n    percentage_df = create_dataframe_with_percentage(train_csv, mt, porcentaje)   \n    remaining_df  = analyze_and_remove_zero_sum_images(percentage_df, mt) \n    train_df, val_df = split_train_val_data(remaining_df, class_prop, random_state)     \n    test_df = get_test_dataframe(mt, porcentaje)\n    train_g, val_g, test_g = get_data_generators(train_df, val_df, test_df, brightness_range)\n    \n    \n    #best_model, history = train_model(mt, train_g, val_g, epochs=20)\n    # Define las variables patience, factor y min_lr fuera de la función\n \n    # Llama a la función train_model y pasa estas variables como argumentos si es necesario\n    #best_model, history = train_model(mt, train_g, val_g, epochs=epochs, patience=patience, factor=factor, min_lr=min_lr)\n    best_model, history = train_model(mt, train_g, val_g, epochs, patience, factor, min_lr)\n  \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   \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":{"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":{"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,"trusted":true},"execution_count":null,"outputs":[]}],"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"}}