{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\nimport sklearn as sk\nimport seaborn as sns\nimport joblib\nfrom sklearn.decomposition import PCA\nfrom sklearn.tree import DecisionTreeClassifier\nimport pickle\nfrom sklearn.svm import SVC\nimport json\n\n\nimport warnings\nwarnings.simplefilter(action='ignore', category=FutureWarning)\n\nimport matplotlib.pyplot as plt\nsns.set_theme(style=\"darkgrid\")\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2022-08-09T17:18:26.289994Z","iopub.execute_input":"2022-08-09T17:18:26.291089Z","iopub.status.idle":"2022-08-09T17:18:26.314357Z","shell.execute_reply.started":"2022-08-09T17:18:26.291033Z","shell.execute_reply":"2022-08-09T17:18:26.313442Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Codigo usado para obtener el dataset reducido","metadata":{}},{"cell_type":"code","source":"\"\"\"\nfrom sklearn.utils.random import sample_without_replacement\n\nds_target = pd.read_csv('train_labels.csv')\n\n# Hago este juego porque tengo problemas con la memoria, y quiero obtener la cantidad filas del train_data\nds = pd.read_csv('train_data.csv', usecols = ['customer_ID']) \ntotal_rows = ds.shape[0]\n\nnro_grupo = 18\nsemilla  = (31416*nro_grupo)%1000\n\nindex = sample_without_replacement(n_population=total_rows, \n                                   n_samples=round(total_rows*0.95), \n                                   random_state=semilla)\nindex.sort()\nindex = np.delete(index, 0) # Para no omitir el header\n\nds = pd.read_csv('train_data.csv', skiprows=index)\n\nds = ds.join(ds_target.set_index('customer_ID'), on='customer_ID')\n\nds.to_csv('train_data_reduced.csv', index = False, header=True)\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:18:26.315892Z","iopub.execute_input":"2022-08-09T17:18:26.316693Z","iopub.status.idle":"2022-08-09T17:18:26.323466Z","shell.execute_reply.started":"2022-08-09T17:18:26.316659Z","shell.execute_reply":"2022-08-09T17:18:26.322352Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df  = pd.read_csv('/kaggle/input/train-data-reducedcsv/train_data_reduced.csv')\ndf.info()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:18:26.325157Z","iopub.execute_input":"2022-08-09T17:18:26.325549Z","iopub.status.idle":"2022-08-09T17:18:37.030607Z","shell.execute_reply.started":"2022-08-09T17:18:26.325517Z","shell.execute_reply":"2022-08-09T17:18:37.029474Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print('Filas: {} \\nColumnas: {}'.format(df.shape[0],df.shape[1]))\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:18:37.033868Z","iopub.execute_input":"2022-08-09T17:18:37.034240Z","iopub.status.idle":"2022-08-09T17:18:37.040964Z","shell.execute_reply.started":"2022-08-09T17:18:37.034199Z","shell.execute_reply":"2022-08-09T17:18:37.039677Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dimensiones = df.shape\n\ncant_columnas = dimensiones[1]\ncant_filas = dimensiones[0]\n\nprint('Cantidad de Columnas: ', cant_columnas)\nprint('Cantidad de Filas:  ', cant_filas)","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:18:37.042294Z","iopub.execute_input":"2022-08-09T17:18:37.042665Z","iopub.status.idle":"2022-08-09T17:18:37.054384Z","shell.execute_reply.started":"2022-08-09T17:18:37.042633Z","shell.execute_reply":"2022-08-09T17:18:37.053090Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df.columns.tolist()","metadata":{"_kg_hide-output":true,"execution":{"iopub.status.busy":"2022-08-09T17:18:37.055853Z","iopub.execute_input":"2022-08-09T17:18:37.056181Z","iopub.status.idle":"2022-08-09T17:18:37.070038Z","shell.execute_reply.started":"2022-08-09T17:18:37.056152Z","shell.execute_reply":"2022-08-09T17:18:37.068925Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df.info()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:18:37.071512Z","iopub.execute_input":"2022-08-09T17:18:37.072223Z","iopub.status.idle":"2022-08-09T17:18:37.088722Z","shell.execute_reply.started":"2022-08-09T17:18:37.072178Z","shell.execute_reply":"2022-08-09T17:18:37.087141Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(df.isna().sum())","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:18:37.090467Z","iopub.execute_input":"2022-08-09T17:18:37.091575Z","iopub.status.idle":"2022-08-09T17:18:37.248896Z","shell.execute_reply.started":"2022-08-09T17:18:37.091538Z","shell.execute_reply":"2022-08-09T17:18:37.247682Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"target_cero = df[df['target']==0]['target'].count()\ntarget_uno  = df[df['target']==1]['target'].count()\n\nlabels = 'No paga la deuda', 'Si paga la deuda'\nsizes = [target_cero, target_uno]\nexplode = (0.05, 0) \n\nplt.title(\"Distribución de la variable Target\")\nplt.pie(sizes, explode=explode, labels=labels, autopct='%1.1f%%',\n        shadow=True, startangle=90 )\nplt.axis('equal') \n\nplt.show()\n\nprint(\"\\n\")\ndf['target'].value_counts()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:18:37.252445Z","iopub.execute_input":"2022-08-09T17:18:37.252804Z","iopub.status.idle":"2022-08-09T17:18:37.662156Z","shell.execute_reply.started":"2022-08-09T17:18:37.252773Z","shell.execute_reply":"2022-08-09T17:18:37.660571Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Vemos la frecuencia de apariciones de los clientes**","metadata":{}},{"cell_type":"markdown","source":"Renombramos los valores de la varible customer_ID por uno mas amigable. Utilizamos Label Encoder.\n\n","metadata":{}},{"cell_type":"code","source":"from sklearn.preprocessing import LabelEncoder\n\nle = LabelEncoder()\n\ndf['customer_ID'] = le.fit_transform(df['customer_ID'].astype(str))","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:18:37.664421Z","iopub.execute_input":"2022-08-09T17:18:37.665384Z","iopub.status.idle":"2022-08-09T17:18:38.382294Z","shell.execute_reply.started":"2022-08-09T17:18:37.665289Z","shell.execute_reply":"2022-08-09T17:18:38.381333Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df_trabajo = df[['customer_ID','target']].value_counts().to_frame('Frecuencia')\ndf_trabajo.reset_index(inplace=True)\ndf_trabajo.rename(columns={'index':'customer_ID'},inplace=True)","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:18:38.383622Z","iopub.execute_input":"2022-08-09T17:18:38.384629Z","iopub.status.idle":"2022-08-09T17:18:38.480959Z","shell.execute_reply.started":"2022-08-09T17:18:38.384583Z","shell.execute_reply":"2022-08-09T17:18:38.479733Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df_ax = df_trabajo[['Frecuencia','target']][df_trabajo['Frecuencia'] < 5].copy()\n\nsns.catplot(y='Frecuencia', data=df_ax, kind=\"count\", hue = \"target\", aspect=3.5)\n\nplt.show()\n\nprint(\"\\n\")\ndf_ax.value_counts()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:18:38.482341Z","iopub.execute_input":"2022-08-09T17:18:38.482793Z","iopub.status.idle":"2022-08-09T17:18:38.987036Z","shell.execute_reply.started":"2022-08-09T17:18:38.482743Z","shell.execute_reply":"2022-08-09T17:18:38.986084Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df_ax = df_trabajo[['Frecuencia','target']][df_trabajo['Frecuencia'] > 4].copy()\n\nsns.catplot(y='Frecuencia', data=df_ax, kind=\"count\", hue = \"target\", aspect=3.5)\n\nplt.show()\n\nprint(\"\\n\")\ndf_ax.value_counts()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:18:38.988601Z","iopub.execute_input":"2022-08-09T17:18:38.989037Z","iopub.status.idle":"2022-08-09T17:18:39.396910Z","shell.execute_reply.started":"2022-08-09T17:18:38.988994Z","shell.execute_reply":"2022-08-09T17:18:39.395808Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df.select_dtypes(include = \"object\")","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:18:39.398096Z","iopub.execute_input":"2022-08-09T17:18:39.398428Z","iopub.status.idle":"2022-08-09T17:18:39.424351Z","shell.execute_reply.started":"2022-08-09T17:18:39.398392Z","shell.execute_reply":"2022-08-09T17:18:39.423408Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(\"Cantidad de Nulos: \", (cant_filas-df['D_63'].isnull().value_counts()[0]) / cant_filas * 100,'%', end=\"\\n\\n\")\n\nsns.catplot(y = 'D_63', data = df, kind='count', aspect=2.9, order = df['D_63'].value_counts().index)\n\nvalue_counts = df['D_63'].value_counts()\nfor i in range(len(value_counts)):\n    plt.text(value_counts[i]+100, i, value_counts[i], va ='center')\n\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:18:39.425963Z","iopub.execute_input":"2022-08-09T17:18:39.426615Z","iopub.status.idle":"2022-08-09T17:18:54.240565Z","shell.execute_reply.started":"2022-08-09T17:18:39.426570Z","shell.execute_reply":"2022-08-09T17:18:54.235999Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(\"Cantidad de Nulos: \", (cant_filas-df['D_64'].isnull().value_counts()[0]) / cant_filas * 100,'%', end=\"\\n\\n\")\n\nsns.catplot(y = 'D_64', data = df, kind='count', aspect=2.9, order = df['D_64'].value_counts().index)\n\nvalue_counts = df['D_64'].value_counts()\nfor i in range(len(value_counts)):\n    plt.text(value_counts[i]+100, i, value_counts[i], va ='center')\n\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:18:54.245988Z","iopub.execute_input":"2022-08-09T17:18:54.247067Z","iopub.status.idle":"2022-08-09T17:19:04.699777Z","shell.execute_reply.started":"2022-08-09T17:18:54.247012Z","shell.execute_reply":"2022-08-09T17:19:04.698419Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Variables Cualitativas**","metadata":{}},{"cell_type":"code","source":"df_cuantitativas = df.select_dtypes(exclude = \"object\")\ndf_cuantitativas.info()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:04.701530Z","iopub.execute_input":"2022-08-09T17:19:04.702744Z","iopub.status.idle":"2022-08-09T17:19:05.055775Z","shell.execute_reply.started":"2022-08-09T17:19:04.702703Z","shell.execute_reply":"2022-08-09T17:19:05.054399Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"matriz_correlacion = df_cuantitativas.corr()\n\nvariables = matriz_correlacion['target'][(matriz_correlacion['target'] >= 0.45) | (matriz_correlacion['target'] <= -0.45)].index\n\nplt.figure(figsize = (12,12))\nsns.heatmap(matriz_correlacion.loc[list(variables),list(variables)], annot=True, linewidths=1, cmap=\"Blues\")\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:05.057847Z","iopub.execute_input":"2022-08-09T17:19:05.058301Z","iopub.status.idle":"2022-08-09T17:19:29.404817Z","shell.execute_reply.started":"2022-08-09T17:19:05.058256Z","shell.execute_reply":"2022-08-09T17:19:29.403824Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"fig, axs = plt.subplots(nrows=1, ncols=4,figsize=(24, 5))\n\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==0], x='D_75', ax=axs[0]).set(title='Target = 0')\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==1], x='D_75', ax=axs[1]).set(title='Target = 1')\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==0], x='B_33', ax=axs[2]).set(title='Target = 0')\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==1], x='B_33', ax=axs[3]).set(title='Target = 1')","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:29.406095Z","iopub.execute_input":"2022-08-09T17:19:29.406475Z","iopub.status.idle":"2022-08-09T17:19:30.603954Z","shell.execute_reply.started":"2022-08-09T17:19:29.406442Z","shell.execute_reply":"2022-08-09T17:19:30.603075Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"fig, axs = plt.subplots(nrows=1, ncols=4,figsize=(24, 5))\n\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==0], x='B_9', ax=axs[0]).set(title='Target = 0')\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==1], x='B_9', ax=axs[1]).set(title='Target = 1')\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==0], x='D_55', ax=axs[2]).set(title='Target = 0')\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==1], x='D_55', ax=axs[3]).set(title='Target = 1')","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:30.605594Z","iopub.execute_input":"2022-08-09T17:19:30.606453Z","iopub.status.idle":"2022-08-09T17:19:31.837967Z","shell.execute_reply.started":"2022-08-09T17:19:30.606406Z","shell.execute_reply":"2022-08-09T17:19:31.837116Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"fig, axs = plt.subplots(nrows=1, ncols=4,figsize=(24, 5))\n\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==0], x='D_44', ax=axs[0]).set(title='Target = 0')\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==1], x='D_44', ax=axs[1]).set(title='Target = 1')\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==0], x='D_48', ax=axs[2]).set(title='Target = 0')\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==1], x='D_48', ax=axs[3]).set(title='Target = 1')","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:31.839086Z","iopub.execute_input":"2022-08-09T17:19:31.839604Z","iopub.status.idle":"2022-08-09T17:19:33.060702Z","shell.execute_reply.started":"2022-08-09T17:19:31.839568Z","shell.execute_reply":"2022-08-09T17:19:33.059515Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"fig, axs = plt.subplots(nrows=1, ncols=4,figsize=(24, 5))\n\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==0], x='P_2', ax=axs[0]).set(title='Target = 0')\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==1], x='P_2', ax=axs[1]).set(title='Target = 1')\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==0], x='B_2', ax=axs[2]).set(title='Target = 0')\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==1], x='B_2', ax=axs[3]).set(title='Target = 1')","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:33.061953Z","iopub.execute_input":"2022-08-09T17:19:33.062660Z","iopub.status.idle":"2022-08-09T17:19:34.312061Z","shell.execute_reply.started":"2022-08-09T17:19:33.062625Z","shell.execute_reply":"2022-08-09T17:19:34.311267Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"fig, axs = plt.subplots(nrows=1, ncols=4,figsize=(24, 5))\n\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==0], x='D_61', ax=axs[0]).set(title='Target = 0')\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==1], x='D_61', ax=axs[1]).set(title='Target = 1')\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==0], x='B_18', ax=axs[2]).set(title='Target = 0')\nsns.boxplot(data=df_cuantitativas[df_cuantitativas['target']==1], x='B_18', ax=axs[3]).set(title='Target = 1')","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:34.313337Z","iopub.execute_input":"2022-08-09T17:19:34.313695Z","iopub.status.idle":"2022-08-09T17:19:35.759959Z","shell.execute_reply.started":"2022-08-09T17:19:34.313662Z","shell.execute_reply":"2022-08-09T17:19:35.758807Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Ingeniería de características**","metadata":{}},{"cell_type":"code","source":"df = df.drop_duplicates()\ndf.reset_index(drop=True, inplace=True)\n\nnew_dimensiones = df.shape\n\nif(new_dimensiones[0] < cant_filas):\n    print('Cantidad de Filas eliminadas:  ', (cant_filas-new_dimensiones[0]))\n    cant_columnas = new_dimensiones[1]\n    cant_filas = new_dimensiones[0]\n\nelse:\n    print(\"No se borraron filas.\")\n    cant_columnas = new_dimensiones[1]\n    cant_filas = new_dimensiones[0]","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:35.766999Z","iopub.execute_input":"2022-08-09T17:19:35.768071Z","iopub.status.idle":"2022-08-09T17:19:41.412860Z","shell.execute_reply.started":"2022-08-09T17:19:35.768029Z","shell.execute_reply":"2022-08-09T17:19:41.411558Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Nos deshacemos de los valores atípicos de la variable categorica (D_64 = -1).**","metadata":{}},{"cell_type":"code","source":"\nindex_drop = df[df['D_64']=='-1'].index\n\ndf.drop(index_drop, axis='index', inplace=True)\ndf.reset_index(inplace=True, drop=True)\n\n# Actualizamos las dimensiones\ndimensiones = df.shape\n\ncant_columnas = dimensiones[1]\ncant_filas = dimensiones[0]\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:41.414441Z","iopub.execute_input":"2022-08-09T17:19:41.415431Z","iopub.status.idle":"2022-08-09T17:19:41.713919Z","shell.execute_reply.started":"2022-08-09T17:19:41.415382Z","shell.execute_reply":"2022-08-09T17:19:41.712695Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\n# Reviso si hay nulos en las variables categoricas\ndf.select_dtypes(include = 'object').isnull().sum()\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:41.715497Z","iopub.execute_input":"2022-08-09T17:19:41.715937Z","iopub.status.idle":"2022-08-09T17:19:41.771748Z","shell.execute_reply.started":"2022-08-09T17:19:41.715905Z","shell.execute_reply":"2022-08-09T17:19:41.770857Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\n# Volvemos a mirar la distribucion de los datos en la variable\ndf['D_64'].value_counts()\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:41.772941Z","iopub.execute_input":"2022-08-09T17:19:41.773444Z","iopub.status.idle":"2022-08-09T17:19:41.792913Z","shell.execute_reply.started":"2022-08-09T17:19:41.773414Z","shell.execute_reply":"2022-08-09T17:19:41.791960Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\n# Transformamos las variables\nle = LabelEncoder()\n\ndf['S_2'] = le.fit_transform(df['S_2'].astype(str))\ndf['D_63'] = le.fit_transform(df['D_63'].astype(str))\ndf['D_64'] = le.fit_transform(df['D_64'].astype(str))\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:41.794255Z","iopub.execute_input":"2022-08-09T17:19:41.794585Z","iopub.status.idle":"2022-08-09T17:19:42.036927Z","shell.execute_reply.started":"2022-08-09T17:19:41.794557Z","shell.execute_reply":"2022-08-09T17:19:42.035854Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\ndf['D_64'].value_counts()\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:42.038450Z","iopub.execute_input":"2022-08-09T17:19:42.038761Z","iopub.status.idle":"2022-08-09T17:19:42.049608Z","shell.execute_reply.started":"2022-08-09T17:19:42.038734Z","shell.execute_reply":"2022-08-09T17:19:42.048238Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Los valores D_64 = 3, son los que son anteriormente eran nulos. Lo seteamos nuevamente con NaN, luego utilizando los métodos vistos en clases lo completamos.","metadata":{}},{"cell_type":"code","source":"\ndf['D_64'].replace(to_replace=3, value=np.nan, inplace=True)\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:42.051718Z","iopub.execute_input":"2022-08-09T17:19:42.052242Z","iopub.status.idle":"2022-08-09T17:19:42.062009Z","shell.execute_reply.started":"2022-08-09T17:19:42.052199Z","shell.execute_reply":"2022-08-09T17:19:42.060938Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Revisamos los outliers**\n","metadata":{}},{"cell_type":"code","source":"\ndf['D_64'].replace(to_replace=3, value=np.nan, inplace=True)\n#Revisamos los outliers\nimport scipy.stats as st\n\ncolumns = df.select_dtypes(exclude = \"object\").columns.to_list()\ncolumns.remove('customer_ID')\n\ndf_copy = df[columns].copy()\n\n# Z-score con librería Stats\nfor column in columns:\n    ds = st.zscore(df_copy[[column]])    \n    index_drop = ds[(ds[column] > 3) | (ds[column] < -3)].index       \n  \n    if(len(index_drop) == 0): continue   \n    \n    df_copy.drop(index_drop, axis='index', inplace=True)\n    ","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:42.063512Z","iopub.execute_input":"2022-08-09T17:19:42.063866Z","iopub.status.idle":"2022-08-09T17:19:53.466575Z","shell.execute_reply.started":"2022-08-09T17:19:42.063835Z","shell.execute_reply":"2022-08-09T17:19:53.465379Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\nprint(df_copy.shape)\nindex = df_copy.index\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:53.468095Z","iopub.execute_input":"2022-08-09T17:19:53.468504Z","iopub.status.idle":"2022-08-09T17:19:53.474764Z","shell.execute_reply.started":"2022-08-09T17:19:53.468469Z","shell.execute_reply":"2022-08-09T17:19:53.473572Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\nporc = df_copy.shape[0] / df.shape[0] * 100\nprint(\"Me quedo con el\",porc,\"% del dataset original\")\ndel(df_copy)\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:53.476243Z","iopub.execute_input":"2022-08-09T17:19:53.477071Z","iopub.status.idle":"2022-08-09T17:19:53.489530Z","shell.execute_reply.started":"2022-08-09T17:19:53.477033Z","shell.execute_reply":"2022-08-09T17:19:53.488387Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Me quedo con el 47.65078683261196 % del dataset original**\n\n**Como se puede apreciar, se reduce considerablemente la dimensión del dataset si se eliminara los outliers teniendo en cuenta el análisis con Z-score. Esto debido a que muchas variables cumplen con la regla vista en clase, y que por cada iteración que se elimina registro, puede generar nuevos outliers al cambiar la varianza de las demás variables. Por eso, se decide cambiar esos outliers por NaN, luego analizaremos los registros (y las columnas) con cierta cantidad de nulos y procederemos a eliminarlos.**","metadata":{}},{"cell_type":"code","source":"\ncant_col_afectadas = 0\n\nfor column in columns:\n    ds = st.zscore(df[[column]])    \n    index_drop = ds[(ds[column] > 3) | (ds[column] < -3)].index \n    \n    if(len(index_drop) == 0): continue\n    \n    cant_col_afectadas += 1\n\n    df.loc[index_drop,column] = np.nan\n    \nprint(\"Cantidad de columnas afectadas:\", cant_col_afectadas)\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:53.491453Z","iopub.execute_input":"2022-08-09T17:19:53.491766Z","iopub.status.idle":"2022-08-09T17:19:55.818929Z","shell.execute_reply.started":"2022-08-09T17:19:53.491738Z","shell.execute_reply":"2022-08-09T17:19:55.817544Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Cantidad de columnas afectadas: 62\n\n**Revisamos la cantidad de nulos por variables, y la relacion que presenta con el target.**","metadata":{}},{"cell_type":"code","source":"\nnulos_por_columna = df.isnull().sum(axis=0)\n\nplt.figure(figsize = (25,5))\nsns.boxplot(x=nulos_por_columna/cant_filas*100).set(title=\"Cantidad de nulos de todas las variables (porcentaje)\")\nplt.show()\n\n(nulos_por_columna/cant_filas*100).describe()\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:55.820934Z","iopub.execute_input":"2022-08-09T17:19:55.822143Z","iopub.status.idle":"2022-08-09T17:19:56.181507Z","shell.execute_reply.started":"2022-08-09T17:19:55.822087Z","shell.execute_reply":"2022-08-09T17:19:56.180281Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\nnew_nulos_por_columna = nulos_por_columna[(nulos_por_columna/cant_filas*100) < 20]\n\nplt.figure(figsize = (25,5))\nsns.boxplot(x=new_nulos_por_columna/cant_filas*100).set(\n    title=\"Cantidad de nulos de todas las variables (porcentaje)\"\n)\nplt.show()\n\nprint((new_nulos_por_columna/cant_filas*100).describe(), end=\"\\n\\n\")\n\n#print('Cantidad de Columnas:       ', len(new_nulos_por_columna))\n#print('Cantidad de Columnas(%):  ', round((len(new_nulos_por_columna)/cant_columnas_inicial*100),2), end=\"\\n\\n\")\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:56.183513Z","iopub.execute_input":"2022-08-09T17:19:56.184008Z","iopub.status.idle":"2022-08-09T17:19:56.450798Z","shell.execute_reply.started":"2022-08-09T17:19:56.183963Z","shell.execute_reply":"2022-08-09T17:19:56.449266Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\nvariables_full_null = nulos_por_columna[(nulos_por_columna/cant_filas*100) >= 20].index\ndf[list(variables_full_null)+['target']]['target'].value_counts()/cant_filas*100\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:56.453049Z","iopub.execute_input":"2022-08-09T17:19:56.453572Z","iopub.status.idle":"2022-08-09T17:19:56.486889Z","shell.execute_reply.started":"2022-08-09T17:19:56.453526Z","shell.execute_reply":"2022-08-09T17:19:56.485730Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\nvariables = nulos_por_columna[(nulos_por_columna/cant_filas*100) < 20].index\ndf[variables]['target'].value_counts()/cant_filas*100\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:56.488232Z","iopub.execute_input":"2022-08-09T17:19:56.489250Z","iopub.status.idle":"2022-08-09T17:19:56.615473Z","shell.execute_reply.started":"2022-08-09T17:19:56.489213Z","shell.execute_reply":"2022-08-09T17:19:56.614380Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Se observa que se mantiene la distribución del target. Podria no causar gran impacto eliminar las siguientes variables.\n\nTodas aquellas variables que presenta una cantidad de nulos mayor/igual al 20%, se desestima el uso de tales variables, por ende, se procede a eliminarlas del set de datos. Completar las columnas con los métodos aprendidos en clase afectaría a la varianza de las mismas.","metadata":{}},{"cell_type":"code","source":"\ncolumns_drop = nulos_por_columna[(nulos_por_columna/cant_filas*100) >= 20]\nprint(\"Cantidad de columnas eliminadas: \", len(columns_drop.index))\ndf.drop(columns_drop.index, axis='columns', inplace=True)\n\n# Actualizamos las dimensiones\ndimensiones = df.shape\n\ncant_columnas = dimensiones[1]\ncant_filas = dimensiones[0]\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:56.616847Z","iopub.execute_input":"2022-08-09T17:19:56.617203Z","iopub.status.idle":"2022-08-09T17:19:56.736290Z","shell.execute_reply.started":"2022-08-09T17:19:56.617173Z","shell.execute_reply":"2022-08-09T17:19:56.735099Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Revisamos la cantidad de nulos por filas, y la relacion que presenta con el target.**","metadata":{}},{"cell_type":"code","source":"\nnulos_por_fila = df.isnull().sum(axis=1)\n\nplt.figure(figsize = (25,5))\nsns.boxplot(x=nulos_por_fila/cant_columnas*100).set(title=\"Cantidad de nulos por fila (porcentaje)\")\nplt.show()\n\n(nulos_por_fila/cant_columnas*100).describe()\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:56.738066Z","iopub.execute_input":"2022-08-09T17:19:56.738500Z","iopub.status.idle":"2022-08-09T17:19:57.128465Z","shell.execute_reply.started":"2022-08-09T17:19:56.738463Z","shell.execute_reply":"2022-08-09T17:19:57.127382Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\ndf_aux = pd.DataFrame()\ndf_aux['nulos_filas'] = (nulos_por_fila/cant_columnas*100)\ndf_aux['target'] = df['target']\n\nplt.figure(figsize = (25,8))\nsns.kdeplot(data=df_aux, x=\"nulos_filas\", hue='target', cut=0)\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:57.129764Z","iopub.execute_input":"2022-08-09T17:19:57.130785Z","iopub.status.idle":"2022-08-09T17:19:58.706348Z","shell.execute_reply.started":"2022-08-09T17:19:57.130744Z","shell.execute_reply":"2022-08-09T17:19:58.705200Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Hacemos un zoom donde presenta diferencia significativa entre la distribución de los datos de target.\n\n","metadata":{}},{"cell_type":"code","source":"\ncorte = 2\n\nplt.figure(figsize = (25,8))\nsns.kdeplot(data=df_aux[df_aux['nulos_filas']<corte], x=\"nulos_filas\", hue='target', cut=0)\nplt.show()\n\nnew_cant_filas = len(df_aux[df_aux['nulos_filas']<corte]['target'])\nprint(df_aux[df_aux['nulos_filas']<corte]['target'].value_counts()/new_cant_filas*100, end=\"\\n\\n\")\n\n\n#print('Cantidad de Filas:       ', df_aux[df_aux['nulos_filas']<corte].shape[0])\n#print('Cantidad de Filas(%):     ', round((df_aux[df_aux['nulos_filas']<corte].shape[0]/cant_filas_inicial*100),2), end=\"\\n\\n\")\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:58.707967Z","iopub.execute_input":"2022-08-09T17:19:58.708372Z","iopub.status.idle":"2022-08-09T17:19:59.916506Z","shell.execute_reply.started":"2022-08-09T17:19:58.708337Z","shell.execute_reply":"2022-08-09T17:19:59.915135Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Borramos aquellas filas que presentan más del 2% de nulos en su registro, luego completamos las restantes utilizando información de los demás. Evitamos que la varianza de cada variable se vea lo menos posible afectada.\n\n","metadata":{}},{"cell_type":"code","source":"\nindex_drop = df_aux[df_aux['nulos_filas']>=corte].index\n\ndf.drop(index_drop, axis='index', inplace=True)\ndf.reset_index(inplace=True, drop=True)\n\n# Actualizamos las dimensiones\ndimensiones = df.shape\n\ncant_columnas = dimensiones[1]\ncant_filas = dimensiones[0]\n","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:19:59.918075Z","iopub.execute_input":"2022-08-09T17:19:59.918535Z","iopub.status.idle":"2022-08-09T17:20:00.115967Z","shell.execute_reply.started":"2022-08-09T17:19:59.918498Z","shell.execute_reply":"2022-08-09T17:20:00.114635Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Completamos el dataset**","metadata":{}},{"cell_type":"code","source":"\"\"\"\nprint(\"Tamaño del dataset comparado con el set original\", end=\"\\n\\n\")\n\nprint('Cantidad de Filas:       ', cant_filas)\nprint('Cantidad de Filas(%):     ', round((cant_filas/cant_filas_inicial*100),2), end=\"\\n\\n\")\n\nprint('Cantidad de Columnas:       ', cant_columnas)\nprint('Cantidad de Columnas(%):  ', round((cant_columnas/cant_columnas_inicial*100),2), end=\"\\n\\n\")\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.117644Z","iopub.execute_input":"2022-08-09T17:20:00.118038Z","iopub.status.idle":"2022-08-09T17:20:00.126223Z","shell.execute_reply.started":"2022-08-09T17:20:00.118003Z","shell.execute_reply":"2022-08-09T17:20:00.124889Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nfrom sklearn.experimental import enable_iterative_imputer\nfrom sklearn.impute import IterativeImputer\nfrom sklearn.linear_model import LinearRegression\nimport random\n\ndf_copy = df.select_dtypes(exclude = 'object').copy()\n\ncolumns = df_copy.columns\ncolumns_nulos1 = []\n\nfor column in columns:\n    if(df_copy[column].isnull().sum() == 0): continue\n    columns_nulos1.append(column)\n    \n# Dividimos en tres la lista columns_nulos para reducir el tiempo de proceso\ncolumns_nulos2 = random.sample(columns_nulos1, len(columns_nulos1)//3)\n\nfor col in columns_nulos2:\n    columns_nulos1.remove(col)\n    \ncolumns_nulos3 = random.sample(columns_nulos1, len(columns_nulos1)//2)\n\nfor col in columns_nulos3:\n    columns_nulos1.remove(col)\n    \nlr = LinearRegression()\nimp = IterativeImputer(estimator=lr, missing_values=np.nan, max_iter=15, verbose=0, random_state=0) #imputation_order='roman'\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.127982Z","iopub.execute_input":"2022-08-09T17:20:00.128504Z","iopub.status.idle":"2022-08-09T17:20:00.144407Z","shell.execute_reply.started":"2022-08-09T17:20:00.128465Z","shell.execute_reply":"2022-08-09T17:20:00.143417Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\ndf[columns_nulos1] = imp.fit_transform(df_copy[columns_nulos1])\ndf[columns_nulos2] = imp.fit_transform(df_copy[columns_nulos2])\ndf[columns_nulos3] = imp.fit_transform(df_copy[columns_nulos3])\n# Set de datos completo\ndf.isnull().sum().sum()\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.146420Z","iopub.execute_input":"2022-08-09T17:20:00.147218Z","iopub.status.idle":"2022-08-09T17:20:00.156349Z","shell.execute_reply.started":"2022-08-09T17:20:00.147181Z","shell.execute_reply":"2022-08-09T17:20:00.155032Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Vemos la importancia de normalizar**","metadata":{}},{"cell_type":"code","source":"\"\"\"\nfeatures = df.columns.to_list()\nfeatures.remove('target')\nfeatures.remove('customer_ID') # Tanto tanget como customer_ID, son variables que se van a utilizar\n\ntarget = 'target'\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.159336Z","iopub.execute_input":"2022-08-09T17:20:00.159859Z","iopub.status.idle":"2022-08-09T17:20:00.169932Z","shell.execute_reply.started":"2022-08-09T17:20:00.159811Z","shell.execute_reply":"2022-08-09T17:20:00.169050Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Para evitar una eterna ejecución, elegimos de forma aleatoria una cantidad de features.\n\n","metadata":{}},{"cell_type":"code","source":"\"\"\"\n_features = random.sample(features, 5)\n\n# Creo conjuntos de train y test\nx_train, x_test, y_train, y_test = train_test_split(df[_features].values, df[target].values, test_size=0.2, random_state=0)\n\n# Armo una version estandarizada\nstand_scaler = preprocessing.StandardScaler()\nx_train_norm = stand_scaler.fit_transform(x_train)\nx_test_norm = stand_scaler.fit_transform(x_test)\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.171571Z","iopub.execute_input":"2022-08-09T17:20:00.172639Z","iopub.status.idle":"2022-08-09T17:20:00.181789Z","shell.execute_reply.started":"2022-08-09T17:20:00.172588Z","shell.execute_reply":"2022-08-09T17:20:00.180544Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\n# Entreno con los datos sin escalar (25min aprox)\nsvm = SVC()\nsvm.fit(x_train, y_train)\ny_pred = svm.predict(x_test)\nmetricas(y_pred,y_test)\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.183744Z","iopub.execute_input":"2022-08-09T17:20:00.184674Z","iopub.status.idle":"2022-08-09T17:20:00.196417Z","shell.execute_reply.started":"2022-08-09T17:20:00.184626Z","shell.execute_reply":"2022-08-09T17:20:00.195130Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Vemos la importancia de normalizar","metadata":{}},{"cell_type":"code","source":"\"\"\"\nfeatures = tsne_dfReduc.columns.to_list()\nfeatures.remove('target')\nfeatures.remove('customer_ID') # Tanto tanget como customer_ID, son variables que se van a utilizar\n\ntarget = 'target'\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.198438Z","iopub.execute_input":"2022-08-09T17:20:00.198999Z","iopub.status.idle":"2022-08-09T17:20:00.209025Z","shell.execute_reply.started":"2022-08-09T17:20:00.198963Z","shell.execute_reply":"2022-08-09T17:20:00.208071Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Para evitar una eterna ejecución, elegimos de forma aleatoria una cantidad de features.","metadata":{}},{"cell_type":"code","source":"\"\"\"\n_features = random.sample(features, 5)\n\n# Creo conjuntos de train y test\nx_train, x_test, y_train, y_test = train_test_split(df[_features].values, df[target].values, test_size=0.2, random_state=0)\n\n# Armo una version estandarizada\nstand_scaler = preprocessing.StandardScaler()\nx_train_norm = stand_scaler.fit_transform(x_train)\nx_test_norm = stand_scaler.fit_transform(x_test)\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.210670Z","iopub.execute_input":"2022-08-09T17:20:00.211784Z","iopub.status.idle":"2022-08-09T17:20:00.220598Z","shell.execute_reply.started":"2022-08-09T17:20:00.211745Z","shell.execute_reply":"2022-08-09T17:20:00.219457Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\n# Entreno con los datos sin escalar (25min aprox)\nsvm = SVC()\nsvm.fit(x_train, y_train)\ny_pred = svm.predict(x_test)\nmetricas(y_pred,y_test)\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.222130Z","iopub.execute_input":"2022-08-09T17:20:00.223485Z","iopub.status.idle":"2022-08-09T17:20:00.232042Z","shell.execute_reply.started":"2022-08-09T17:20:00.223440Z","shell.execute_reply":"2022-08-09T17:20:00.231212Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"              precision    recall  f1-score   support\n\n           0       0.79      0.99      0.88     34579\n           1       0.56      0.05      0.10      9568\n\n    accuracy                           0.79     44147\nmacro avg       \n   precision:0.67\n   recall: 0.52      \n   f1-score: 0.49     \n   support: 44147\n   \nweighted avg       \n precision:0.74\n recall: 0.79    \n f1-score: 0.71     \n support: 44147\n\n","metadata":{}},{"cell_type":"code","source":"\"\"\"\n# Entreno los datos escalados con normalizacion (20min aprox)\nsvm_norm = SVC()\nsvm_norm.fit(x_train_norm, y_train)\ny_pred_norm = svm_norm.predict(x_test_norm)\nmetricas(y_pred_norm,y_test)\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.233891Z","iopub.execute_input":"2022-08-09T17:20:00.235133Z","iopub.status.idle":"2022-08-09T17:20:00.245045Z","shell.execute_reply.started":"2022-08-09T17:20:00.235092Z","shell.execute_reply":"2022-08-09T17:20:00.244055Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"              precision    recall  f1-score   support\n\n           0       0.79      0.99      0.88     34579\n           1       0.58      0.05      0.09      9568\n\n    accuracy                           0.79     44147\n    \nmacro avg       \n   precision: 0.68           \n   recall: 0.52          \n   f1-score: 0.48         \n   support: 44147 \nweighted avg       \n   precision: 0.74           \n   recall: 0.79          \n   f1-score: 0.71         \n   support: 44147        ","metadata":{}},{"cell_type":"markdown","source":"Con 5 variables random, se ve un ligero incremento de eficiencia del estimador en la predicción con los datos. Quizás, tomando más datos esta brecha aumenta. Teniendo en cuenta este resultado, y a pesar de la documentación de sklearn, se decide no normalizar los datos del dataset.\n\n","metadata":{}},{"cell_type":"markdown","source":"\n","metadata":{}},{"cell_type":"code","source":"\"\"\"\ncolumns = df.columns.to_list()\ntotal = 0\ncolumns_drop = []\n \nfor column in columns:\n    if((df[column].isna().sum()/cant_filas*100) > 35):\n        total = total + 1\n        columns_drop.append(column)\n        print(column, \": \",df[column].isna().sum()/cant_filas*100)\n\nprint(\"Cantidad de variables: \",total, end=\"\\n\")\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.246802Z","iopub.execute_input":"2022-08-09T17:20:00.247473Z","iopub.status.idle":"2022-08-09T17:20:00.257342Z","shell.execute_reply.started":"2022-08-09T17:20:00.247433Z","shell.execute_reply":"2022-08-09T17:20:00.255972Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\ndf.drop(columns_drop, axis='columns', inplace=True)\n\n# Actualizamos las dimensiones\ndimensiones = df.shape\n\ncant_columnas = dimensiones[1]\ncant_filas = dimensiones[0]\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.259517Z","iopub.execute_input":"2022-08-09T17:20:00.260422Z","iopub.status.idle":"2022-08-09T17:20:00.270763Z","shell.execute_reply.started":"2022-08-09T17:20:00.260369Z","shell.execute_reply":"2022-08-09T17:20:00.269494Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nnulos_por_fila = df.isnull().sum(axis=1)\n(nulos_por_fila/cant_columnas * 100).sort_values(ascending = False) \n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.272063Z","iopub.execute_input":"2022-08-09T17:20:00.273113Z","iopub.status.idle":"2022-08-09T17:20:00.284981Z","shell.execute_reply.started":"2022-08-09T17:20:00.273056Z","shell.execute_reply":"2022-08-09T17:20:00.283612Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#df.shape","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.286181Z","iopub.execute_input":"2022-08-09T17:20:00.287082Z","iopub.status.idle":"2022-08-09T17:20:00.298265Z","shell.execute_reply.started":"2022-08-09T17:20:00.287030Z","shell.execute_reply":"2022-08-09T17:20:00.297329Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dfRed = pd.read_csv('/kaggle/input/ds-trabajo/ds_trabajo.csv')","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.299726Z","iopub.execute_input":"2022-08-09T17:20:00.300731Z","iopub.status.idle":"2022-08-09T17:20:00.348118Z","shell.execute_reply.started":"2022-08-09T17:20:00.300696Z","shell.execute_reply":"2022-08-09T17:20:00.330951Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dfRed.columns.tolist()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.349560Z","iopub.status.idle":"2022-08-09T17:20:00.350538Z","shell.execute_reply.started":"2022-08-09T17:20:00.350261Z","shell.execute_reply":"2022-08-09T17:20:00.350289Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#dfRed = dfRed.dropna()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.351994Z","iopub.status.idle":"2022-08-09T17:20:00.352734Z","shell.execute_reply.started":"2022-08-09T17:20:00.352506Z","shell.execute_reply":"2022-08-09T17:20:00.352531Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dfRed.info()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.353835Z","iopub.status.idle":"2022-08-09T17:20:00.355155Z","shell.execute_reply.started":"2022-08-09T17:20:00.354899Z","shell.execute_reply":"2022-08-09T17:20:00.354924Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dfRed.describe()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.356272Z","iopub.status.idle":"2022-08-09T17:20:00.357266Z","shell.execute_reply.started":"2022-08-09T17:20:00.357048Z","shell.execute_reply":"2022-08-09T17:20:00.357071Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dfTarget = dfRed['target'].copy()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.358649Z","iopub.status.idle":"2022-08-09T17:20:00.359058Z","shell.execute_reply.started":"2022-08-09T17:20:00.358851Z","shell.execute_reply":"2022-08-09T17:20:00.358868Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dfTarget.head()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.360546Z","iopub.status.idle":"2022-08-09T17:20:00.360926Z","shell.execute_reply.started":"2022-08-09T17:20:00.360741Z","shell.execute_reply":"2022-08-09T17:20:00.360759Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dfTarget.describe()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.362189Z","iopub.status.idle":"2022-08-09T17:20:00.362648Z","shell.execute_reply.started":"2022-08-09T17:20:00.362415Z","shell.execute_reply":"2022-08-09T17:20:00.362435Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dfAux = dfRed.copy()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.363957Z","iopub.status.idle":"2022-08-09T17:20:00.364370Z","shell.execute_reply.started":"2022-08-09T17:20:00.364151Z","shell.execute_reply":"2022-08-09T17:20:00.364168Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#dfRed.drop('target', axis='columns', inplace=True)\n#dfRed.drop('S_2', axis='columns', inplace=True)\n#dfRed.drop('D_63', axis='columns', inplace=True)\n#dfRed.drop('D_64', axis='columns', inplace=True)","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.365669Z","iopub.status.idle":"2022-08-09T17:20:00.366059Z","shell.execute_reply.started":"2022-08-09T17:20:00.365863Z","shell.execute_reply":"2022-08-09T17:20:00.365881Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dfRed.shape","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.367468Z","iopub.status.idle":"2022-08-09T17:20:00.367874Z","shell.execute_reply.started":"2022-08-09T17:20:00.367666Z","shell.execute_reply":"2022-08-09T17:20:00.367683Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dfRed.describe()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.368998Z","iopub.status.idle":"2022-08-09T17:20:00.369403Z","shell.execute_reply.started":"2022-08-09T17:20:00.369186Z","shell.execute_reply":"2022-08-09T17:20:00.369203Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dfTarget.shape","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.370657Z","iopub.status.idle":"2022-08-09T17:20:00.371039Z","shell.execute_reply.started":"2022-08-09T17:20:00.370845Z","shell.execute_reply":"2022-08-09T17:20:00.370862Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dfTarget.head()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.372289Z","iopub.status.idle":"2022-08-09T17:20:00.372698Z","shell.execute_reply.started":"2022-08-09T17:20:00.372509Z","shell.execute_reply":"2022-08-09T17:20:00.372527Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dfTarget.describe()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.374219Z","iopub.status.idle":"2022-08-09T17:20:00.374615Z","shell.execute_reply.started":"2022-08-09T17:20:00.374428Z","shell.execute_reply":"2022-08-09T17:20:00.374446Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(dfTarget.isna().sum())","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.375837Z","iopub.status.idle":"2022-08-09T17:20:00.376221Z","shell.execute_reply.started":"2022-08-09T17:20:00.376036Z","shell.execute_reply":"2022-08-09T17:20:00.376054Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Vamos a hacer una reduccion de dimensionalidad para ver como se comporta el dataset**","metadata":{}},{"cell_type":"code","source":"from sklearn.preprocessing import StandardScaler\n\ndfRed=StandardScaler().fit_transform(dfRed)","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.377408Z","iopub.status.idle":"2022-08-09T17:20:00.377778Z","shell.execute_reply.started":"2022-08-09T17:20:00.377593Z","shell.execute_reply":"2022-08-09T17:20:00.377610Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### \"\"\"\nfrom sklearn.decomposition import PCA\n\npca = PCA(n_components=7) \nx_transformada = pca.fit_transform(dfRed)\n\npca_df_aux = pd.DataFrame(data = x_transformada, columns = ['cp_1', 'cp_2','cp_3','cp_4','cp_5','cp_6','cp_7'])\n\"\"\"\n","metadata":{"execution":{"iopub.status.busy":"2022-07-27T19:39:40.212413Z","iopub.execute_input":"2022-07-27T19:39:40.213132Z","iopub.status.idle":"2022-07-27T19:39:42.695484Z","shell.execute_reply.started":"2022-07-27T19:39:40.213092Z","shell.execute_reply":"2022-07-27T19:39:42.694432Z"}}},{"cell_type":"code","source":"#pca_df_aux.head()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.378554Z","iopub.status.idle":"2022-08-09T17:20:00.378914Z","shell.execute_reply.started":"2022-08-09T17:20:00.378733Z","shell.execute_reply":"2022-08-09T17:20:00.378750Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#pca_df_aux.shape","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.380510Z","iopub.status.idle":"2022-08-09T17:20:00.380886Z","shell.execute_reply.started":"2022-08-09T17:20:00.380701Z","shell.execute_reply":"2022-08-09T17:20:00.380718Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#dfTarget.shape","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.382186Z","iopub.status.idle":"2022-08-09T17:20:00.382599Z","shell.execute_reply.started":"2022-08-09T17:20:00.382400Z","shell.execute_reply":"2022-08-09T17:20:00.382419Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#dfTarget.tail()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.383515Z","iopub.status.idle":"2022-08-09T17:20:00.383881Z","shell.execute_reply.started":"2022-08-09T17:20:00.383698Z","shell.execute_reply":"2022-08-09T17:20:00.383714Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#dfTarget = dfTarget.reset_index()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.391013Z","iopub.status.idle":"2022-08-09T17:20:00.391522Z","shell.execute_reply.started":"2022-08-09T17:20:00.391272Z","shell.execute_reply":"2022-08-09T17:20:00.391291Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#dfTarget.tail()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.392989Z","iopub.status.idle":"2022-08-09T17:20:00.393436Z","shell.execute_reply.started":"2022-08-09T17:20:00.393202Z","shell.execute_reply":"2022-08-09T17:20:00.393220Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#pca_dfReduc = pd.concat([dfAux['target'],pca_df_aux], axis = 1)","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.394884Z","iopub.status.idle":"2022-08-09T17:20:00.395275Z","shell.execute_reply.started":"2022-08-09T17:20:00.395091Z","shell.execute_reply":"2022-08-09T17:20:00.395109Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#pca_dfReduc =pd.concat([pca_df_aux,dfTarget], axis = 1)","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.396734Z","iopub.status.idle":"2022-08-09T17:20:00.397129Z","shell.execute_reply.started":"2022-08-09T17:20:00.396939Z","shell.execute_reply":"2022-08-09T17:20:00.396958Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#pca_dfReduc.head()","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.398366Z","iopub.status.idle":"2022-08-09T17:20:00.398749Z","shell.execute_reply.started":"2022-08-09T17:20:00.398562Z","shell.execute_reply":"2022-08-09T17:20:00.398580Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#pca_dfReduc.drop('index', axis='columns', inplace=True)","metadata":{"execution":{"iopub.status.busy":"2022-08-09T17:20:00.399580Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#pca_dfReduc.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#pca_dfReduc.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#pca_dfReduc.to_csv('PCA_ds_trabajo.csv',index=False)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"La reduccion se ejecutó anteriormente y se guardo para acortar tiempos","metadata":{}},{"cell_type":"code","source":"pca_dfReduc = pd.read_csv('/kaggle/input/ds-trabajo-pca/PCA_ds_trabajo.csv')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"pca_dfReduc.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#pca.explained_variance_ratio_","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"array([0.02055686, 0.01237959, 0.01234568, 0.01234568, 0.01234568,\n       0.01234568, 0.01234568])","metadata":{}},{"cell_type":"markdown","source":"Con 7 variables vemos que el ratio es casi 0.095 por lo que podemos ver pierde bastante informacion","metadata":{}},{"cell_type":"markdown","source":"**Vamos ha hacer una reduccion via tsne**","metadata":{}},{"cell_type":"code","source":"\"\"\"\nfrom sklearn.manifold import TSNE\ntsne = TSNE(n_components=2)\nx_tsne = tsne.fit_transform(dfRed)\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#tsne_df_aux = pd.DataFrame(data = x_tsne, columns = ['cp_1', 'cp_2'])","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#tsne_dfReduc =pd.concat([tsne_df_aux,dfTarget], axis = 1)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#tsne_dfReduc = pd.read_csv('/kaggle/input/tsne2cp/mycsvfile.csv')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#tsne_dfReduc.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#tsne_dfReduc.drop('index', axis='columns', inplace=True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#tsne_dfReduc.to_csv('tsne_ds_trabajo.csv',index=False)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"la reduccion se guardo para evitar volver a procesarla","metadata":{}},{"cell_type":"code","source":"tsne_dfReduc = pd.read_csv('/kaggle/input/ds-trabajo-tsne/tsne_ds_trabajo.csv')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"db_x = tsne_dfReduc.copy()\ndb_x.drop('target', axis='columns', inplace=True)\ndb_y = tsne_dfReduc['target'].copy()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Modelos**\n\npara los modelos vamos a buscar maximizar F1 score ya que tiene en cuenta tanto presicion como recall en su calculo","metadata":{}},{"cell_type":"markdown","source":"Aunque la reduccion de dimensionalidad hecha tanto con pca y tsne no han resultado ser utiles por su perdida de informacion (en el caso de pca al menos), vamos a plantear varios modelos con estos datos a modo ilustrativo pero solo se consideraran los modelos entrenados con el set sin reducción de dimensionalidad para el analisis posterior","metadata":{}},{"cell_type":"markdown","source":"**Random forest**","metadata":{}},{"cell_type":"markdown","source":"**randon forest con tsne**","metadata":{}},{"cell_type":"code","source":"from sklearn.model_selection import train_test_split\nx_train, x_test, y_train, y_test = train_test_split(db_x, db_y, test_size=0.2, random_state=2)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from sklearn.ensemble import RandomForestClassifier\nfrom sklearn.model_selection import StratifiedKFold, KFold,RandomizedSearchCV\nfrom sklearn.metrics import make_scorer","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.model_selection import StratifiedKFold, KFold,RandomizedSearchCV\nfrom sklearn.metrics import make_scorer\n\n\n#Cantidad de combinaciones a probar\nn=15\n\n#Conjunto de parámetros a usar\nparametros_RF = {'criterion':['gini','entropy'],\n               'ccp_alpha':np.linspace(0,0.05,n),\n               'max_depth':list(range(1,20,2))}\n                \n\n#Cantidad de splits para el Cross Validation\nsplits=5\n\n#Kfold estratificado\nkfoldcv = StratifiedKFold(n_splits=splits)\n\n#Clasificador\nbase_random_forest = RandomForestClassifier()\n\n#se decidio por optimizar F1 score\nscorer_fn = make_scorer(sk.metrics.f1_score)\n\n#Random Search Cross Validation\nrandomcv_random_forest = RandomizedSearchCV(estimator=base_random_forest,\n                              param_distributions = parametros_RF,\n                              scoring=scorer_fn,\n                              cv=kfoldcv,\n                              n_iter=n,\n                              random_state=4)\n\n#Busco los hiperparametros que optimizan F1 Score\nrandomcv_random_forest.fit(x_train,y_train)\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#print(randomcv_random_forest.best_params_)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"{'max_depth': 13, 'criterion': 'gini', 'ccp_alpha': 0.0}\n","metadata":{}},{"cell_type":"code","source":"#best_random_forest = RandomForestClassifier(max_depth = 13, criterion=\"gini\", ccp_alpha=0)\n#best_random_forest.fit(x_train, y_train)\nbest_random_forest = joblib.load('/kaggle/input/ds-trabajo-rf/ds_trabajo_RFtsne.joblib')¡","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#joblib.dump(best_random_forest, \"./ds_trabajo_RFtsne.joblib\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from sklearn.metrics import precision_score\nfrom sklearn.metrics import recall_score\nfrom sklearn.metrics import f1_score\nfrom sklearn.ensemble import RandomForestClassifier\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"RF_pred = best_random_forest.predict(x_test)\nRF_precision = precision_score(y_test, RF_pred)\nRF_recall = recall_score(y_test, RF_pred)\nRF_f1 = f1_score(y_test, RF_pred)\nprint(\"Random Forest Precision: \" + str(RF_precision))\nprint(\"Random Forest Recall: \" + str(RF_recall))\nprint(\"Random Forest F1 Score: \" + str(RF_f1))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Random Forest Precision: 0.803066812705367\n\nRandom Forest Recall: 0.7690371302706105\n\nRandom Forest F1 Score: 0.7856836690955851","metadata":{}},{"cell_type":"code","source":"#dfTarget.drop('index', axis='columns', inplace=True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Random Forest con PCA**","metadata":{}},{"cell_type":"code","source":"pca_df_aux = pca_dfReduc.copy()\npca_df_aux.drop('target', axis='columns', inplace=True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df_target = pca_dfReduc['target'].copy()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"x_train2, x_test2, y_train2, y_test2 = train_test_split(pca_df_aux, df_target, test_size=0.2, random_state=2)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"x_train2.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.model_selection import StratifiedKFold, KFold,RandomizedSearchCV\nfrom sklearn.metrics import make_scorer\n\n\n#Cantidad de combinaciones a probar\nn=15\n\n#Conjunto de parámetros a usar\nparametros_RF = {'criterion':['gini','entropy'],\n               'ccp_alpha':np.linspace(0,0.05,n),\n               'max_depth':list(range(1,20,2))}\n                \n\n#Cantidad de splits para el Cross Validation\nsplits=5\n\n#Kfold estratificado\nkfoldcv = StratifiedKFold(n_splits=splits)\n\n#Clasificador\nbase_random_forest = RandomForestClassifier()\n\n#se decidio por optimizar F1 score\nscorer_fn = make_scorer(sk.metrics.f1_score)\n\n#Random Search Cross Validation\nrandomcv_random_forest = RandomizedSearchCV(estimator=base_random_forest,\n                              param_distributions = parametros_RF,\n                              scoring=scorer_fn,\n                              cv=kfoldcv,\n                              n_iter=n,\n                              random_state=4)\n\n#Busco los hiperparametros que optimizan F1 Score\nrandomcv_random_forest.fit(x_train2,y_train2)\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"RandomizedSearchCV(cv=StratifiedKFold(n_splits=5, random_state=None, shuffle=False),\n                   estimator=RandomForestClassifier(), n_iter=15,\n                   param_distributions={'ccp_alpha': array([0.        , 0.00357143, 0.00714286, 0.01071429, 0.01428571,\n       0.01785714, 0.02142857, 0.025     , 0.02857143, 0.03214286,\n       0.03571429, 0.03928571, 0.04285714, 0.04642857, 0.05      ]),\n                                        'criterion': ['gini', 'entropy'],\n                                        'max_depth': [1, 3, 5, 7, 9, 11, 13, 15,\n                                                      17, 19]},\n                   random_state=4, scoring=make_scorer(f1_score))","metadata":{}},{"cell_type":"code","source":"#print(randomcv_random_forest.best_params_)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"{'max_depth': 17, 'criterion': 'entropy', 'ccp_alpha': 0.0}\n","metadata":{}},{"cell_type":"code","source":"#best_random_forest = RandomForestClassifier(max_depth = 17, criterion=\"entropy\", ccp_alpha=0)\n#best_random_forest.fit(x_train2, y_train2)\nbest_random_forest = joblib.load('/kaggle/input/ds-trabajo-rf/ds_trabajo_RFpca.joblib')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#joblib.dump(best_random_forest, \"./ds_trabajo_RFpca.joblib\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"RF_pred = best_random_forest.predict(x_test2)\nRF_precision = precision_score(y_test2, RF_pred)\nRF_recall = recall_score(y_test2, RF_pred)\nRF_f1 = f1_score(y_test2, RF_pred)\nprint(\"Random Forest Precision: \" + str(RF_precision))\nprint(\"Random Forest Recall: \" + str(RF_recall))\nprint(\"Random Forest F1 Score: \" + str(RF_f1))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Random Forest Precision: 0.9764229331117574\n\nRandom Forest Recall: 0.9860499265785609\n\nRandom Forest F1 Score: 0.9812128170337124","metadata":{}},{"cell_type":"markdown","source":"**Random Forest con todas las variables**","metadata":{}},{"cell_type":"code","source":"ds_trabajo = pd.read_csv('/kaggle/input/ds-trabajo/ds_trabajo.csv')\nds_target = ds_trabajo['target'].copy()\nds_trabajo.drop('target', axis='columns', inplace=True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"x_train4, x_test4, y_train4, y_test4 = train_test_split(ds_trabajo, ds_target, test_size=0.2, random_state=2)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"x_train4.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.model_selection import StratifiedKFold, KFold,RandomizedSearchCV\nfrom sklearn.metrics import make_scorer\n\n\n#Cantidad de combinaciones a probar\nn=15\n\n#Conjunto de parámetros a usar\nparametros_RF = {'criterion':['gini','entropy'],\n               'ccp_alpha':np.linspace(0,0.05,n),\n               'max_depth':list(range(1,20,2))}\n                \n\n#Cantidad de splits para el Cross Validation\nsplits=5\n\n#Kfold estratificado\nkfoldcv = StratifiedKFold(n_splits=splits)\n\n#Clasificador\nbase_random_forest = RandomForestClassifier()\n\n#se decidio por optimizar F1 score\nscorer_fn = make_scorer(sk.metrics.f1_score)\n\n#Random Search Cross Validation\nrandomcv_random_forest = RandomizedSearchCV(estimator=base_random_forest,\n                              param_distributions = parametros_RF,\n                              scoring=scorer_fn,\n                              cv=kfoldcv,\n                              n_iter=n,\n                              random_state=4)\n\n#Busco los hiperparametros que optimizan F1 Score\nrandomcv_random_forest.fit(x_train4,y_train4)\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#print(randomcv_random_forest.best_params_)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"{'max_depth': 17, 'criterion': 'entropy', 'ccp_alpha': 0.0}","metadata":{}},{"cell_type":"code","source":"#best_random_forest = RandomForestClassifier(max_depth = 17, criterion=\"entropy\", ccp_alpha=0)\n#best_random_forest.fit(x_train4, y_train4)\nbest_random_forest = joblib.load('/kaggle/input/ds-trabajo-rf/ds_trabajo_RF.joblib')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#joblib.dump(best_random_forest, \"./ds_trabajo_RF.joblib\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"RF_pred = best_random_forest.predict(x_test4)\nRF_precision = precision_score(y_test4, RF_pred)\nRF_recall = recall_score(y_test4, RF_pred)\nRF_f1 = f1_score(y_test4, RF_pred)\nprint(\"Random Forest Precision: \" + str(RF_precision))\nprint(\"Random Forest Recall: \" + str(RF_recall))\nprint(\"Random Forest F1 Score: \" + str(RF_f1))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Random Forest Precision: 0.7262477831264251\n\nRandom Forest Recall: 0.6013215859030837\n\n**Random Forest F1 Score: 0.6579068166169383**","metadata":{}},{"cell_type":"markdown","source":"**Ya se puede ir observando que tanto TSNE y PCA dan valores completamente desproporcionados en comparacion a usar todas las variables al ser mayores a este ultimo, lo cual no tiene ningun sentido**","metadata":{}},{"cell_type":"code","source":"import xgboost as xgb","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**gxboost con t-sne**","metadata":{}},{"cell_type":"code","source":"#xgb_model = xgb.XGBClassifier(random_state=0, n_estimators=100)\n#xgb_model.fit(x_train, y_train)\nxgb_model = xgb.XGBClassifier()\nxgb_model.load_model(\"/kaggle/input/ds-trabajoxgb/ds_trabajoXGB_TSNE.txt\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"XGBClassifier(base_score=0.5, booster='gbtree', callbacks=None,\n              colsample_bylevel=1, colsample_bynode=1, colsample_bytree=1,\n              early_stopping_rounds=None, enable_categorical=False,\n              eval_metric=None, gamma=0, gpu_id=-1, grow_policy='depthwise',\n              importance_type=None, interaction_constraints='',\n              learning_rate=0.300000012, max_bin=256, max_cat_to_onehot=4,\n              max_delta_step=0, max_depth=6, max_leaves=0, min_child_weight=1,\n              missing=nan, monotone_constraints='()', n_estimators=100,\n              n_jobs=0, num_parallel_tree=1, predictor='auto', random_state=0,\n              reg_alpha=0, reg_lambda=1, ...)","metadata":{}},{"cell_type":"code","source":"from sklearn.metrics import roc_auc_score\nfrom sklearn.metrics import confusion_matrix, classification_report\n\n#Evaluo en el set de test\ny_pred_proba= xgb_model.predict_proba(x_test)[:, 1]\nprint('AUC:',roc_auc_score(y_test, y_pred_proba))\n\n#Matriz de Confusion\ny_pred=xgb_model.predict(x_test)\n\ncm = confusion_matrix(y_test,y_pred)\nsns.heatmap(cm, cmap='Blues',annot=True,fmt='g')\nplt.xlabel('Predicted')\nplt.ylabel('True')\n\n#Reporte\nprint(classification_report(y_test,y_pred))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#xgb_model.save_model('ds_trabajoXGB_TSNE.txt')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**xgboost con PCA**","metadata":{}},{"cell_type":"code","source":"#xgb_model = xgb.XGBClassifier(random_state=0, n_estimators=100)\n#xgb_model.fit(x_train2, y_train2)\nxgb_model = xgb.XGBClassifier()\nxgb_model.load_model(\"/kaggle/input/ds-trabajoxgb/ds_trabajoXGB_PCA.txt\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"XGBClassifier(base_score=0.5, booster='gbtree', callbacks=None,\n              colsample_bylevel=1, colsample_bynode=1, colsample_bytree=1,\n              early_stopping_rounds=None, enable_categorical=False,\n              eval_metric=None, gamma=0, gpu_id=-1, grow_policy='depthwise',\n              importance_type=None, interaction_constraints='',\n              learning_rate=0.300000012, max_bin=256, max_cat_to_onehot=4,\n              max_delta_step=0, max_depth=6, max_leaves=0, min_child_weight=1,\n              missing=nan, monotone_constraints='()', n_estimators=100,\n              n_jobs=0, num_parallel_tree=1, predictor='auto', random_state=0,\n              reg_alpha=0, reg_lambda=1, ...)","metadata":{}},{"cell_type":"code","source":"#Evaluo en el set de test\ny_pred_proba2= xgb_model.predict_proba(x_test2)[:, 1]\nprint('AUC:',roc_auc_score(y_test2, y_pred_proba2))\n\n#Matriz de Confusion\ny_pred2=xgb_model.predict(x_test2)\n\ncm = confusion_matrix(y_test2,y_pred2)\nsns.heatmap(cm, cmap='Blues',annot=True,fmt='g')\nplt.xlabel('Predicted')\nplt.ylabel('True')\n\n#Reporte\nprint(classification_report(y_test2,y_pred2))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#xgb_model.save_model('ds_trabajoXGB_PCA.txt')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**xgboost con todas las variables**","metadata":{}},{"cell_type":"code","source":"#xgb_model = xgb.XGBClassifier(random_state=0, n_estimators=100)\n#xgb_model.fit(x_train4, y_train4)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"XGBClassifier(base_score=0.5, booster='gbtree', callbacks=None,\n              colsample_bylevel=1, colsample_bynode=1, colsample_bytree=1,\n              early_stopping_rounds=None, enable_categorical=False,\n              eval_metric=None, gamma=0, gpu_id=-1, grow_policy='depthwise',\n              importance_type=None, interaction_constraints='',\n              learning_rate=0.300000012, max_bin=256, max_cat_to_onehot=4,\n              max_delta_step=0, max_depth=6, max_leaves=0, min_child_weight=1,\n              missing=nan, monotone_constraints='()', n_estimators=100,\n              n_jobs=0, num_parallel_tree=1, predictor='auto', random_state=0,\n              reg_alpha=0, reg_lambda=1, ...)","metadata":{}},{"cell_type":"code","source":"xgb_model = xgb.XGBClassifier()\nxgb_model.load_model(\"/kaggle/input/ds-trabajoxgb/ds_trabajoXGB.txt\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Evaluo en el set de test\ny_pred_proba4= xgb_model.predict_proba(x_test4)[:, 1]\nprint('AUC:',roc_auc_score(y_test4, y_pred_proba4))\n\n#Matriz de Confusion\ny_pred4=xgb_model.predict(x_test4)\n\ncm = confusion_matrix(y_test4,y_pred4)\nsns.heatmap(cm, cmap='Blues',annot=True,fmt='g')\nplt.xlabel('Predicted')\nplt.ylabel('True')\n\n#Reporte\nprint(classification_report(y_test4,y_pred4))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**A pesar de ser un modelo al que no se le han optimizado los hiperparametros ya podemos ver que da mejor que random forest**","metadata":{}},{"cell_type":"code","source":"#xgb_model.save_model('ds_trabajoXGB.txt')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**SVM**","metadata":{}},{"cell_type":"markdown","source":"**Importante: tanto SVM como VC tardan demasiado en cargar desde el arhcivo por lo que vamos a obviar eso y mostrar los resultados directamente para que no se haga muy lento**","metadata":{}},{"cell_type":"markdown","source":"**SVM con tsne**","metadata":{}},{"cell_type":"code","source":"def metricas(y_pred,y_test):\n    print(classification_report(y_test,y_pred))\n    \n    cm = confusion_matrix(y_test,y_pred)\n    \n    sns.heatmap(cm, cmap='Blues',annot=True,fmt='g')\n    \n    plt.xlabel('Predicted')\n    plt.ylabel('True')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nsvm = SVC()\n#svm.fit(x_train, y_train)\nsvm = pickle.load(open('/kaggle/input/ds-trabajo-svm/ds_trabajo_SVMtsne', 'rb'))\ny_pred = svm.predict(x_test)\nmetricas(y_pred,y_test)\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nSVM_precision = precision_score(y_test, y_pred)\nSVM_recall = recall_score(y_test, y_pred)\nSVM_f1 = f1_score(y_test, y_pred)\nprint(\"SVM Precision: \" + str(SVM_precision))\nprint(\"SVM Recall: \" + str(SVM_recall))\nprint(\"SVM F1 Score: \" + str(SVM_f1))\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"SVM Precision: 0.7425828970331588\n\nSVM Recall: 0.5355569540591567\n\nSVM F1 Score: 0.6223034734917733","metadata":{}},{"cell_type":"code","source":"#pickle.dump(svm, open('ds_trabajo_SVMtsne', 'wb'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nsvm2 = SVC()\n#svm2.fit(x_train2, y_train2)\nsvm2 = pickle.load(open('/kaggle/input/ds-trabajo-svm/ds_trabajo_SVMpca', 'rb'))\ny_pred2 = svm2.predict(x_test2)\nmetricas(y_pred2,y_test2)\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nSVM_precision = precision_score(y_test2, y_pred2)\nSVM_recall = recall_score(y_test2, y_pred2)\nSVM_f1 = f1_score(y_test2, y_pred2)\nprint(\"SVM Precision: \" + str(SVM_precision))\nprint(\"SVM Recall: \" + str(SVM_recall))\nprint(\"SVM F1 Score: \" + str(SVM_f1))\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"SVM Precision: 0.9779028559516364\n\nSVM Recall: 0.9840570589469267\n\nSVM F1 Score: 0.980970305311585","metadata":{}},{"cell_type":"code","source":"#pickle.dump(svm2, open('ds_trabajo_SVMpca', 'wb'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nsvm4 = SVC()\n#svm4.fit(x_train4, y_train4)\nsvm4 = pickle.load(open('/kaggle/input/ds-trabajo-svm/ds_trabajo_SVM', 'rb'))\ny_pred4 = svm4.predict(x_test4)\nmetricas(y_pred4,y_test4)\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nSVM_precision = precision_score(y_test4, y_pred4)\nSVM_recall = recall_score(y_test4, y_pred4)\nSVM_f1 = f1_score(y_test4, y_pred4)\nprint(\"SVM Precision: \" + str(SVM_precision))\nprint(\"SVM Recall: \" + str(SVM_recall))\nprint(\"SVM F1 Score: \" + str(SVM_f1))\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"SVM Precision: 0.7212795230451732\n\nSVM Recall: 0.6598489616110762\n\nSVM F1 Score: 0.6891980718667836\n","metadata":{}},{"cell_type":"markdown","source":"**A pesar de no haber estandarizado los valores, vemos que SVM es por ahora el mejor modelo**","metadata":{}},{"cell_type":"code","source":"#pickle.dump(svm4, open('ds_trabajo_SVM', 'wb'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Árbol de decision**","metadata":{}},{"cell_type":"markdown","source":"**tsne**","metadata":{}},{"cell_type":"code","source":"\"\"\"\nfrom sklearn.model_selection import StratifiedKFold, KFold,RandomizedSearchCV\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.metrics import make_scorer\nn=15\nparametros_DT = {'criterion':['gini','entropy'],\n               'ccp_alpha':np.linspace(0,0.05,n),\n               'max_depth':list(range(1,20,2))}\n#cantidad de splits para cross validation\nsplits=5\n\nkfoldcv = StratifiedKFold(n_splits=splits)\n\nbase_tree = DecisionTreeClassifier()\n\n#se decidio por optimizar F1 score\nscorer_fn = make_scorer(sk.metrics.f1_score)\n\n#candom Search Cross Validation\nrandomcv = RandomizedSearchCV(estimator=base_tree,\n                              param_distributions = parametros_DT,\n                              scoring=scorer_fn,\n                              cv=kfoldcv,\n                              n_iter=n,\n                              random_state=4)\n\n#Busco los hiperparamtros que optimizan F1 Score\nrandomcv.fit(x_train,y_train);\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#print(randomcv.best_params_)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"{'max_depth': 13, 'criterion': 'gini', 'ccp_alpha': 0.0}","metadata":{}},{"cell_type":"code","source":"\"\"\"\n#Creo el árbol con los mejores hiperparámetros\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.tree import export_text\n\n#best_decision_tree=DecisionTreeClassifier().set_params(**randomcv.best_params_)\nbest_tree=DecisionTreeClassifier(max_depth=13, criterion='gini', ccp_alpha=0.0)\n\nbest_tree.fit(x_train, y_train)\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#joblib.dump(best_tree, \"./ds_trabajo_BTtsne.joblib\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"best_tree = joblib.load('/kaggle/input/ds-trabajo-dt/ds_trabajo_BTtsne.joblib')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"DT_pred = best_tree.predict(x_test)\nDT_precision = precision_score(y_test, DT_pred)\nDT_recall = recall_score(y_test, DT_pred)\nDT_f1 = f1_score(y_test, DT_pred)\nprint(\"Árbol de decisión Precision: \" + str(DT_precision))\nprint(\"Árbol de decisión Recall: \" + str(DT_recall))\nprint(\"Árbol de decisión F1 Score: \" + str(DT_f1))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Árbol de decisión Precision: 0.7876008398718091\n\nÁrbol de decisión Recall: 0.7475351374029788\n\nÁrbol de decisión F1 Score: 0.7670451487919067","metadata":{}},{"cell_type":"code","source":"DT_resultados=pd.DataFrame(zip(y_test,DT_pred),columns=['test','pred'])\nDT_resultados.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"tabla=confusion_matrix(DT_resultados['test'], DT_resultados['pred'])\n\ngrf=sns.heatmap(tabla,annot=True)\nplt.show()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nfrom sklearn.model_selection import StratifiedKFold, KFold,RandomizedSearchCV\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.metrics import make_scorer\nn=15\nparametros_DT = {'criterion':['gini','entropy'],\n               'ccp_alpha':np.linspace(0,0.05,n),\n               'max_depth':list(range(1,20,2))}\n#cantidad de splits para cross validation\nsplits=5\n\nkfoldcv = StratifiedKFold(n_splits=splits)\n\nbase_tree = DecisionTreeClassifier()\n\n#se decidio por optimizar F1 score\nscorer_fn = make_scorer(sk.metrics.f1_score)\n\n#candom Search Cross Validation\nrandomcv = RandomizedSearchCV(estimator=base_tree,\n                              param_distributions = parametros_DT,\n                              scoring=scorer_fn,\n                              cv=kfoldcv,\n                              n_iter=n,\n                              random_state=4)\n\n#Busco los hiperparamtros que optimizan F1 Score\nrandomcv.fit(x_train2,y_train2);\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#print(randomcv.best_params_)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"{'max_depth': 7, 'criterion': 'entropy', 'ccp_alpha': 0.0}","metadata":{}},{"cell_type":"code","source":"\"\"\"\n#Creo el árbol con los mejores hiperparámetros\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.tree import export_text\n\n#best_decision_tree=DecisionTreeClassifier().set_params(**randomcv.best_params_)\nbest_tree=DecisionTreeClassifier(max_depth=7, criterion='gini', ccp_alpha=0.0)\n\nbest_tree.fit(x_train2, y_train2)\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#joblib.dump(best_tree, \"./ds_trabajo_BTpca.joblib\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"best_tree = joblib.load('/kaggle/input/ds-trabajo-dt/ds_trabajo_BTpca.joblib')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"DT_pred = best_tree.predict(x_test2)\nDT_precision = precision_score(y_test2, DT_pred)\nDT_recall = recall_score(y_test2, DT_pred)\nDT_f1 = f1_score(y_test2, DT_pred)\nprint(\"Árbol de decisión Precision: \" + str(DT_precision))\nprint(\"Árbol de decisión Recall: \" + str(DT_recall))\nprint(\"Árbol de decisión F1 Score: \" + str(DT_f1))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Árbol de decisión Precision: 0.9675385092525587\n\nÁrbol de decisión Recall: 0.9816446402349486\n\nÁrbol de decisión F1 Score: 0.9745405320976727\n","metadata":{}},{"cell_type":"code","source":"DT_resultados=pd.DataFrame(zip(y_test2,DT_pred),columns=['test','pred'])\nDT_resultados.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"tabla=confusion_matrix(DT_resultados['test'], DT_resultados['pred'])\n\ngrf=sns.heatmap(tabla,annot=True)\nplt.show()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nfrom sklearn.model_selection import StratifiedKFold, KFold,RandomizedSearchCV\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.metrics import make_scorer\nn=15\nparametros_DT = {'criterion':['gini','entropy'],\n               'ccp_alpha':np.linspace(0,0.05,n),\n               'max_depth':list(range(1,20,2))}\n#cantidad de splits para cross validation\nsplits=5\n\nkfoldcv = StratifiedKFold(n_splits=splits)\n\nbase_tree = DecisionTreeClassifier()\n\n#se decidio por optimizar F1 score\nscorer_fn = make_scorer(sk.metrics.f1_score)\n\n#candom Search Cross Validation\nrandomcv = RandomizedSearchCV(estimator=base_tree,\n                              param_distributions = parametros_DT,\n                              scoring=scorer_fn,\n                              cv=kfoldcv,\n                              n_iter=n,\n                              random_state=4)\n\n#Busco los hiperparamtros que optimizan F1 Score\nrandomcv.fit(x_train4,y_train4);\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#print(randomcv.best_params_)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"{'max_depth': 7, 'criterion': 'entropy', 'ccp_alpha': 0.05}","metadata":{}},{"cell_type":"code","source":"\"\"\"\n#Creo el árbol con los mejores hiperparámetros\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.tree import export_text\n\n#best_decision_tree=DecisionTreeClassifier().set_params(**randomcv.best_params_)\nbest_tree=DecisionTreeClassifier(max_depth=7, criterion='entropy', ccp_alpha=0.05)\n\nbest_tree.fit(x_train4, y_train4)\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#joblib.dump(best_tree, \"./ds_trabajo_BT.joblib\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"best_tree = joblib.load('/kaggle/input/ds-trabajo-dt/ds_trabajo_BT.joblib')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"DT_pred = best_tree.predict(x_test4)\nDT_precision = precision_score(y_test4, DT_pred)\nDT_recall = recall_score(y_test4, DT_pred)\nDT_f1 = f1_score(y_test4, DT_pred)\nprint(\"Árbol de decisión Precision: \" + str(DT_precision))\nprint(\"Árbol de decisión Recall: \" + str(DT_recall))\nprint(\"Árbol de decisión F1 Score: \" + str(DT_f1))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Árbol de decisión Precision: 0.5114508393285372\n\nÁrbol de decisión Recall: 0.894797566603734\n\nÁrbol de decisión F1 Score: 0.6508735790035859","metadata":{}},{"cell_type":"markdown","source":"**Sin lugar a dudas arbol de decision es el peor modelo hasta ahora pero tiene la particularidad de haber maximizado recall, algo a tener en cuenta a futuro**","metadata":{}},{"cell_type":"code","source":"DT_resultados=pd.DataFrame(zip(y_test4,DT_pred),columns=['test','pred'])\nDT_resultados.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"tabla=confusion_matrix(DT_resultados['test'], DT_resultados['pred'])\n\ngrf=sns.heatmap(tabla,annot=True)\nplt.show()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**VotingClassifier**","metadata":{}},{"cell_type":"code","source":"from sklearn.ensemble import RandomForestClassifier \nfrom sklearn.linear_model import LogisticRegression \nfrom sklearn.neighbors import KNeighborsClassifier\nfrom sklearn.ensemble import VotingClassifier\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import accuracy_score","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Creo clasificadores\n\nfrom sklearn.pipeline import make_pipeline\n\nRF_clf = RandomForestClassifier()\nXGB_clf = xgb.XGBClassifier()\nDT_clf = DecisionTreeClassifier()\nSVM = SVC()\n\n#Creo ensemble de Votación\nvot_clf = VotingClassifier(estimators = [('RF', RF_clf), ('xgb', XGB_clf), ('dt', DT_clf),('svm',SVM)], voting = 'hard')\n\n#Armo conjunto entrenamiento y test 80-20\n#x_train, x_test, y_train, y_test = train_test_split(x, y, random_state = 42, train_size = 0.80)\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\n#Entreno el ensemble\n#vot_clf.fit(x_train, y_train)\nvot_clf = pickle.load(open('/kaggle/input/ds-trabajo-vc/ds_trabajo_VCtsne2', 'rb'))\n#Evaluo en conjunto de test\npred = vot_clf.predict(x_test)\naccuracy_score(y_test, pred)\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nVC_precision = precision_score(y_test, pred)\nVC_recall = recall_score(y_test, pred)\nVC_f1 = f1_score(y_test, pred)\nprint(\"VC Precision: \" + str(VC_precision))\nprint(\"VC Recall: \" + str(VC_recall))\nprint(\"VC F1 Score: \" + str(VC_f1))\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"0.9008313135660407","metadata":{}},{"cell_type":"markdown","source":"VC Precision: 0.8246033744648703\n\nVC Recall: 0.6869100062932662\n\nVC F1 Score: 0.7494850080109865","metadata":{}},{"cell_type":"code","source":"#pickle.dump(vot_clf, open('ds_trabajo_VCtsne2', 'wb'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\n#Entreno el ensemble\n#vot_clf.fit(x_train2, y_train2)\nvot_clf = pickle.load(open('/kaggle/input/ds-trabajo-vc/ds_trabajo_VCpca2', 'rb'))\n#Evaluo en conjunto de test\npred = vot_clf.predict(x_test2)\naccuracy_score(y_test2, pred)\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nVC_precision = precision_score(y_test2, pred)\nVC_recall = recall_score(y_test2, pred)\nVC_f1 = f1_score(y_test2, pred)\nprint(\"VC Precision: \" + str(VC_precision))\nprint(\"VC Recall: \" + str(VC_recall))\nprint(\"VC F1 Score: \" + str(VC_f1))\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"VC Precision: 0.9796858638743455\n\nVC Recall: 0.9813299769246906\n\nVC F1 Score: 0.9805072311884301","metadata":{}},{"cell_type":"markdown","source":"0.9915736063605681\n","metadata":{}},{"cell_type":"code","source":"#pickle.dump(vot_clf, open('ds_trabajo_VCpca2', 'wb'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\n#Entreno el ensemble\n#vot_clf.fit(x_train4, y_train4)\nvot_clf = pickle.load(open('/kaggle/input/ds-trabajo-vc/ds_trabajo_VC2', 'rb'))\n#Evaluo en conjunto de test\npred = vot_clf.predict(x_test4)\naccuracy_score(y_test4, pred)\nprecision_score(y_test4, pred)\nrecall_score(y_test4, pred)\nf1_score(y_test4, pred)\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nVC_precision = precision_score(y_test4, pred)\nVC_recall = recall_score(y_test4, pred)\nVC_f1 = f1_score(y_test4, pred)\nprint(\"VC Precision: \" + str(VC_precision))\nprint(\"VC Recall: \" + str(VC_recall))\nprint(\"VC F1 Score: \" + str(VC_f1))\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"0.86796384805309530.8679638480530953\n0.8679638480530953\n0.8679638480530953\n","metadata":{}},{"cell_type":"markdown","source":"VC Precision: 0.7326384528444054\n\nVC Recall: 0.6119152506817706\n\nVC F1 Score: 0.6668571755158028","metadata":{}},{"cell_type":"markdown","source":"**A pesar de haber usado los modelos base, votincclassifier dio relativamente bien por lo que se considerara a futuro una posible optimizacion**","metadata":{}},{"cell_type":"code","source":"#pickle.dump(vot_clf, open('ds_trabajo_VC2', 'wb'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Redes neuronales**","metadata":{}},{"cell_type":"code","source":"from IPython.core.pylabtools import figsize\nimport pandas as pd\nimport numpy as np\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nimport tensorflow as tf\nfrom sklearn.model_selection import train_test_split\nfrom tensorflow.keras.models import Sequential , Model\nfrom tensorflow.keras.layers import Dense, Dropout, Input, Dot, Flatten #keras tiene capas para armar la red capa a capa\nfrom tensorflow.keras.optimizers import Adam\nfrom tensorflow.keras.callbacks import EarlyStopping\nfrom tensorflow.keras.losses import BinaryCrossentropy\nfrom sklearn.preprocessing import OneHotEncoder\nfrom sklearn.preprocessing  import StandardScaler\nfrom sklearn.metrics import confusion_matrix, classification_report","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Para hacer un poco mas sensillo el apartado de redes neuronales vamos a obviar los dataset reducidos, en parte porque tenemos la sospecha de que algo está mal con ellos al tener en general mejores resultados que el dataset con la mayor parte de las variable a pesar de que deberían perder bastante informacion","metadata":{}},{"cell_type":"code","source":"def get_pred(y_pred):\n  preds = []\n  index = 0\n  for value in y_pred:\n    if (value < 0.5):\n      preds.append(0)\n    else:\n      preds.append(1)\n  return preds","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def metricas(y_pred,y_test):\n\n    print(classification_report(y_test,y_pred))\n    \n    cm = confusion_matrix(y_test,y_pred)\n    \n    sns.heatmap(cm, cmap='Blues',annot=True,fmt='g')\n    \n    plt.xlabel('Predicted')\n    plt.ylabel('True')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model1 = Sequential([Input((80,))])\nmodel1.add(Dense(512, activation='relu'))\nmodel1.add(Dense(256, activation='relu'))\nmodel1.add(Dense(128, activation='relu'))\nmodel1.add(Dense(64, activation='sigmoid'))\nmodel1.add(Dense(32, activation='relu'))\nmodel1.add(Dense(16, activation='relu'))\nmodel1.add(Dense(1, activation='sigmoid'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model1.compile(loss=BinaryCrossentropy(),\n              optimizer=Adam(0.001),\n              metrics='accuracy')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#hst1 = model1.fit(x_train4, y_train4, validation_split=0.1, epochs=60, batch_size=128)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"¿Estatexto del enlacemos frente a un modelo de red neuronal que tiene una precision del 99%?\nVeamos que dicen los graficos","metadata":{}},{"cell_type":"code","source":"import json","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### \"\"\"\nmodel1.save(\"ds_trabajo_RN1.h5\")\nhistory_dict1 = hst1.history\njson.dump(history_dict1, open('ds_trabajo_RNH1', 'w'))\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2022-08-01T02:01:28.622383Z","iopub.execute_input":"2022-08-01T02:01:28.622797Z","iopub.status.idle":"2022-08-01T02:01:28.672360Z","shell.execute_reply.started":"2022-08-01T02:01:28.622761Z","shell.execute_reply":"2022-08-01T02:01:28.671381Z"}}},{"cell_type":"code","source":"model1 = tf.keras.models.load_model('/kaggle/input/ds-trabajo-rn/ds_trabajo_RN1.h5')\nhistory_dict1 = json.load(open('/kaggle/input/ds-trabajo-rn/ds_trabajo_RNH1', 'r'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.figure(dpi = 180)\nplt.plot( history_dict1['accuracy'] , label =  'Train acc' )\nplt.plot( history_dict1['val_accuracy'] , label = 'Test acc'  )\nplt.legend()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"El plot nos muestra dos funciones, la azul como aumenta la precision a medida de que la red se entrena, en cambio en el naranja tenemos lo contrario vemos que a medida de que la red se entrena el modelo con los datos de testeo empeora.","metadata":{}},{"cell_type":"code","source":"plt.figure(dpi = 180)\nplt.plot( history_dict1['loss'] , label =  'Train err')\nplt.plot( history_dict1['val_loss'] , label = 'Test err')\nplt.legend()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"y_pred1 = model1.predict(x_test4)\ny_pred1 = get_pred(y_pred1)\nmetricas(y_pred1, y_test4)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Este grafico nos deja mucho mas claro el OVERFITTING que sufre la red, dado que a medida de que esta se entrena el error aumenta considerablemente.\n\nClaro ejemplo donde la red no generaliza, tenemos overfitting...\n\nComo primera medida para combatir con el overfiting, comenzaremos por quitar capas a la red y sumarle tecnicas de robustez, utilizando dropout","metadata":{}},{"cell_type":"code","source":"model2 = Sequential([Input((80,))])\nmodel2.add(Dense(64, activation='relu'))\nmodel2.add(Dense(32, activation='relu'))\nmodel2.add(Dense(16, activation='sigmoid'))\nmodel2.add(Dense(8, activation='relu'))\nmodel2.add(Dense(4, activation='relu'))\nmodel2.add(Dense(1, activation='sigmoid'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Ahora entrenaremos casi 21 mil parametros","metadata":{}},{"cell_type":"code","source":"model2.compile(loss=BinaryCrossentropy(),\n              optimizer=Adam(0.001),\n              metrics='accuracy')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#hst2 = model2.fit(x_train4, y_train4, validation_split=0.1, epochs=60, batch_size=128)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"90% de precision, comprobaremos si estamos en la misma situacion","metadata":{}},{"cell_type":"code","source":"\"\"\"\nmodel2.save(\"ds_trabajo_RN2.h5\")\nhistory_dict2 = hst2.history\njson.dump(history_dict2, open('ds_trabajo_RNH2', 'w'))\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model2 = tf.keras.models.load_model('/kaggle/input/ds-trabajo-rn/ds_trabajo_RN2.h5')\nhistory_dict2 = json.load(open('/kaggle/input/ds-trabajo-rn/ds_trabajo_RNH2', 'r'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.figure(dpi = 180)\nplt.plot( history_dict2['accuracy'] , label =  'Train acc' )\nplt.plot( history_dict2['val_accuracy'] , label = 'Test acc'  )\nplt.legend()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.figure(dpi = 180)\nplt.plot( history_dict2['loss'] , label =  'Train err' )\nplt.plot( history_dict2['val_loss'] , label = 'Test err'  )\nplt.legend()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"y_pred2 = model2.predict(x_test4)\ny_pred2 = get_pred(y_pred2)\nmetricas(y_pred, y_test4)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Este modelo, aunque sigue teniendo problemas de generalizacion, es mucho mejor que el anterior, vemos que el modelo anterior su error rondaba por 0.8, con una pequeña modificacion en la arquitectura logramos reducir el error a 0.32\n\nAdemas de reducir la cantidad de neuronas y capaz, utilizaremos tecnicas de dropout para aumentar la robustez de la red","metadata":{}},{"cell_type":"code","source":"model3 = Sequential([Input((80,))])\nmodel3.add(Dense(64, activation='relu'))\nmodel3.add(Dropout(0.25))\nmodel3.add(Dense(32, activation='relu'))\nmodel3.add(Dropout(0.5))\nmodel3.add(Dense(16, activation='sigmoid'))\nmodel3.add(Dropout(0.25))\nmodel3.add(Dense(8, activation='relu'))\nmodel3.add(Dropout(0.5))\nmodel3.add(Dense(4, activation='relu'))\nmodel3.add(Dropout(0.25))\nmodel3.add(Dense(1, activation='sigmoid'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model3.compile(loss=BinaryCrossentropy(),\n              optimizer=Adam(0.001),\n              metrics='accuracy')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#hst3 = model3.fit(x_train4, y_train4, validation_split=0.1, epochs=60, batch_size=128)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nmodel3.save(\"ds_trabajo_RN3.h5\")\nhistory_dict3 = hst3.history\njson.dump(history_dict3, open('ds_trabajo_RNH3', 'w'))\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model3 = tf.keras.models.load_model('/kaggle/input/ds-trabajo-rn/ds_trabajo_RN3.h5')\nhistory_dict3 = json.load(open('/kaggle/input/ds-trabajo-rn/ds_trabajo_RNH3', 'r'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.figure(dpi = 180)\nplt.plot( history_dict3['loss'] , label =  'Train loss' )\nplt.plot( history_dict3['val_loss'] , label = 'Valid loss'  )\nplt.legend()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.figure(dpi = 180)\nplt.plot( history_dict3['accuracy'] , label =  'Train loss' )\nplt.plot( history_dict3['val_accuracy'] , label = 'Valid loss'  )\nplt.legend()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"y_pred3 = model3.predict(x_test4)\ny_pred3 = get_pred(y_pred3)\nmetricas(y_pred3, y_test4)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Ahora si vemos que la red aumento considerablemente la robustez, esto se ve reflejado en el pequeño error que ahora comete cuando predice con datos que nunca bien, veamos si podemos seguir mejorando la arquitectura","metadata":{}},{"cell_type":"code","source":"model4 = Sequential([Input((80,))])\nmodel4.add(Dense(64, activation='tanh'))\nmodel4.add(Dropout(0.25))\nmodel4.add(Dense(32, activation='tanh'))\nmodel4.add(Dropout(0.5))\nmodel4.add(Dense(16, activation='sigmoid'))\nmodel4.add(Dropout(0.25))\nmodel4.add(Dense(8, activation='tanh'))\nmodel4.add(Dropout(0.5))\nmodel4.add(Dense(4, activation='tanh'))\nmodel4.add(Dropout(0.25))\nmodel4.add(Dense(1, activation='sigmoid'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model4.compile(loss=BinaryCrossentropy(),\n              optimizer=Adam(0.001),\n              metrics='accuracy')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#hst4 = model4.fit(x_train4, y_train4, validation_split=0.1, epochs=60, batch_size=128)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nmodel4.save(\"ds_trabajo_RN4.h5\")\nhistory_dict4 = hst4.history\njson.dump(history_dict4, open('ds_trabajo_RNH4', 'w'))\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model4 = tf.keras.models.load_model('/kaggle/input/ds-trabajo-rn/ds_trabajo_RN4.h5')\nhistory_dict4 = json.load(open('/kaggle/input/ds-trabajo-rn/ds_trabajo_RNH4', 'r'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.figure(dpi = 180)\nplt.plot( history_dict4['loss'] , label =  'Train loss' )\nplt.plot( history_dict4['val_loss'] , label = 'Valid loss'  )\nplt.legend()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.figure(dpi = 180)\nplt.plot( history_dict4['accuracy'] , label =  'Train loss' )\nplt.plot( history_dict4['val_accuracy'] , label = 'Valid loss'  )\nplt.legend()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"y_pred4 = model4.predict(x_test4)\ny_pred4 = get_pred(y_pred4)\nmetricas(y_pred4, y_test4)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"En esta version mejoramos la red con los datos de entrenamiento y de testeo\n\nAhora con esta arquitectura modificamos un poco la cantidad de parametros","metadata":{}},{"cell_type":"code","source":"model5 = Sequential([Input((80,))])\nmodel5.add(Dense(128, activation='tanh'))\nmodel5.add(Dropout(0.5))\nmodel5.add(Dense(64, activation='tanh'))\nmodel5.add(Dropout(0.5))\nmodel5.add(Dense(32, activation='sigmoid'))\nmodel5.add(Dropout(0.25))\nmodel5.add(Dense(16, activation='tanh'))\nmodel5.add(Dropout(0.5))\nmodel5.add(Dense(8, activation='tanh'))\nmodel5.add(Dropout(0.25))\nmodel5.add(Dense(1, activation='sigmoid'))\nmodel5.compile(loss=BinaryCrossentropy(),\n              optimizer=Adam(0.001),\n              metrics='accuracy')\n#hst5 = model5.fit(x_train4, y_train4, validation_split=0.1, epochs=60, batch_size=128)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nmodel5.save(\"ds_trabajo_RN5.h5\")\nhistory_dict5 = hst5.history\njson.dump(history_dict5, open('ds_trabajo_RNH5', 'w'))\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model5 = tf.keras.models.load_model('/kaggle/input/ds-trabajo-rn/ds_trabajo_RN5.h5')\nhistory_dict5 = json.load(open('/kaggle/input/ds-trabajo-rn/ds_trabajo_RNH5', 'r'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.figure(dpi = 180)\nplt.plot( history_dict5['accuracy'] , label =  'Train acc' )\nplt.plot( history_dict5['val_accuracy'] , label = 'Valid acc'  )\nplt.legend()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.figure(dpi = 180)\nplt.plot( history_dict5['loss'] , label =  'Train loss' )\nplt.plot( history_dict5['val_loss'] , label = 'Valid loss'  )\nplt.legend()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"y_pred5 = model5.predict(x_test4)\ny_pred5 = get_pred(y_pred5)\nmetricas(y_pred5, y_test4)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model6 = Sequential([Input((80,))])\nmodel6.add(Dense(128, activation='tanh'))\nmodel6.add(Dropout(0.5))\nmodel6.add(Dense(64, activation='tanh'))\nmodel6.add(Dropout(0.5))\nmodel6.add(Dense(32, activation='sigmoid'))\nmodel6.add(Dropout(0.5))\nmodel6.add(Dense(16, activation='tanh'))\nmodel6.add(Dropout(0.5))\nmodel6.add(Dense(8, activation='tanh'))\nmodel6.add(Dropout(0.5))\nmodel6.add(Dense(1, activation='sigmoid'))\nmodel6.compile(loss=BinaryCrossentropy(),\n              optimizer=Adam(0.001),\n              metrics='accuracy')\n#hst6 = model6.fit(x_train4, y_train4, validation_split=0.1, epochs=60, batch_size=128)\nmodel6 = tf.keras.models.load_model('/kaggle/input/ds-trabajo-rn/ds_trabajo_RN6.h5')\nhistory_dict6 = json.load(open('/kaggle/input/ds-trabajo-rn/ds_trabajo_RNH6', 'r'))\nplt.figure(dpi = 180)\nplt.plot( history_dict6['loss'] , label =  'Train loss' )\nplt.plot( history_dict6['val_loss'] , label = 'Valid loss'  )\nplt.legend()\nplt.figure(dpi = 180)\nplt.plot( history_dict6['accuracy'] , label =  'Train acc' )\nplt.plot( history_dict6['val_accuracy'] , label = 'Valid acc'  )\nplt.legend()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"y_pred6 = model6.predict(x_test4)\ny_pred6 = get_pred(y_pred6)\nmetricas(y_pred6, y_test4)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"type(y_pred6)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nmodel6.save(\"ds_trabajo_RN6.h5\")\nhistory_dict6 = hst6.history\njson.dump(history_dict6, open('ds_trabajo_RNH6', 'w'))\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"No tenemos overfitting","metadata":{}},{"cell_type":"code","source":"model7 = Sequential([Input((80,))])\nmodel7.add(Dense(128, activation='relu'))\nmodel7.add(Dropout(0.5))\nmodel7.add(Dense(128, activation='relu'))\nmodel7.add(Dropout(0.5))\nmodel7.add(Dense(64, activation='relu'))\nmodel7.add(Dropout(0.5))\nmodel7.add(Dense(64, activation='tanh'))\nmodel7.add(Dropout(0.5))\nmodel7.add(Dense(32, activation='relu'))\nmodel7.add(Dropout(0.5))\nmodel7.add(Dense(32, activation='relu'))\nmodel7.add(Dropout(0.5))\nmodel7.add(Dense(8, activation='relu'))\nmodel7.add(Dropout(0.5))\nmodel7.add(Dense(1, activation='sigmoid'))\n\nmodel7.compile(\n    optimizer=Adam(0.001),\n    loss='binary_crossentropy',\n    metrics=['binary_accuracy'],\n)\n\"\"\"\nhistory = model7.fit(\n    x_train4, y_train4,\n    validation_split=0.2,\n    epochs=150,\n    batch_size=96\n)\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nmodel7.save(\"ds_trabajo_RN7.h5\")\nhistory_dict7 = history.history\njson.dump(history_dict7, open('ds_trabajo_RNH7', 'w'))\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model7 = tf.keras.models.load_model('/kaggle/input/ds-trabajo-rn/ds_trabajo_RN7.h5')\nhistory_dict7 = json.load(open('/kaggle/input/ds-trabajo-rn/ds_trabajo_RNH7', 'r'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.figure(dpi = 180)\nplt.plot( history_dict7['loss'] , label =  'Train loss' )\nplt.plot( history_dict7['val_loss'] , label = 'Valid loss'  )\nplt.legend()\nplt.figure(dpi = 180)\nplt.plot( history_dict7['binary_accuracy'] , label =  'Train acc' )\nplt.plot( history_dict7['val_binary_accuracy'] , label = 'Valid acc'  )\nplt.legend()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"y_pred7 = model7.predict(x_test4)\ny_pred7 = get_pred(y_pred7)\nmetricas(y_pred7, y_test4)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Cascading**","metadata":{}},{"cell_type":"markdown","source":"Vamos a tomar como base el modelo 7 al cual le vamos a sumar el 6 y luego el 5\n\nBasicamente el modelo en cascada es pasar el set a analizar por el modelo 7, se sacan los valores que se consideran pagadores, se pasa lo que queda por el modelo 6, se vuelven a sacar los pagadores, se pasa por el modelo 5 y se comparan los resultados con el target\n","metadata":{}},{"cell_type":"markdown","source":"Tambien vamos a probar ir cambiando el umbral con el cual se califica a un resultado como pagador o no pagador","metadata":{}},{"cell_type":"code","source":"def get_predC(y_pred):\n  preds = []\n  index = 0\n  for value in y_pred:\n    if (value < 0.4):\n      preds.append(0)\n    else:\n      preds.append(1)\n  return preds","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"y_pred6 = model6.predict(x_test4)\ny_pred6 = get_predC(y_pred6)\nmetricas(y_pred6, y_test4)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"x_testC = x_test4.copy()\nx_testC.reset_index(inplace=True)\ny_testC = pd.DataFrame (y_pred7, columns = ['pred7'])\nx_testC['pred7'] = y_testC.copy()\nx_testC_Copy = x_testC.copy()\nx_testC.drop('index',axis='columns', inplace=True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#x_testC.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#x_testC_Copy.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#x_testC.info()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#x_testC_Copy.info()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"x_testC = x_testC.drop(x_testC[x_testC.pred7 == 0].index)\nx_testC_Copy = x_testC_Copy.drop(x_testC_Copy[x_testC_Copy.pred7 == 0].index)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#x_testC.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"x_testC.drop('pred7',axis='columns', inplace=True)\nx_testC_Copy.drop('pred7',axis='columns', inplace=True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#x_testC.info()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#x_testC_Copy.info()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def get_predC2(y_pred):\n  preds = []\n  index = 0\n  for value in y_pred:\n    if (value < 0.25):\n      preds.append(0)\n    else:\n      preds.append(1)\n  return preds","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"y_predC = model7.predict(x_testC)\ny_predC = get_predC2(y_predC)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#x_testC_Copy.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"x_testC.reset_index(inplace=True)\nx_testC_Copy.reset_index(inplace=True)\ny_testC = pd.DataFrame (y_predC, columns = ['pred6'])\nx_testC['pred6'] = y_testC.copy()\nx_testC_Copy['pred6'] = y_testC.copy()\nx_testC.drop('index',axis='columns', inplace=True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#x_testC_Copy.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#x_testC.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"x_testC = x_testC.drop(x_testC[x_testC.pred6 == 0].index)\nx_testC_Copy = x_testC_Copy.drop(x_testC_Copy[x_testC_Copy.pred6 == 0].index)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#x_testC.info()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#x_testC_Copy.info()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"x_testC.drop('pred6',axis='columns', inplace=True)\nx_testC_Copy.drop('pred6',axis='columns', inplace=True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def get_predC3(y_pred):\n  preds = []\n  index = 0\n  for value in y_pred:\n    if (value < 0.4):\n      preds.append(0)\n    else:\n      preds.append(1)\n  return preds","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"y_predC = model5.predict(x_testC)\ny_predC = get_predC3(y_predC)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"x_testC_Copy.rename(columns = {'level_0':'level_1'}, inplace = True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"x_testC.reset_index(inplace=True)\nx_testC_Copy.reset_index(inplace=True)\ny_testC = pd.DataFrame (y_predC, columns = ['pred5'])\nx_testC['pred5'] = y_testC.copy()\nx_testC_Copy['pred5'] = y_testC.copy()\nx_testC.drop('index',axis='columns', inplace=True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#x_testC.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#x_testC_Copy.info()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#x_testC.info()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#x_test4.info()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"ds_final = x_test4.copy()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"ds_final.reset_index(inplace=True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#ds_final.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"ds_final['target'] = y_test4.copy()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"final = pd.merge(ds_final,x_testC_Copy, how=\"outer\",on='index')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#final.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#final.info()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"final['pred5'] = final['pred5'].fillna(0)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"metricas(final['pred5'], y_test4)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Es cuestionable si este modelo es mejor que una red neural sola, aunque el F1-score ha aumentado en 0.02, fue a costa de un aumento en precision y disminucion en recall","metadata":{}},{"cell_type":"markdown","source":"**Conclusiones y mas**","metadata":{}},{"cell_type":"code","source":"#esto es una prueba de a ver que pasa si VC le doy los mejores modelos, cosa que no hicimos antes\n\"\"\"\nRF_clf = RandomForestClassifier(max_depth = 17, criterion=\"entropy\", ccp_alpha=0)\nXGB_clf = xgb.XGBClassifier(random_state=0, n_estimators=100)\nDT_clf = DecisionTreeClassifier(max_depth=7, criterion='gini', ccp_alpha=0.0)\nSVM = SVC()\n\n#Creo ensemble de Votación\nvot_clf = VotingClassifier(estimators = [('RF', RF_clf), ('xgb', XGB_clf), ('dt', DT_clf),('svm',SVM)], voting = 'hard')\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\n#Entreno el ensemble\n#vot_clf.fit(x_train4, y_train4)\nvot_clf = pickle.load(open('/kaggle/input/ds-trabajo-vc/ds_trabajo_VCopt', 'rb'))\n#Evaluo en conjunto de test\npred = vot_clf.predict(x_test4)\nVC_accuracy = accuracy_score(y_test4, pred)\nVC_precision = precision_score(y_test4, pred)\nVC_recall = recall_score(y_test4, pred)\nVC_f1 = f1_score(y_test4, pred)\nprint(\"VC Precision: \" + str(VC_precision))\nprint(\"VC Recall: \" + str(VC_recall))\nprint(\"VC F1 Score: \" + str(VC_f1))\nprint(\"VC Accuracy Score: \" + str(VC_accuracy))\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"VC Precision: 0.7369894388599059\n\nVC Recall: 0.6075099643381582\n\nVC F1 Score: 0.6660150635313056\n\nVC Accuracy Score: 0.8684168799691938","metadata":{}},{"cell_type":"markdown","source":"Comparamos con lo que nos habia dado en su momento VC","metadata":{}},{"cell_type":"markdown","source":"VC Precision: 0.7326384528444054\n\nVC Recall: 0.6119152506817706\n\nVC F1 Score: 0.6668571755158028","metadata":{}},{"cell_type":"markdown","source":"Nos dio mejor en precision y en F1-score, pero la diferencia en precision recien está en la 3er cifra mientras que F1-score solo es mejor en la 4ta cifra. Concluimos que la mejora es insignificante","metadata":{}},{"cell_type":"code","source":"#pickle.dump(vot_clf, open('ds_trabajo_VCopt', 'wb'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Como mejor modelo vamos a tomar SVM ya que fue junto con XGBoost el que dio mayor F1-score pero como anteriormente lo hicimos sin normalizar podemos estimar que al estandarizar los parametros va a dar mejor.","metadata":{}},{"cell_type":"code","source":"from sklearn import preprocessing\nstand_scaler = preprocessing.StandardScaler()\nx_train4_norm = stand_scaler.fit_transform(x_train4)\nx_test4_norm = stand_scaler.fit_transform(x_test4)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nsvm4 = SVC()\n#svm4.fit(x_train4_norm, y_train4)\nsvm4 = pickle.load(open('/kaggle/input/ds-trabajo-svm/ds_trabajo_SVM_norm', 'rb'))\ny_pred4_norm = svm4.predict(x_test4_norm)\nmetricas(y_pred4_norm,y_test4)\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#pickle.dump(svm4, open('ds_trabajo_SVM_norm', 'wb'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nSVM_precision = precision_score(y_test4, y_pred4_norm)\nSVM_recall = recall_score(y_test4, y_pred4_norm)\nSVM_f1 = f1_score(y_test4, y_pred4_norm)\nprint(\"VSM Precision: \" + str(SVM_precision))\nprint(\"VSM Recall: \" + str(SVM_recall))\nprint(\"VSM F1 Score: \" + str(SVM_f1))\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"VSM Precision: 0.7174908424908425\n\nVSM Recall: 0.6574365428990979\n\nVSM F1 Score: 0.686152162014231","metadata":{}},{"cell_type":"markdown","source":"Comparamos con lo que nos habia dado sin normalizar","metadata":{}},{"cell_type":"markdown","source":"SVM Precision: 0.7212795230451732\n\nSVM Recall: 0.6598489616110762\n\nSVM F1 Score: 0.6891980718667836","metadata":{}},{"cell_type":"markdown","source":"Las diferencias son insignificantes","metadata":{}},{"cell_type":"markdown","source":"Nos parecio llamativo que decision tree fue el unico modelo que, maximizando F1 score, dio recall mayor a presicion. Es planteable que recall podría ser un parametro a maximizar ya que nos interesa que se nos pasen por alto la menor cantidad de no pagadores posibles. Para eso vamos a entrenar un modelo buscando maximizar recall","metadata":{}},{"cell_type":"code","source":"\"\"\"\nfrom sklearn.model_selection import StratifiedKFold, KFold,RandomizedSearchCV\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.metrics import make_scorer\nn=15\nparametros_DT = {'criterion':['gini','entropy'],\n               'ccp_alpha':np.linspace(0,0.05,n),\n               'max_depth':list(range(1,20,2))}\n#cantidad de splits para cross validation\nsplits=5\n\nkfoldcv = StratifiedKFold(n_splits=splits)\n\nbase_tree = DecisionTreeClassifier()\n\n#se optimiza recall\nscorer_fn = make_scorer(sk.metrics.recall_score)\n\n#candom Search Cross Validation\nrandomcv = RandomizedSearchCV(estimator=base_tree,\n                              param_distributions = parametros_DT,\n                              scoring=scorer_fn,\n                              cv=kfoldcv,\n                              n_iter=n,\n                              random_state=4)\n\n#Busco los hiperparamtros que optimizan recall\nrandomcv.fit(x_train4,y_train4);\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#print(randomcv.best_params_)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"{'max_depth': 13, 'criterion': 'gini', 'ccp_alpha': 0.028571428571428574}\n","metadata":{}},{"cell_type":"code","source":"\"\"\"\n#Creo el árbol con los mejores hiperparámetros\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.tree import export_text\n\n#best_decision_tree=DecisionTreeClassifier().set_params(**randomcv.best_params_)\nbest_tree=DecisionTreeClassifier(max_depth=13, criterion='gini', ccp_alpha=0.028571428571428574)\n\nbest_tree.fit(x_train4, y_train4)\n\"\"\"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#joblib.dump(best_tree, \"./ds_trabajo_BTRecall.joblib\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"best_tree = joblib.load('/kaggle/input/ds-trabajo-dt/ds_trabajo_BTRecall.joblib')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"DT_pred = best_tree.predict(x_test4)\nDT_precision = precision_score(y_test4, DT_pred)\nDT_recall = recall_score(y_test4, DT_pred)\nDT_f1 = f1_score(y_test4, DT_pred)\nprint(\"Árbol de decisión Precision: \" + str(DT_precision))\nprint(\"Árbol de decisión Recall: \" + str(DT_recall))\nprint(\"Árbol de decisión F1 Score: \" + str(DT_f1))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Árbol de decisión Precision: 0.5437797416723318\n\nÁrbol de decisión Recall: 0.8389972729179778\n\nÁrbol de decisión F1 Score: 0.6598746081504703","metadata":{}},{"cell_type":"markdown","source":"Comparamos con lo que nos dio antes","metadata":{}},{"cell_type":"markdown","source":"Árbol de decisión Precision: 0.5114508393285372\n\nÁrbol de decisión Recall: 0.894797566603734\n\nÁrbol de decisión F1 Score: 0.6508735790035859","metadata":{}},{"cell_type":"markdown","source":"Curiosamente nos dio peor, suponemos que al buscar arboles de forma aleatoria el mejor que encontro esta vez no fue tan bueno como el mejor de la primera vez","metadata":{}},{"cell_type":"markdown","source":"## Ensamble en cascada con la mejor red neuronal","metadata":{}},{"cell_type":"code","source":"model8 = Sequential([Input((x_train.shape[1],))])\nmodel8.add(Dense(128, activation='relu'))\nmodel8.add(Dropout(0.5))\nmodel8.add(Dense(64, activation='relu'))\nmodel8.add(Dropout(0.5))\nmodel8.add(Dense(32, activation='relu'))\nmodel8.add(Dropout(0.5))\nmodel8.add(Dense(32, activation='relu'))\nmodel8.add(Dropout(0.5))\nmodel8.add(Dense(32, activation='relu'))\nmodel8.add(Dropout(0.5))\nmodel8.add(Dense(32, activation='relu'))\nmodel8.add(Dropout(0.5))\nmodel8.add(Dense(8, activation='tanh'))\nmodel8.add(Dropout(0.25))\nmodel8.add(Dense(4, activation='softmax'))\nmodel8.add(Dense(1, activation='sigmoid'))\n\nmodel8.compile(loss=BinaryCrossentropy(),\n              optimizer=Adam(0.001),\n              metrics='accuracy')\n\nearly_stopping = EarlyStopping(\n    monitor=\"val_loss\",\n    min_delta=0.15,\n    patience=50,\n    verbose=1,\n    mode=\"auto\",\n    baseline=None,\n    restore_best_weights=True,\n)\n\nhst6 = model8.fit(x_train, y_train, validation_split=0.35, epochs=100, batch_size=128, verbose=1)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def cascading(modelos, umbral, x_test, y_test):\n  resultados = pd.DataFrame(columns = [\"target\", \"preds\"])\n  x_test_en_cascada = x_test.copy()\n  y_test_en_cascada = y_test.copy()\n  for modelo in modelos:\n    model_prediction = modelo.predict(x_test_en_cascada) # si se quiere hacer un ensamble con un modelo que no sea una red hay q modificar esta llamada al .prediction\n    predicciones = pd.DataFrame(data = y_test_en_cascada)\n    predicciones[\"preds\"] = model_prediction\n    clasificacion = predicciones[predicciones[\"preds\"] > umbral]\n    clasificacion.loc[:, \"preds\"] = 1\n    resultados = pd.concat([resultados, clasificacion], axis = 0)\n    x_test_en_cascada.drop(clasificacion.index, inplace = True)\n    y_test_en_cascada.drop(clasificacion.index, inplace = True)\n  resultados[\"target\"] = resultados[\"target\"].astype(int)\n  resultados[\"preds\"] = resultados[\"preds\"].astype(int)\n  return resultados, x_test_en_cascada","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"modelos = [model8,model8,model8,model8,model8,model8,model8,model8,model8]","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"res,faltantes = cascading(modelos, 0.75, x_test, y_test)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"tabla = confusion_matrix(res['target'], res['preds'])\nsns.heatmap(tabla,annot=True, fmt='g')\nplt.xlabel('Predicted')\nplt.ylabel('True')","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Probamos con un umbral mucho mas fino","metadata":{}},{"cell_type":"code","source":"max_it = 50\numbral = 0.82\nbest_umbral = 0\nf1_max = -1\nresolution = 0.001\nfor i in range(max_it):\n  res,faltantes = cascading(modelos, umbral, x_test, y_test)\n  f1 = f1_score(res['target'], res['preds'])\n  if (f1 > f1_max):\n    f1_max = f1\n    print('\\nf1: {}'.format(f1_max))\n    print('umbral: {}\\n'.format(umbral))\n  else:\n    umbral += resolution","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"res,faltantes = cascading(modelos, umbral, x_test, y_test)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"tabla = confusion_matrix(res['target'], res['preds'])\nsns.heatmap(tabla,annot=True, fmt='g')\nplt.xlabel('Predicted')\nplt.ylabel('True')","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**¿Es posible detectar si un cliente va a dejar de pagar?**\n\nEn principio diriamos que no ya que o se nos escapan una cantidad significativa de no pagadores (recall bajo) o flagueamos pagadores como no pagadores frecuentemente (precision bajo)","metadata":{}},{"cell_type":"markdown","source":"**¿Qué información adicional creen que sería útil agregar?**\n\nes dificil asegurar que tipo de informacion nos podría resultar util al no saber con exactitud con qué tipo de variables contamos al comienzo. Tener mas ejemplos de no pagadores es lo unico que podría ayudar significativamente a simple vista y de esta manera los modelo podrian interpretar con mas informacion estos casos.","metadata":{}},{"cell_type":"markdown","source":"**¿Qué peso tendría la intervención humana si el sistema entrase en producción?**\n\nLa posicion que ocuparia una persona para este modelo es de vital importancia dado que el ensamble en cascada filtra los datos de los que esta seguro y de los que no pasan al siguiente modelo, de esta manera una vez finalizado el proceso de refinacion es posible que hallan datos a los que el modelo no pudo clasificar correctamente, por lo que una persona tendria que ver estos datos y definir a que tipo corresponden.","metadata":{}},{"cell_type":"markdown","source":"**¿Qué habría que tener en cuenta si se decide mantener actualizado el sistema a lo largo del tiempo?**\n\nPara mantener el sistema actualizado a lo largo del tiempo se requieren tener en cuenta varias cosas, por ejemplo por el lado de la arquitectura de la red neuronal si se quitasen columnas que no se consideren necesarias es posible que la arquitectura de la red se deba modificar para que se mantenga la precision a un valor deseado.","metadata":{}},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}