{"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.10.14","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"colab":{"provenance":[]},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":81933,"databundleVersionId":9643020,"sourceType":"competition"}],"dockerImageVersionId":30804,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# **Child Mind Institute — Problematic Internet Use**\n\nEn la era digital actual, el uso problemático de internet entre niños y adolescentes es una preocupación creciente. Comprender mejor este problema es crucial para abordar problemas de salud mental como la depresión y la ansiedad.\n\nLos métodos actuales para medir el uso problemático de internet en niños y adolescentes suelen ser complejos y requieren evaluaciones profesionales. Esto crea barreras de acceso, culturales y lingüísticas para muchas familias. Debido a estas limitaciones, el uso problemático de internet a menudo no se mide directamente, sino que se asocia con problemas como la depresión y la ansiedad en los jóvenes.\n\nPor el contrario, las mediciones de condición física son extremadamente accesibles y están ampliamente disponibles con una intervención mínima o sin necesidad de experiencia clínica. Los cambios en los hábitos físicos, como una peor postura, una dieta irregular y una actividad física reducida, son comunes en los usuarios excesivos de tecnología. Proponemos usar estos indicadores de condición física, que son fáciles de obtener, como proxies para identificar el uso problemático de internet, especialmente en contextos donde falta experiencia clínica o herramientas de evaluación adecuadas.\n\nEl objetivo es desarrollar un modelo predictivo capaz de analizar datos de actividad física de los niños para detectar indicadores tempranos de uso problemático de internet y tecnología. Esto permitirá intervenciones tempranas destinadas a promover hábitos digitales más saludables.","metadata":{"id":"ellXA7EFS0cU"}},{"cell_type":"markdown","source":"## Autores del Proyecto\n- **Amado Rosas**  \n- **Carlos Mancillas**  \n- **Benjamin Partida**  \n","metadata":{}},{"cell_type":"code","source":"# # Clone the repository to get data\n# !git clone https://github.com/amadorssa/ChildInternetUseAnalysis.git\n\n# !ls ChildInternetUseAnalysis/data/","metadata":{"id":"KOl4fHouIL6Z","trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import pandas as pd","metadata":{"id":"8ad9bbciPkGb","trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# train_df = pd.read_csv('ChildInternetUseAnalysis/data/train.csv')\n# test_df = pd.read_csv('ChildInternetUseAnalysis/data/test.csv')","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_df = pd.read_csv('/kaggle/input/child-mind-institute-problematic-internet-use/train.csv', index_col=0)\ntest_df = pd.read_csv('/kaggle/input/child-mind-institute-problematic-internet-use/test.csv', index_col=0)\ndictionary_df = pd.read_csv('/kaggle/input/child-mind-institute-problematic-internet-use/data_dictionary.csv')","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# train_df = pd.read_csv('data/train.csv', index_col=0)\n# test_df = pd.read_csv('data/test.csv', index_col=0)\n# dictionary_df = pd.read_csv('data/data_dictionary.csv')","metadata":{"id":"J4dwTQqzP5gt","trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"### 1. Análisis exploratorio sencillo de los datos (que datos tenemos, que tipo son los datos, si hay o no datos faltantes, si hay datos numéricos, que distribución tienen, y si hay cualitativos si son ordenados o no por ejemplo).\n","metadata":{"id":"Ofa7nuy6RnyT"}},{"cell_type":"markdown","source":"##### Analisis exploratorio de los datos","metadata":{}},{"cell_type":"code","source":"display(train_df.head())","metadata":{"id":"gSLdyTiqP9pI","trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Resumen general de los datos de entrenamiento\ntrain_df.info()\n","metadata":{"id":"okF-thplSxpM","trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"test_df.info()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"dictionary_df.info()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"##### Actualizar train_df con caracteristicas compartidas","metadata":{}},{"cell_type":"code","source":"print(train_df.shape)\nprint(test_df.shape)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"#WOLOLO\ntrain_df_objetivo = train_df['sii']\n\n# Actualziar train_df con caracterisitcas compartidas entre train_df y test_df\ntrain_df = train_df[test_df.columns]\n\n# Combinar train_df_objetivo con train_df\ntrain_df = pd.concat([train_df, train_df_objetivo], axis=1)\n\ndisplay(train_df.head())\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(train_df.shape)\nprint(test_df.shape)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Obtener una lista con las filas de la columna 'Field' de dictionary_df que que tienen str en la columna 'Type'\nstr_df = dictionary_df[dictionary_df['Type'] == 'str'][['Field', 'Values']]\n\ndisplay(str_df)\n\n# Crear un array con los valores únicos de la columna 'Values' de str_df\nstr_columns = str_df['Field']\n\n# Imprimir los valores únicos de la columna 'Value Labels' de str_df\nprint(str_df['Values'].unique())","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Eliminar la primera fila de str_df\nstr_df = str_df.drop(index=0)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Obtener una array con las filas de la columna 'Field' de dictionary_df que que tienen str en la columna 'Type'\ncategorical_df = dictionary_df[dictionary_df['Type'] == 'categorical int'][['Field', 'Value Labels']]\n\ndisplay(categorical_df)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"##### Manejar valores faltantes","metadata":{}},{"cell_type":"code","source":"# Eliminar filas con valores faltantes en la columna 'sii' de train_df\ntrain_df = train_df.dropna(subset=['sii'])","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Valores faltantes\nmissing_values = train_df.isnull().mean()*100\nmissing_values = missing_values[missing_values > 35]\n\n# Crear dataframe con los valores faltantes\nmissing_values_df = pd.DataFrame({'Variable': missing_values.index, 'Porcentaje': missing_values.values})\n\ndisplay(missing_values_df)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(train_df.shape)\nprint(test_df.shape)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Eliminar columnas con más del 35% de valores faltantes\ntrain_df = train_df.drop(columns=missing_values_df['Variable'])\ntest_df = test_df.drop(columns=missing_values_df['Variable'])","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(train_df.shape)\nprint(test_df.shape)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# # Valores faltantes\n# values = train_df.isnull().mean()*100\n# values = values[values < 35]\n# values = values[values > 10]\n\n# # Crear dataframe con los valores faltantes\n# values_df = pd.DataFrame({'Variable': values.index, 'Porcentaje': values.values})\n\n# display(values_df)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Eliminar filas con valoriables eliminadas en el paso anterior en los dataframes str_df y categorical_df\nstr_df = str_df[~str_df['Field'].isin(missing_values_df['Variable'])]\n\ncategorical_df = categorical_df[~categorical_df['Field'].isin(missing_values_df['Variable'])]","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"##### Codificación de variables categóricas","metadata":{}},{"cell_type":"code","source":"from sklearn.preprocessing import LabelEncoder","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# # WOLOLO\n# # Inicializar el codificador\n# label_encoder = LabelEncoder()\n\n# # Variables binarias\n# binary_columns = ['Basic_Demos-Sex', 'FGC-FGC_CU_Zone', 'FGC-FGC_PU_Zone', 'FGC-FGC_SRL_Zone', 'FGC-FGC_SRR_Zone', 'FGC-FGC_TL_Zone']\n\n# # Aplicar Label Encoding\n# for col in binary_columns:\n#     if col in train_df.columns:\n#         train_df[col] = label_encoder.fit_transform(train_df[col])\n# for col in binary_columns:\n#     if col in test_df.columns:\n#         test_df[col] = label_encoder.transform(test_df[col])\n\n# # Verificar las primeras filas\n# display(train_df[binary_columns].head())\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Aplicar one-hot encoding con las columnas de srt_df\nfor col in str_columns:\n    if col in train_df.columns:\n        train_df = pd.get_dummies(train_df, columns=[col])\n\nfor col in str_columns:\n    if col in test_df.columns:\n        test_df = pd.get_dummies(test_df, columns=[col])\n\ndisplay(train_df.head())\n\ndisplay(test_df.head())","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# # WOLOLO\n# multicategorical_columns = [\n#     'BIA-BIA_Activity_Level_num',\n#     'BIA-BIA_Frame_num', 'PCIAT-PCIAT_01', 'PCIAT-PCIAT_02', 'PCIAT-PCIAT_03',\n#     'PCIAT-PCIAT_04', 'PCIAT-PCIAT_05', 'PCIAT-PCIAT_06', 'PCIAT-PCIAT_07',\n#     'PCIAT-PCIAT_08', 'PCIAT-PCIAT_09', 'PCIAT-PCIAT_10', 'PCIAT-PCIAT_11',\n#     'PCIAT-PCIAT_12', 'PCIAT-PCIAT_13', 'PCIAT-PCIAT_14', 'PCIAT-PCIAT_15',\n#     'PCIAT-PCIAT_16', 'PCIAT-PCIAT_17', 'PCIAT-PCIAT_18', 'PCIAT-PCIAT_19',\n#     'PCIAT-PCIAT_20', 'PreInt_EduHx-computerinternet_hoursday']\n\n# # Aplicar One-Hot Encoding para las variables con más de dos categorías\n# for col in multicategorical_columns:\n#     if col in train_df.columns:\n#         train_df = pd.get_dummies(train_df, columns=[col], drop_first=True)\n    \n# for col in multicategorical_columns:\n#     if col in test_df.columns:\n#         test_df = pd.get_dummies(test_df, columns=[col], drop_first=True)\n\n# # Verificar las primeras filas después de One-Hot Encoding\n# display(train_df.head())\n\n# display(test_df.head())","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"##### Imputación de valores faltantes","metadata":{}},{"cell_type":"code","source":"# Identificar columnas numéricas\nnumeric_cols = train_df.select_dtypes(include=['float64', 'int64']).columns\nprint(\"\\nColumnas numéricas:\")\nprint(numeric_cols)\n\n# Identificar columnas categóricas\ncategorical_cols = train_df.select_dtypes(include=['object']).columns\nprint(\"\\nColumnas categóricas:\")\nprint(categorical_cols)\n\nprint(train_df.dtypes)\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Eliminar la columna 'sii' de las columnas numéricas\nnumeric_cols = numeric_cols.drop('sii')\n\n# Imputar valores faltantes numéricos con la media\nfor col in numeric_cols:\n    if col in train_df.columns:\n        train_df[col] = train_df[col].fillna(train_df[col].mean())\n    if col in test_df.columns:\n        test_df[col] = test_df[col].fillna(test_df[col].mean())","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(train_df[numeric_cols].isnull().sum())","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(train_df.shape)\nprint(test_df.shape)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport seaborn as sns","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Visualizar distribuciones de los datos numéricos\ntrain_df[numeric_cols].hist(figsize=(15,10), bins=30)\nplt.suptitle('Distribuciones de variables numéricas')\nplt.tight_layout()\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_df['sii'].hist(figsize=(15,10), bins=30)\nplt.suptitle('Distribucion de la variable objetivo sii')\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(train_df.shape)\nprint(test_df.shape)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"##### Análisis de correlación","metadata":{}},{"cell_type":"code","source":"from sklearn.feature_selection import VarianceThreshold","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Eliminar características con varianza por debajo de un umbral (ej. 0.01)\nselector = VarianceThreshold(threshold=0.01)\nselector.fit(train_df.drop('sii', axis=1))\nlow_variance_features = train_df.drop('sii', axis=1).columns[~selector.get_support()]\ntrain_df = train_df.drop(columns=low_variance_features)\nprint(f\"Características eliminadas por baja varianza: {low_variance_features.tolist()}\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Calcular la correlación de Pearson con SII\ncorrelation_matrix = train_df.corr()\n\nmatrix = correlation_matrix['sii'].sort_values(ascending=False)\n\ndisplay(correlation_matrix['sii'].sort_values(ascending=False))","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Calcular correlación con la variable objetivo\ncorrelation_with_target = correlation_matrix['sii'].drop('sii')\nlow_corr_threshold = 0.1\nlow_corr_features = correlation_with_target[abs(correlation_with_target) < low_corr_threshold].index.tolist()\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Visualizar la correlación con SII\nplt.figure(figsize=(10, 24))\nsns.heatmap(correlation_matrix[['sii']], annot=True, cmap='coolwarm', fmt='.2f')\nplt.title('Correlación de las características con SII')\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(train_df.shape)\nprint(test_df.shape)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# WOLOLO\n# Eliminar características con baja correlación\ntrain_df = train_df.drop(columns=low_corr_features)\nprint(f\"Características eliminadas por baja correlación con 'sii': {low_corr_features}\")\n\nfor col in low_corr_features:\n    if col in test_df.columns:\n        test_df = test_df.drop(columns=col)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(train_df.shape)\nprint(test_df.shape)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Encontrar pares de características altamente correlacionadas\nhigh_corr_threshold = 0.8\nhigh_corr_pairs = []\n\nfor i in range(len(correlation_matrix.columns)):\n    for j in range(i):\n        if abs(correlation_matrix.iloc[i, j]) > high_corr_threshold:\n            high_corr_pairs.append((correlation_matrix.columns[i], correlation_matrix.columns[j]))\n\nprint(f\"Pares de características con alta correlación (> {high_corr_threshold}):\")\n\nfor pair in high_corr_pairs:\n    print(f\"({pair[0]}, {pair[1]})\")\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"#### 2. Implementar un método de reagrupamiento, o visualización con PCA o t-SNE de los datos de entrenamiento, que permita ver si hay ciertos patrones claros.","metadata":{"id":"nwvHmcGmR652"}},{"cell_type":"code","source":"print(train_df.shape)\nprint(test_df.shape)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"##### Normalización de datos","metadata":{}},{"cell_type":"code","source":"from sklearn.preprocessing import StandardScaler\n\n# Inicializar el escalador\nscaler = StandardScaler()\n\n# Escalar los datos numéricos\nfor col in numeric_cols:\n    if col in train_df.columns:\n        train_df[col] = scaler.fit_transform(train_df[col].values.reshape(-1, 1))\n\nfor col in numeric_cols:\n    if col in test_df.columns:\n        test_df[col] = scaler.transform(test_df[col].values.reshape(-1, 1))","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"##### PCA","metadata":{}},{"cell_type":"code","source":"from sklearn.decomposition import PCA\nimport numpy as np","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Preparar datos de entrenamiento\nX_train = train_df.drop('sii', axis=1)\ny_train = train_df['sii']\n# X_test = test_df","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Aplicar PCA\nn_components = 10\npca = PCA(n_components=n_components, random_state=42)\nX_train_pca = pca.fit_transform(X_train)\n# X_test_pca = pca.transform(X_test)\n\n# Crear un DataFrame con los componentes principales\npca_df = pd.DataFrame(data=X_train_pca, columns=[f'PC{i}' for i in range(1, n_components+1)])\npca_df['SII'] = y_train.values","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Visualizar los resultados de PCA\nplt.figure(figsize=(10, 6))\nsns.scatterplot(x='PC1', y='PC2', data=pca_df, hue='SII', palette='coolwarm')\nplt.title('PCA: Componentes 1 y 2')\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# revisar la cantidad de varianza explicada por cada componente principal para entender qué tan bien representan los datos originales.\nexplained_variance_ratio = pca.explained_variance_ratio_\nvarianza_acumulada = np.cumsum(explained_variance_ratio)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Gráfica de varianza explicada acumulada\nplt.figure(figsize=(10, 6))\nplt.plot(range(1, len(varianza_acumulada) + 1), varianza_acumulada, marker='o', linestyle='--', color='b')\nplt.title('Varianza explicada acumulada por PCA')\nplt.xlabel('Número de Componentes Principales')\nplt.ylabel('Porcentaje de Varianza Explicada Acumulada')\nplt.grid()\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Imprimir varianza explicada por los primeros 10 componentes\nfor i, var in enumerate(explained_variance_ratio[:n_components], start=1):\n    print(f\"Varianza explicada por el Componente Principal {i}: {var:.2f}\")\nprint(f\"Varianza explicada acumulada por los 10 componentes: {varianza_acumulada[9]:.2f}\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"##### t-SNE","metadata":{}},{"cell_type":"code","source":"from sklearn.manifold import TSNE","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Reduccion a n_components\nn_components = 2\n\ntsne = TSNE(n_components=n_components, random_state=42)\nX_tsne = tsne.fit_transform(X_train)\n\ntsne_df = pd.DataFrame(data=X_tsne, columns=[f'Dim{i}' for i in range(1, n_components+1)])\ntsne_df['SII'] = y_train.values\n\n# Visualizar los resultados de t-SNE\nplt.figure(figsize=(10, 6))\nsns.scatterplot(x='Dim1', y='Dim2', data=tsne_df, hue='SII', palette='coolwarm')\nplt.title('t-SNE: Dimensiones 1 y 2')\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"### 3. Preprocesamiento de los datos, y su codificación para usarlos como entrada a un modelo. Hay que tener en cuenta que este preprocesamiento debe poder integrarse mediante pipelines al modelo final.","metadata":{"id":"GkSr6NPYSGsR"}},{"cell_type":"markdown","source":"##### Random Forest","metadata":{}},{"cell_type":"code","source":"from sklearn.ensemble import RandomForestClassifier\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import classification_report, accuracy_score","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Separar los datos en entrenamiento y validación para Random Forest\nX_train, X_val, y_train, y_val = train_test_split( X_train, y_train, test_size=0.2, random_state=42, stratify=y_train)\n\nprint(f\"Datos de entrenamiento: {X_train.shape}\")\nprint(f\"Datos de validación: {X_val.shape}\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Crear y entrenar el modelo de Random Forest (clasificación)\nrf = RandomForestClassifier(n_estimators=100, random_state=42, class_weight='balanced')\nrf.fit(X_train, y_train)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Obtener las importancias de las características\nimportances = rf.feature_importances_\nfeature_names = train_df.drop('sii', axis=1).columns\nfeature_importances = pd.DataFrame({'Feature': feature_names, 'Importance': importances})","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Obtener la importancia de las características\nimportances = rf.feature_importances_\nfeature_names = X_train.columns","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Ordenar las características por importancia\nfeature_importances = feature_importances.sort_values(by='Importance', ascending=False)\n\n# Seleccionar las características más importantes (por ejemplo, las que tienen importancia > 0.01)\nthreshold = 0.01  # Ajusta este valor según tus necesidades\nselected_features = feature_importances[feature_importances['Importance'] > threshold]['Feature'].values\nprint(f\"Número de características seleccionadas: {len(selected_features)}\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Mostrar las 20 características más importantes\nplt.figure(figsize=(12, 10))\nsns.barplot(x='Importance', y='Feature', data=feature_importances.head(13))\nplt.title('Importancia de Características según Random Forest')\nplt.xlabel('Importancia')\nplt.ylabel('Características')\nplt.tight_layout()\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(train_df.shape)\nprint(test_df.shape)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"### 4. Decidir si es un problema de clasificación o de regresión (ambos podrían aplicar) y justificar porqué.","metadata":{"id":"Ji7h0h3QSKcq"}},{"cell_type":"markdown","source":"Este problema puede abordarse tanto como un problema de clasificación y como una problema de regresión, dependiendo del enfoque que se quiera tomar.\nSi consideramos la variable objetivo `sii` (Severity Impairment Index) como categorías discretas ordenadas (0: ninguno, 1: leve, 2: moderado, 3: grave),\nla clasificación es más adecuada, ya que respeta la naturaleza categórica de los datos y permite predecir directamente las clases con modelos como\nRandom Forest o XGBoost, evitando valores intermedios no válidos. Sin embargo, también podría tratarse como un problema de regresión debido a que los valores\nson numéricos y tienen un orden. En este caso, modelos como regresión lineal, árboles de decisión para regresión, Random Forest Regressor,\nGradient Boosting Regressor (XGBoost, LightGBM) o redes neuronales podrían ser aplicados. Pero tenemos que tener en cuentas que las predicciones continuas\nrequerirían redondeo a los valores válidos (0, 1, 2, 3), lo que podría introducir errores adicionales. En general, la clasificación es preferible porque refleja\nmejor el significado de las clases, aunque la regresión podría ser útil en análisis específicos donde se busquen tendencias más continuas en la severidad.","metadata":{}},{"cell_type":"markdown","source":"### 5. Utilizar un modelo inicial simple que permita establecer un baseline del problema.","metadata":{"id":"4tmsRDOSSOMO"}},{"cell_type":"code","source":"# Usar las características seleccionadas\nX = train_df.drop('sii', axis=1)\ny = train_df['sii']\n\n# Usar las características seleccionadas con PCA\n# X = X_train_pca\n# y = train_df['sii']\n\n# Dividir los datos en conjunto de entrenamiento y prueba\nX_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n\nprint(f\"Datos de entrenamiento: {X_train.shape}\")\nprint(f\"Datos de validación: {X_val.shape}\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"##### Catboost","metadata":{}},{"cell_type":"code","source":"from catboost import CatBoostClassifier\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import classification_report, accuracy_score\n\n# Identificar las características categóricas para CatBoost\ncategorical_features = [\n    train_df.columns.get_loc(col) \n    for col in categorical_cols \n    if col in train_df.columns\n]\n\n# Crear y configurar el modelo de CatBoost\ncatboost_model = CatBoostClassifier(\n    iterations=1000,\n    learning_rate=0.02,\n    depth=4,\n    loss_function='MultiClass',\n    eval_metric='Accuracy',\n    verbose=100,\n    random_seed=42,\n)\n\n# Entrenar el modelo\ncatboost_model.fit(X_train, y_train, eval_set=(X_val, y_val), early_stopping_rounds=50)\n\n# Predecir en los datos de validación\ny_pred = catboost_model.predict(X_val)\n\n# Mostrar métricas de evaluación\nprint(\"Accuracy:\", accuracy_score(y_val, y_pred))\nprint(\"\\nClassification Report:\")\nprint(classification_report(y_val, y_pred))","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(\"Características del entrenamiento:\", catboost_model.feature_names_)\nprint(\"Características del conjunto de prueba:\", test_df.columns)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Realizar predicciones\ntest_predictions_cb = catboost_model.predict(test_df)\n\n# Convertir predicciones a un formato adecuado\ntest_predictions_cb = test_predictions_cb.flatten()\n\n# Crear un DataFrame con las predicciones y los IDs correspondientes\noutput_cb = pd.DataFrame({\n    'id': test_df.index,  # Usar el índice como ID\n    'sii_predicted': test_predictions_cb\n})","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"output_cb","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Guardar las predicciones en un archivo CSV\noutput_cb.to_csv('/kaggle/working/submission.csv', index=False)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"### 6. Usar algún método de búsqueda de hiperparámetros y seleccionar el modelo de aprendizaje que consideres más adecuado. Justificar la selección.","metadata":{"id":"Tp-uMsjqSToZ"}},{"cell_type":"code","source":"from sklearn.model_selection import RandomizedSearchCV\nfrom catboost import CatBoostClassifier\nimport numpy as np\n\n# Crear el modelo base\ncatboost_model = CatBoostClassifier(\n    random_seed=42,\n    verbose=0  # Silenciar el entrenamiento en cada iteración\n)\n\n# Espacio de búsqueda reducido para acelerar\nparam_distributions = {\n    'iterations': [100, 500],                # Menos valores de iteraciones\n    'learning_rate': [0.01, 0.1],            # Tasas de aprendizaje más comunes\n    'depth': [4, 6],                         # Profundidad limitada\n    'l2_leaf_reg': np.logspace(-2, 1, 3),    # Regularización limitada\n    'bagging_temperature': [0, 1],           # Menos combinaciones\n    'grow_policy': ['SymmetricTree']         # Política de crecimiento fija\n}\n\n# Configurar RandomizedSearchCV\nrandom_search = RandomizedSearchCV(\n    estimator=catboost_model,\n    param_distributions=param_distributions,\n    n_iter=10,             # Número reducido de iteraciones para acelerar\n    cv=3,                  # Validación cruzada con 3 folds para rapidez\n    scoring='accuracy',    # Métrica de evaluación\n    n_jobs=-1,             # Usar todos los núcleos disponibles\n    random_state=42,\n    verbose=1\n)\n\n# Entrenar el modelo con búsqueda de hiperparámetros\nrandom_search.fit(X_train, y_train)\n\n# Resultados\nprint(f\"Mejores hiperparámetros: {random_search.best_params_}\")\nprint(f\"Precisión del mejor modelo: {random_search.best_score_:.4f}\")\n\n# Usar el mejor modelo para realizar predicciones en el conjunto de validación\nbest_model = random_search.best_estimator_\ny_val_pred = best_model.predict(X_val)\n\n# Evaluar el modelo\nfrom sklearn.metrics import classification_report, accuracy_score, confusion_matrix\n\naccuracy = accuracy_score(y_val, y_val_pred)\nprint(f\"\\nPrecisión del modelo CatBoost optimizado: {accuracy:.4f}\")\n\nprint(\"\\nReporte de Clasificación:\")\nprint(classification_report(y_val, y_val_pred))\n\nprint(\"\\nMatriz de Confusión:\")\nprint(confusion_matrix(y_val, y_val_pred))","metadata":{"trusted":true,"execution":{"iopub.status.idle":"2024-12-04T13:36:17.056425Z","shell.execute_reply.started":"2024-12-04T13:36:00.306092Z","shell.execute_reply":"2024-12-04T13:36:17.055203Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"### 7. Revisar y mostrar la calidad del modelo retenido usando métodos (los que consideren mejor adaptados) como k-cross-fold-validation, curvas de aprendizaje, curvas RoC, matrices de confusión o métricas de entrenamiento y validación.\n","metadata":{"id":"j6V5IEeKSXkJ"}},{"cell_type":"code","source":"from sklearn.model_selection import cross_val_score, learning_curve\nfrom sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, roc_curve, auc\nfrom sklearn.preprocessing import label_binarize\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Evaluate the CatBoost model using k-Fold Cross-Validation\ncv_scores = cross_val_score(best_model, X_train, y_train, cv=3, scoring='accuracy')\n\n# Print cross-validation results\nprint(f\"Cross-validation scores: {cv_scores}\")\nprint(f\"Average accuracy (cross-validation): {np.mean(cv_scores):.4f}\")\n\n# Predictions on the validation set\ny_val_pred = best_model.predict(X_val)\n\n# Confusion Matrix\ncm = confusion_matrix(y_val, y_val_pred)\n\n# Get unique class labels\nclass_labels = sorted(y_train.unique())\n\n# Display confusion matrix with specific labels\nConfusionMatrixDisplay(confusion_matrix=cm, display_labels=class_labels).plot(cmap='Blues')\nplt.title(\"Confusion Matrix\")\nplt.show()\n\n# Binarize labels for ROC\ny_train_binarized = label_binarize(y_train, classes=class_labels)\ny_val_binarized = label_binarize(y_val, classes=class_labels)\n\n# Predict probabilities\ny_val_proba = best_model.predict_proba(X_val)\n\n# ROC curves for each class\nplt.figure(figsize=(10, 6))\nfor i, label in enumerate(class_labels):\n    fpr, tpr, _ = roc_curve(y_val_binarized[:, i], y_val_proba[:, i])\n    roc_auc = auc(fpr, tpr)\n    plt.plot(fpr, tpr, label=f'Class {label} (AUC = {roc_auc:.2f})')\n\n# Configure plot\nplt.plot([0, 1], [0, 1], 'k--')  # Baseline\nplt.title('ROC Curves for Each Class')\nplt.xlabel('False Positive Rate (FPR)')\nplt.ylabel('True Positive Rate (TPR)')\nplt.legend(loc='lower right')\nplt.grid()\nplt.show()\n\n# Learning curves calculation\ntrain_sizes, train_scores, val_scores = learning_curve(\n    best_model,\n    X_train,\n    y_train,\n    cv=3,\n    scoring='accuracy',\n    train_sizes=np.linspace(0.1, 1.0, 10)\n)\n\n# Averages and standard deviations\ntrain_mean = np.mean(train_scores, axis=1)\ntrain_std = np.std(train_scores, axis=1)\nval_mean = np.mean(val_scores, axis=1)\nval_std = np.std(val_scores, axis=1)\n\n# Plot learning curves\nplt.figure(figsize=(10, 6))\nplt.plot(train_sizes, train_mean, label='Training Accuracy')\nplt.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, alpha=0.1)\n\nplt.plot(train_sizes, val_mean, label='Validation Accuracy')\nplt.fill_between(train_sizes, val_mean - val_std, val_mean + val_std, alpha=0.1)\n\nplt.title('Learning Curves')\nplt.xlabel('Training Set Size')\nplt.ylabel('Accuracy')\nplt.legend()\nplt.grid()\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-04T13:36:17.058006Z","iopub.execute_input":"2024-12-04T13:36:17.058372Z","iopub.status.idle":"2024-12-04T13:36:23.40129Z","shell.execute_reply.started":"2024-12-04T13:36:17.058339Z","shell.execute_reply":"2024-12-04T13:36:23.400136Z"}},"outputs":[],"execution_count":null}]}