{"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":"# Libreria","metadata":{}},{"cell_type":"code","source":"# Importaciones generales\nimport math\nimport os\nimport random\nimport cv2\nimport numpy as np\nimport pandas as pd\nimport tensorflow as tf\nimport pydicom\nfrom IPython.display import display, FileLink\nimport pydicom\nimport cv2\nimport numpy as np\n# Importaciones de TensorFlow y Keras\nimport tensorflow_hub as tfhub\nfrom kaggle_datasets import KaggleDatasets\nfrom tensorflow.keras import Model\nfrom tensorflow.keras.applications import EfficientNetB3, DenseNet121\nfrom tensorflow.keras.callbacks import EarlyStopping, LearningRateScheduler, ModelCheckpoint, ReduceLROnPlateau\nfrom tensorflow.keras.layers import (BatchNormalization, Conv2D, Dense, Dropout, Flatten, GlobalAveragePooling2D, InputLayer, MaxPooling2D)\nfrom tensorflow.keras.metrics import AUC, Recall, Precision\nfrom tensorflow.keras.optimizers import RMSprop, Adam\nfrom tensorflow.keras.preprocessing.image import ImageDataGenerator\nfrom tensorflow.keras.layers import GlobalAveragePooling2D\nimport time\nimport os\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pydicom\nimport os\n# Importaciones de scikit-learn\nfrom sklearn.metrics import f1_score, matthews_corrcoef, brier_score_loss\nfrom sklearn.model_selection import train_test_split\nimport pydicom\nimport cv2\nimport numpy as np\nimport tensorflow as tf\nfrom sklearn.utils import shuffle\nfrom sklearn.model_selection import train_test_split\nimport tensorflow as tf\nfrom tensorflow.keras.applications import DenseNet121\nfrom tensorflow import keras\nfrom tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping, ReduceLROnPlateau\nfrom tensorflow.keras.optimizers import Adam\nfrom tensorflow.keras.losses import BinaryCrossentropy\n\nimport tensorflow as tf\nfrom tensorflow import keras\nfrom tensorflow.keras import layers\nfrom tensorflow.keras.optimizers import Adam\nfrom tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping\nfrom tensorflow.keras.layers import MultiHeadAttention\nfrom tensorflow.keras.callbacks import LearningRateScheduler\nfrom tensorflow.keras.regularizers import l1\nfrom tensorflow.keras.regularizers import l2\n\n# Si necesitas trabajar exclusivamente con TensorFlow, esta es la versión revisada del código sin importaciones innecesarias de PyTorch o Torch:\nif tf.test.is_gpu_available():\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-11-02T15:42:00.742581Z","iopub.execute_input":"2023-11-02T15:42:00.743299Z","iopub.status.idle":"2023-11-02T15:42:00.764729Z","shell.execute_reply.started":"2023-11-02T15:42:00.743263Z","shell.execute_reply":"2023-11-02T15:42:00.763627Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"base_datos = '/kaggle/input/rsna-miccai-brain-tumor-radiogenomic-classification/'\ndef cargar_datos(base_datos):\n    # Listar los archivos y directorios en la ruta de la base de datos\n    archivos = os.listdir(base_datos)\n    \n    # Establecer las rutas para los conjuntos de datos de entrenamiento y prueba\n    train = os.path.join(base_datos, 'train')\n    test = os.path.join(base_datos, 'test')\n    \n    # Leer los archivos CSV para los conjuntos de datos de entrenamiento y prueba utilizando la biblioteca pandas\n    train_csv = pd.read_csv(os.path.join(base_datos, 'train_labels.csv'))\n    test_csv = pd.read_csv(os.path.join(base_datos, 'sample_submission.csv'))\n    \n    train_csv['MGMT_value'] = train_csv['MGMT_value'].astype(int)\n    test_csv['MGMT_value'] = test_csv['MGMT_value'].astype(int)\n    \n    # Imprimir las primeras 10 filas de los DataFrames de entrenamiento y prueba\n    print('\\033[1;32;48;5;82m' + '\\033[1m' + '--------------TRAIN--------------' + '\\033[0m')\n    display(train_csv.head(10))\n    print('\\033[1;32;48;5;82m' + '\\033[1m' + '--------------TEST--------------' + '\\033[0m')\n    display(test_csv.head(10))\n    return train_csv, test_csv\ntrain_csv, test_csv = cargar_datos(base_datos)","metadata":{"execution":{"iopub.status.busy":"2023-11-02T15:42:00.766347Z","iopub.execute_input":"2023-11-02T15:42:00.766663Z","iopub.status.idle":"2023-11-02T15:42:00.803301Z","shell.execute_reply.started":"2023-11-02T15:42:00.766624Z","shell.execute_reply":"2023-11-02T15:42:00.802166Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Pacientes TRAIN & TEST","metadata":{}},{"cell_type":"code","source":"def 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\n# Convertir 'BraTS21ID', 'MGMT_value' y 'BraTS21ID_full' a valores numéricos\ntrain_csv['BraTS21ID'] = train_csv['BraTS21ID'].astype(int)\ntrain_csv['MGMT_value'] = train_csv['MGMT_value'].astype(int)\ntrain_csv['BraTS21ID_full'] = train_csv['BraTS21ID_full'].astype(int)\n\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\n# Repite lo mismo para el DataFrame de prueba si es necesario\ntest_csv['BraTS21ID'] = test_csv['BraTS21ID'].astype(int)\ntest_csv['MGMT_value'] = test_csv['MGMT_value'].astype(int)\ntest_csv['BraTS21ID_full'] = test_csv['BraTS21ID_full'].astype(int)\n\nprint('\\033[1;32;48;5;82m' + '\\033[1m' + '                                                     TEST                                                        ' + '\\033[0m')\ndisplay(test_csv)","metadata":{"execution":{"iopub.status.busy":"2023-11-02T15:42:00.805390Z","iopub.execute_input":"2023-11-02T15:42:00.805737Z","iopub.status.idle":"2023-11-02T15:42:00.855368Z","shell.execute_reply.started":"2023-11-02T15:42:00.805697Z","shell.execute_reply":"2023-11-02T15:42:00.854401Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"mt = 'flair'\ndef 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        # Calcular el número de imagen central\n        mid_point = len(img_files) // 2\n\n        # Obtener las rutas completas de las 21 imágenes (10 antes, la central y 10 después)\n        img_paths = []\n        for i in range(mid_point - 5, mid_point + 6):\n            if 0 <= i < len(img_files):\n                img_name = img_files[i]\n                img_path = os.path.join(img_dir, img_name)\n                img_paths.append(img_path)\n\n        # Agregar las rutas de las imágenes, etiquetas e IDs de paciente a las listas correspondientes\n        all_img_files.extend(img_paths)\n        all_img_labels.extend([row['MGMT_value']] * len(img_paths))\n        all_img_patient_ids.extend([row['BraTS21ID_full']] * len(img_paths))\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    train_original['labels'] = train_original['labels'].map({1: '1', 0: '0'})\n    return train_original\ntrain_original = create_dataframe(train_csv, mt)\ntest_original = create_dataframe(test_csv, mt)\n\ntrain_original['labels'] = train_original['labels'].astype(int)\ntest_original['labels'] = test_original['labels'].astype(int)\n\ndef analyze_and_remove_zero_sum_images(train_original, mt):\n    # Carpeta predeterminada donde se encuentran los archivos CSV\n    dataset_dir = '/kaggle/input/datos-negros/'\n    # Validar que mt sea una de las secuencias de IRM válidas\n    valid_mt_values = ['flair', 't1w', 't2w', 't1wce']\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    # Cargar el DataFrame del archivo CSV\n    df = pd.read_csv(csv_path)\n    # Obtener una lista de las URLs de imágenes en la columna correspondiente a mt\n    mt_urls = df['file_paths'].tolist()\n    # Filtrar las filas de train_val_df_all que no contienen las URLs en mt_urls\n    remaining_df = train_original[~train_original['file_paths'].isin(mt_urls)]\n   # Mostrar estadísticas\n    removed_count = len(train_original) - len(remaining_df)\n    remaining_count = len(remaining_df)\n    pd.set_option('display.max_colwidth', None)\n    print('\\033[1;32;48;5;82m' + '\\033[1m' + '                 Data                      ' + '\\033[0m')\n    display(remaining_df)\n    return remaining_df\nremaining_df = analyze_and_remove_zero_sum_images(train_original, mt)\nremaining_df_test = analyze_and_remove_zero_sum_images(test_original, mt)","metadata":{"execution":{"iopub.status.busy":"2023-11-02T15:42:00.857197Z","iopub.execute_input":"2023-11-02T15:42:00.857468Z","iopub.status.idle":"2023-11-02T15:42:01.534306Z","shell.execute_reply.started":"2023-11-02T15:42:00.857444Z","shell.execute_reply":"2023-11-02T15:42:01.533324Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Catidad Imagenes y tamaño","metadata":{}},{"cell_type":"code","source":"# Crear un DataFrame que contiene el número de paciente y la cantidad de imágenes en remaining_df\npatient_image_counts_df = remaining_df['patient_ids'].value_counts().reset_index()\npatient_image_counts_df.columns = ['Patient_ID', 'Image_Count']\n\n# Crear un DataFrame que contiene el número de paciente y la cantidad de imágenes en remaining_df_test\npatient_image_counts_df_test = remaining_df_test['patient_ids'].value_counts().reset_index()\npatient_image_counts_df_test.columns = ['Patient_ID', 'Image_Count']\n\n# Visualizar los DataFrames\nprint(\"Dataframe de pacientes e imágenes en remaining_df:\")\n#pd.set_option('display.max_rows', None)\nprint(patient_image_counts_df)\n\nprint(\"Dataframe de pacientes e imágenes en remaining_df_test:\")\n#pd.set_option('display.max_rows', None)\nprint(patient_image_counts_df_test)\npd.reset_option('display.max_rows')\n\nimport matplotlib.pyplot as plt\n\n# Suponiendo que tienes DataFrames patient_image_counts_df y patient_image_counts_df_test\n\n# Crear un subplot con dos filas y dos columnas\nfig, axs = plt.subplots(2, 2, figsize=(15, 10))\n\n# Histograma para remaining_df (fila superior, primera columna)\naxs[1, 0].hist(patient_image_counts_df['Image_Count'], bins=20, edgecolor='k')\naxs[1, 0].set_title('Histograma de la cantidad de imágenes por paciente en remaining_df')\naxs[1, 0].set_xlabel('Cantidad de imágenes')\naxs[1, 0].set_ylabel('Número de pacientes')\n\n# Histograma para remaining_df_test (fila superior, segunda columna)\naxs[1, 1].hist(patient_image_counts_df_test['Image_Count'], bins=20, edgecolor='k')\naxs[1, 1].set_title('Histograma de la cantidad de imágenes por paciente en remaining_df_test')\naxs[1, 1].set_xlabel('Cantidad de imágenes')\naxs[1, 1].set_ylabel('Número de pacientes')\n\n# Gráfico de barras para remaining_df (fila inferior, primera columna)\naxs[0, 0].bar(patient_image_counts_df['Patient_ID'], patient_image_counts_df['Image_Count'])\naxs[0, 0].set_title('Cantidad de imágenes por paciente en remaining_df')\naxs[0, 0].set_xlabel('ID del paciente')\naxs[0, 0].set_ylabel('Cantidad de imágenes')\naxs[0, 0].tick_params(axis='x', rotation=90)  # Rotar las etiquetas del eje x\n\n# Gráfico de barras para remaining_df_test (fila inferior, segunda columna)\naxs[0, 1].bar(patient_image_counts_df_test['Patient_ID'], patient_image_counts_df_test['Image_Count'])\naxs[0, 1].set_title('Cantidad de imágenes por paciente en remaining_df_test')\naxs[0, 1].set_xlabel('ID del paciente')\naxs[0, 1].set_ylabel('Cantidad de imágenes')\naxs[0, 1].tick_params(axis='x', rotation=90)  # Rotar las etiquetas del eje x\n\n# Ajustar la disposición de los gráficos\nplt.tight_layout()\n\n# Mostrar el subplot\nplt.show()\n\n\nimport pandas as pd\nimport pydicom\nimport matplotlib.pyplot as plt\n\ndef create_dimension_histogram(data_frame, title):\n    # Definir una función para obtener las dimensiones de las imágenes\n    def get_image_dimensions(file_path):\n        try:\n            dcm = pydicom.dcmread(file_path)\n            return f\"{dcm.Rows}x{dcm.Columns}\"\n        except Exception as e:\n            print(f\"Error al leer {file_path}: {str(e)}\")\n            return None\n\n    # Aplicar la función para obtener las dimensiones y crear una nueva columna en el DataFrame\n    data_frame['Image_Dimensions'] = data_frame['file_paths'].apply(get_image_dimensions)\n\n    # Eliminar filas con dimensiones nulas (si es necesario)\n    data_frame = data_frame.dropna(subset=['Image_Dimensions'])\n\n    # Crear un DataFrame con las dimensiones y sus frecuencias\n    dimension_counts = data_frame['Image_Dimensions'].value_counts().reset_index()\n    dimension_counts.columns = ['Dimensions', 'Frequency']\n\n    # Ordenar el DataFrame por dimensiones (opcional)\n    dimension_counts = dimension_counts.sort_values(by='Dimensions')\n\n    # Crear el histograma\n    plt.figure(figsize=(12, 6))\n    plt.bar(dimension_counts['Dimensions'], dimension_counts['Frequency'])\n    plt.title(title)\n    plt.xlabel('Dimensiones (Rows x Columns)')\n    plt.ylabel('Frecuencia')\n    plt.xticks(rotation=45)\n    plt.show()\n\n# Llama a la función para crear el histograma para remaining_df\ncreate_dimension_histogram(remaining_df, 'Histograma de Dimensiones en remaining_df')\n\n# Llama a la función para crear el histograma para remaining_df_test\ncreate_dimension_histogram(remaining_df_test, 'Histograma de Dimensiones en remaining_df_test')\n","metadata":{"execution":{"iopub.status.busy":"2023-11-02T15:42:01.536319Z","iopub.execute_input":"2023-11-02T15:42:01.536626Z","iopub.status.idle":"2023-11-02T15:42:32.845674Z","shell.execute_reply.started":"2023-11-02T15:42:01.536600Z","shell.execute_reply":"2023-11-02T15:42:32.844606Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"'''\ndef resize_dicom_images(dicom_paths, target_size=(512, 512)): ########################################## PADING O INTERPOLACION \n    resized_images = []\n    for dicom_path in dicom_paths:\n        ds = pydicom.dcmread(dicom_path)\n        image_array = ds.pixel_array\n        resized_image = cv2.resize(image_array, target_size)\n        resized_images.append(resized_image)\n    return resized_images\n\nimport pydicom\nimport cv2\nimport numpy as np\n\ndef resize_dicom_images(dicom_paths, target_size=(512, 512)):\n    resized_normalized_images = []\n    for dicom_path in dicom_paths:\n        ds = pydicom.dcmread(dicom_path)\n        image_array = ds.pixel_array\n        # Resize the image\n        resized_image = cv2.resize(image_array, target_size)\n        # Normalize the 16-bit image to [0, 1]\n        normalized_image = resized_image / 65535.0\n        resized_normalized_images.append(normalized_image)\n    return resized_normalized_images\n'''\n\n\ndef resize_dicom_images(dicom_paths, target_size=(512, 512)):\n    normalized_images = []\n    for dicom_path in dicom_paths:\n        ds = pydicom.dcmread(dicom_path)\n        image_array = ds.pixel_array\n        # No se realiza redimensión en este caso\n        # Normalize the 16-bit image to [0, 1]\n        normalized_image = image_array / 65535.0\n        normalized_images.append(normalized_image)\n    return normalized_images\n\n\n# Extraer los píxeles con información (no negros)\ndef extract_info_pixels(images):\n    info_pixels = []\n    for image in images:\n        # Encuentra los píxeles no negros (mayores que 0)\n        non_zero_pixels = np.count_nonzero(image)\n        info_pixels.append(non_zero_pixels)\n    return info_pixels\ndef procesar_dicom_df(remaining_df):\n    # Redimensionar las imágenes DICOM\n    resized_images = resize_dicom_images(remaining_df['file_paths'])\n    # Extraer los píxeles con información y agregarlos como una nueva columna en el DataFrame\n    info_pixels = extract_info_pixels(resized_images)\n    #create_histogram(info_pixels)\n       \n    #remaining_df['info_pixels'] = info_pixels\n    remaining_df.loc[:, 'info_pixels'] = info_pixels\n    \n    print('\\033[1;32;48;5;82m' + '\\033[1m' + '                                                     pixeles                                                        ' + '\\033[0m')\n    display(remaining_df)\n    return remaining_df\n\nremaining_df =procesar_dicom_df(remaining_df)\n'''\nremaining_df_test =procesar_dicom_df(remaining_df_test)\n'''","metadata":{"execution":{"iopub.status.busy":"2023-11-02T15:42:32.847161Z","iopub.execute_input":"2023-11-02T15:42:32.847458Z","iopub.status.idle":"2023-11-02T15:42:51.395688Z","shell.execute_reply.started":"2023-11-02T15:42:32.847433Z","shell.execute_reply":"2023-11-02T15:42:51.394617Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# CUBO","metadata":{}},{"cell_type":"code","source":"import pandas as pd\n\npilas_imagenes = 5\n\n# Seleccionar las # imágenes de cada paciente con la mayor cantidad de información de píxeles en remaining_df\nfiltered_df = remaining_df.groupby('patient_ids', group_keys=False).apply(lambda group: group.nlargest(pilas_imagenes, 'info_pixels')).reset_index(drop=True)\nprint('\\033[1;32;48;5;82m' + '\\033[1m' + '                                                     Imagenes para cubo TRAIN                                                      ' + '\\033[0m')\ndisplay(filtered_df)\n\ne=30\n\n'''\n# Seleccionar las 5 imágenes de cada paciente con la mayor cantidad de información de píxeles en remaining_df_test\nfiltered_df_test = remaining_df_test.groupby('patient_ids', group_keys=False).apply(lambda group: group.nlargest(11, 'info_pixels')).reset_index(drop=True)\nprint('\\033[1;32;48;5;82m' + '\\033[1m' + '                                                     Imagenes para cubo TEST                                                        ' + '\\033[0m')\ndisplay(filtered_df_test)\n\n'''","metadata":{"execution":{"iopub.status.busy":"2023-11-02T15:42:51.397201Z","iopub.execute_input":"2023-11-02T15:42:51.397509Z","iopub.status.idle":"2023-11-02T15:42:52.420787Z","shell.execute_reply.started":"2023-11-02T15:42:51.397482Z","shell.execute_reply":"2023-11-02T15:42:52.419754Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import numpy as np\n# Función para cargar una imagen DICOM desde su URL y obtener su matriz de píxeles\ndef load_dicom_image(url):\n    ds = pydicom.dcmread(url)\n    image_data = ds.pixel_array\n    return image_data\n\n\nimport numpy as np\n\ndef process_dataframe(df, pilas_imagenes=pilas_imagenes):\n    # Inicializar listas para almacenar tensores de imágenes y etiquetas\n    image_tensors = []\n    labels = []\n\n    # Iterar a través del DataFrame para crear tensores de imágenes y etiquetas\n    for patient_id, group in df.groupby('patient_ids'):\n        image_urls = group['file_paths'].tolist()  # Obtener la lista de URL de imágenes en el orden original\n        selected_image_urls = image_urls[:pilas_imagenes]  # Seleccionar las primeras pilas_imagenes imágenes\n\n        # Extraer imágenes\n        patient_images = [load_dicom_image(url) for url in selected_image_urls]\n        \n        # Cantidad de imágenes que faltan para completar pilas_imagenes\n        images_needed = pilas_imagenes - len(selected_image_urls)\n        \n        # Completar con imágenes en negro o matrices de ceros si es necesario\n        if images_needed > 0:\n            padding_images = [np.zeros_like(patient_images[0])] * images_needed\n            patient_images += padding_images\n        \n        stacked_images = np.stack(patient_images, axis=-1)  # Apilar imágenes en el último eje\n        image_tensors.append(stacked_images)\n        labels.append(group['labels'].values[0])  # Tomar la etiqueta del paciente (asumiendo que es la misma para todas las imágenes)\n\n    # Convertir las listas en matrices NumPy\n    image_tensors = np.array(image_tensors)\n    labels = np.array(labels)\n\n    return image_tensors, labels\n\n# Procesar el dataframe 'filtered_df' y almacenar los resultados en 'image_tensors' y 'labels'\nimage_tensors, labels = process_dataframe(filtered_df)\n\n# Comprobar las dimensiones de los tensores y etiquetas\nprint(\"Dimensiones de image_tensors:\", image_tensors.shape)\nprint(\"Dimensiones de labels:\", labels.shape)\n\n\n\n\n'''\n# Procesar el dataframe 'filtered_df_test' y almacenar los resultados en 'image_tensors_test' y 'labels_test'\nimage_tensors_test, labels_test = process_dataframe(filtered_df_test)\nprint(\"Dimensiones de image_tensors_test:\", image_tensors_test.shape)\nprint(\"Dimensiones de labels_test:\", labels_test.shape)\n\n'''","metadata":{"execution":{"iopub.status.busy":"2023-11-02T15:42:52.422238Z","iopub.execute_input":"2023-11-02T15:42:52.422623Z","iopub.status.idle":"2023-11-02T15:42:59.128014Z","shell.execute_reply.started":"2023-11-02T15:42:52.422585Z","shell.execute_reply":"2023-11-02T15:42:59.126983Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\nimport cv2\nimport numpy as np\n\n# Función para redimensionar las imágenes en un conjunto de datos y retornar los tensores resultantes\ndef resize_images(image_tensors):\n    resized_cubes = []\n\n    for cube in image_tensors:\n        resized_images = []\n\n        for i in range(pilas_imagenes):\n            resized_image = cv2.resize(cube[:, :, i], (512, 512))\n            resized_images.append(resized_image)\n\n        resized_cube = np.stack(resized_images, axis=-1)\n        resized_cubes.append(resized_cube)\n\n    resized_image_tensors = np.array(resized_cubes)\n\n    return resized_image_tensors\n\n# Redimensionar las imágenes en 'image_tensors'\nresized_image_tensors = resize_images(image_tensors)\n\n\n\n# Verificar las dimensiones de las matrices redimensionadas\nprint(\"Dimensiones de resized_image_tensors:\", resized_image_tensors.shape)\n\n\n'''\n# Redimensionar las imágenes en 'image_tensors_test'\nX_test = resize_images(image_tensors_test)\nprint(\"Dimensiones de resized_image_tensors_test:\", X_test.shape)\n'''","metadata":{"execution":{"iopub.status.busy":"2023-11-02T15:42:59.129438Z","iopub.execute_input":"2023-11-02T15:42:59.129750Z","iopub.status.idle":"2023-11-02T15:43:00.770647Z","shell.execute_reply.started":"2023-11-02T15:42:59.129724Z","shell.execute_reply":"2023-11-02T15:43:00.769691Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from sklearn.model_selection import train_test_split\n\n# Dividir los datos en conjuntos de entrenamiento (90%) y validación (10%)\n#X_train, X_val, y_train, y_val = train_test_split(resized_image_tensors, labels, test_size=0.1, random_state=42)\nX_train, X_val, y_train, y_val = train_test_split(resized_image_tensors, labels, test_size=0.1, random_state=42)\n\n# Verificar las dimensiones de los conjuntos de entrenamiento y validación\nprint(\"Dimensiones de X_train:\", X_train.shape)\nprint(\"Dimensiones de X_val:\", X_val.shape)\nprint(\"Dimensiones de y_train:\", y_train.shape)\nprint(\"Dimensiones de y_val:\", y_val.shape)\n\n\n\n'''\nprint(\"Dimensiones de Test:\", X_test.shape)\nprint(\"Dimensiones de Test labels:\", labels_test.shape)\n'''","metadata":{"execution":{"iopub.status.busy":"2023-11-02T15:43:00.773595Z","iopub.execute_input":"2023-11-02T15:43:00.773941Z","iopub.status.idle":"2023-11-02T15:43:01.695895Z","shell.execute_reply.started":"2023-11-02T15:43:00.773902Z","shell.execute_reply":"2023-11-02T15:43:01.694956Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n\ndef plot_metrics(history):\n    # Obtener las métricas de entrenamiento\n    training_accuracy = history.history['accuracy']\n    training_loss = history.history['loss']\n\n    # Obtener las métricas de validación\n    validation_accuracy = history.history['val_accuracy']\n    validation_loss = history.history['val_loss']\n   \n    # Crear gráficos\n    plt.figure(figsize=(12, 4))\n    plt.subplot(1, 2, 1)\n    plt.plot(training_accuracy, label='Training Accuracy')\n    plt.plot(validation_accuracy, label='Validation Accuracy')\n    plt.legend()\n    plt.title('Accuracy')\n\n    plt.subplot(1, 2, 2)\n    plt.plot(training_loss, label='Training Loss')\n    plt.plot(validation_loss, label='Validation Loss')\n    plt.legend()\n    plt.title('Loss')\n\n    plt.show()# Obtener las métricas de entrenamiento\nX_train, y_train = np.concatenate((X_train[:-e], X_val[:e])), np.concatenate((y_train[:-e], y_val[:e]))\n\ndef dynamic_learning_rate(epoch, lr):\n    if 1 <= epoch <= 20:\n        return 1e-5  \n    elif 20 <= epoch <= 30:\n        return 1e-6  \n    elif 30 <= epoch <= 40:\n        return 1e-7  \n    else:\n        return 1e-5  ","metadata":{"execution":{"iopub.status.busy":"2023-11-02T15:43:01.697117Z","iopub.execute_input":"2023-11-02T15:43:01.697425Z","iopub.status.idle":"2023-11-02T15:43:02.694491Z","shell.execute_reply.started":"2023-11-02T15:43:01.697397Z","shell.execute_reply":"2023-11-02T15:43:02.693005Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Entrenamiento","metadata":{}},{"cell_type":"markdown","source":"![](https://i.ibb.co/BP1f6FM/Captura-de-pantalla-2023-11-02-101543.png)","metadata":{}},{"cell_type":"markdown","source":"# Modelo (Conv + funcion activacion + Maxpooling)","metadata":{}},{"cell_type":"code","source":"from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Input\nfrom tensorflow.keras import Model\nfrom tensorflow.keras.models import load_model\nimport numpy as np\n\n# Lista de configuraciones de capas\nlayer_configs = [[8], [8, 16], [8, 16, 32], [8, 16, 32, 64], [8, 16, 32, 64, 128]]\n\nbest_models = []  # Lista para almacenar los mejores modelos\nbest_accuracies = []  # Lista para almacenar las precisiones de los mejores modelos\n\n# Capa de entrada\ninput_layer = Input(shape=(512, 512, pilas_imagenes))\n\nfor config in layer_configs:\n    x = input_layer  # Inicializa la variable 'x' con la capa de entrada actual\n    \n    # Agrega las capas de convolución y max-pooling\n    for num_filters in config:\n        x = Conv2D(num_filters, (3, 3), activation='relu')(x)\n        x = MaxPooling2D((2, 2))(x)\n    \n    x = Flatten()(x)\n    x = Dense(128, activation='relu')(x)\n    x = Dense(1, activation='sigmoid')(x)\n\n    # Crea el modelo para la configuración actual\n    model = Model(inputs=input_layer, outputs=x)\n    \n    learning_rate = 1e-5\n    custom_optimizer = Adam(learning_rate=learning_rate)\n\n    # Compila el modelo\n    model.compile(optimizer=custom_optimizer,\n                  loss='binary_crossentropy',\n                  metrics=['accuracy'])\n    \n    lr_scheduler = LearningRateScheduler(dynamic_learning_rate)\n    # Definir un callback para guardar el mejor modelo en función de val_accuracy\n    model_checkpoint = ModelCheckpoint('best_model.h5', save_best_only=True, monitor='val_accuracy', mode='max', verbose=1)\n\n    # Definir un callback para early stopping en función de val_accuracy\n    early_stopping = EarlyStopping(monitor='val_accuracy', patience=50, verbose=1)\n    # Entrena el modelo\n    history = model.fit(X_train, y_train, batch_size=32, epochs=35,\n                        validation_data=(X_val, y_val),\n                        callbacks=[lr_scheduler, model_checkpoint, early_stopping])\n    plot_metrics(history)\n    \n    # Carga el mejor modelo y registra su precisión\n    best_model = load_model('best_model.h5')\n    val_accuracy = best_model.evaluate(X_val, y_val)[1]\n    best_accuracies.append(val_accuracy)\n    best_models.append(best_model)\n\n# Encuentra el índice del mejor modelo en función de la precisión en datos de validación\nbest_model_index = np.argmax(best_accuracies)\nbest_best_model = best_models[best_model_index]\nbest_best_model.save('best_best_model.h5')\n\n# Grafica las precisiones de los mejores modelos\nplt.plot(range(1, len(layer_configs) + 1), best_accuracies, marker='o')\nplt.xticks(range(1, len(layer_configs) + 1), [str(config) for config in layer_configs], rotation=45)\nplt.xlabel('Configuración de Capas')\nplt.ylabel('Mejor Precisión en Validación')\nplt.title('Mejores Modelos con Diferentes Configuraciones de Capas')\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2023-11-02T15:43:02.697563Z","iopub.execute_input":"2023-11-02T15:43:02.697987Z","iopub.status.idle":"2023-11-02T15:43:02.708125Z","shell.execute_reply.started":"2023-11-02T15:43:02.697901Z","shell.execute_reply":"2023-11-02T15:43:02.707076Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Modelo Residual","metadata":{}},{"cell_type":"code","source":"'''\nfrom tensorflow.keras.layers import Conv2D, Flatten, Dense, Input, Activation, Add\nfrom tensorflow.keras import Model\nfrom tensorflow.keras.models import load_model\nimport numpy as np\n\n# Lista de configuraciones de capas\nlayer_configs = [[8], [8, 16], [8, 16, 32], [8, 16, 32, 64], [8, 16, 32, 64, 128]]\n\nbest_models = []  # Lista para almacenar los mejores modelos\nbest_accuracies = []  # Lista para almacenar las precisiones de los mejores modelos\n\n# Capa de entrada\ninput_layer = Input(shape=(512, 512, pilas_imagenes))\n\nx = input_layer  # Inicializa la variable 'x' con la capa de entrada actual\n\nfor config in layer_configs:\n    # Agrega la base de arquitectura residual\n    for num_filters in config:\n        # Capa convolucional\n        x1 = Conv2D(num_filters, (3, 3), padding='same')(x)\n        x1 = Activation('relu')(x1)\n        \n        # Capa convolucional\n        x2 = Conv2D(num_filters, (3, 3), padding='same')(x1)\n        x2 = Activation('relu')(x2)\n        \n        # Conexión directa (skip connection)\n        x = Add()([x1, x2])\n    \n    x = Flatten()(x)\n    x = Dense(128, activation='relu')(x)\n    x = Dense(1, activation='sigmoid')(x)\n\n    # Crea el modelo para la configuración actual\n    model = Model(inputs=input_layer, outputs=x)\n    \n    learning_rate = 1e-5\n    custom_optimizer = Adam(learning_rate=learning_rate)\n\n    # Compila el modelo\n    model.compile(optimizer=custom_optimizer,\n                  loss='binary_crossentropy',\n                  metrics=['accuracy'])\n    \n    lr_scheduler = LearningRateScheduler(dynamic_learning_rate)\n    # Definir un callback para guardar el mejor modelo en función de val_accuracy\n    model_checkpoint = ModelCheckpoint('best_model.h5', save_best_only=True, monitor='val_accuracy', mode='max', verbose=1)\n\n    # Definir un callback para early stopping en función de val_accuracy\n    early_stopping = EarlyStopping(monitor='val_accuracy', patience=50, verbose=1)\n    # Entrena el modelo\n    history = model.fit(X_train, y_train, batch_size=32, epochs=5,\n                        validation_data=(X_val, y_val),\n                        callbacks=[lr_scheduler, model_checkpoint, early_stopping])\n    plot_metrics(history)\n    \n    # Carga el mejor modelo y registra su precisión\n    best_model = load_model('best_model.h5')\n    val_accuracy = best_model.evaluate(X_val, y_val)[1]\n    best_accuracies.append(val_accuracy)\n    best_models.append(best_model)\n\n# Encuentra el índice del mejor modelo en función de la precisión en datos de validación\nbest_model_index = np.argmax(best_accuracies)\nbest_best_model = best_models[best_model_index]\nbest_best_model.save('best_best_model.h5')\n\n# Grafica las precisiones de los mejores modelos\nplt.plot(range(1, len(layer_configs) + 1), best_accuracies, marker='o')\nplt.xticks(range(1, len(layer_configs) + 1), [str(config) for config in layer_configs], rotation=45)\nplt.xlabel('Configuración de Capas')\nplt.ylabel('Mejor Precisión en Validación')\nplt.title('Mejores Modelos con Diferentes Configuraciones de Capas')\nplt.show()\n'''","metadata":{"execution":{"iopub.status.busy":"2023-11-02T15:43:02.709857Z","iopub.execute_input":"2023-11-02T15:43:02.710328Z","iopub.status.idle":"2023-11-02T15:44:43.644288Z","shell.execute_reply.started":"2023-11-02T15:43:02.710293Z","shell.execute_reply":"2023-11-02T15:44:43.642813Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# VALIDACION","metadata":{}},{"cell_type":"code","source":"from sklearn.metrics import classification_report, accuracy_score, confusion_matrix, roc_auc_score, f1_score, precision_score, matthews_corrcoef\n\n\nbest_model = load_model('best_best_model.h5')\n\n# Evaluar el modelo en el conjunto de validación\nval_predictions = best_model.predict(X_val)\nval_predictions = (val_predictions > 0.5)  # Convertir las probabilidades en etiquetas binarias\n\n# Calcular la matriz de confusión y otras métricas\nconfusion = confusion_matrix(y_val, val_predictions)\naccuracy = accuracy_score(y_val, val_predictions)\nroc_auc = roc_auc_score(y_val, val_predictions)\nf1 = f1_score(y_val, val_predictions)\nprecision = precision_score(y_val, val_predictions)\nmcc = matthews_corrcoef(y_val, val_predictions)\n\nclassification_report_str = classification_report(y_val, val_predictions)\n\n# Imprimir la matriz de confusión y otras métricas\nprint(\"Matriz de Confusión:\\n\", confusion)\nprint(\"Exactitud (Accuracy):\", accuracy)\nprint(\"ROC AUC Score:\", roc_auc)\nprint(\"F1 Score:\", f1)\nprint(\"Precisión (Precision):\", precision)\nprint(\"MCC (Matthews Correlation Coefficient):\", mcc)\n\n","metadata":{"execution":{"iopub.status.busy":"2023-11-02T15:44:43.645344Z","iopub.status.idle":"2023-11-02T15:44:43.645723Z","shell.execute_reply.started":"2023-11-02T15:44:43.645534Z","shell.execute_reply":"2023-11-02T15:44:43.645551Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"![](https://i.ibb.co/YNh3rW9/Sin-t-tulo.png)","metadata":{}},{"cell_type":"markdown","source":"![](https://i.ibb.co/fq9cK9G/asdfasdf.png)","metadata":{}},{"cell_type":"markdown","source":"# TEST","metadata":{}},{"cell_type":"code","source":"\nremaining_df_test =procesar_dicom_df(remaining_df_test)\n\n\n# Seleccionar las 5 imágenes de cada paciente con la mayor cantidad de información de píxeles en remaining_df_test\nfiltered_df_test = remaining_df_test.groupby('patient_ids', group_keys=False).apply(lambda group: group.nlargest(11, 'info_pixels')).reset_index(drop=True)\nprint('\\033[1;32;48;5;82m' + '\\033[1m' + '                                                     Imagenes para cubo TEST                                                        ' + '\\033[0m')\ndisplay(filtered_df_test)\n\n\n\n# Procesar el dataframe 'filtered_df_test' y almacenar los resultados en 'image_tensors_test' y 'labels_test'\nimage_tensors_test, labels_test = process_dataframe(filtered_df_test)\nprint(\"Dimensiones de image_tensors_test:\", image_tensors_test.shape)\nprint(\"Dimensiones de labels_test:\", labels_test.shape)\n\n\n\n# Redimensionar las imágenes en 'image_tensors_test'\nX_test = resize_images(image_tensors_test)\nprint(\"Dimensiones de resized_image_tensors_test:\", X_test.shape)\n\n\nprint(\"Dimensiones de Test:\", X_test.shape)\nprint(\"Dimensiones de Test labels:\", labels_test.shape)\n\n\nprint(\"Dimensiones de Test:\", X_test.shape)\nprint(\"Dimensiones de Test labels:\", labels_test.shape)","metadata":{"execution":{"iopub.status.busy":"2023-11-02T15:44:43.647263Z","iopub.status.idle":"2023-11-02T15:44:43.647673Z","shell.execute_reply.started":"2023-11-02T15:44:43.647467Z","shell.execute_reply":"2023-11-02T15:44:43.647485Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# .csv para enviar a la competencia ","metadata":{}},{"cell_type":"code","source":"# Evaluar el modelo en el conjunto de prueba\ntest_predictions = model.predict(X_test)\ntest_predictions = np.round(test_predictions, 2)\nsubm = pd.read_csv('/kaggle/input/rsna-miccai-brain-tumor-radiogenomic-classification/sample_submission.csv')\n# Asegúrate de que las dimensiones coincidan\nassert len(subm) == len(test_predictions)\n# Reemplazar la columna \"MGMT_value\" con los valores de test_predictions\nsubm[\"MGMT_value\"] = test_predictions\nsubm.to_csv(\"submission.csv\", index=False)\nsubm","metadata":{"execution":{"iopub.status.busy":"2023-11-02T15:44:43.649133Z","iopub.status.idle":"2023-11-02T15:44:43.649551Z","shell.execute_reply.started":"2023-11-02T15:44:43.649360Z","shell.execute_reply":"2023-11-02T15:44:43.649382Z"},"trusted":true},"execution_count":null,"outputs":[]}]}