# Importamos las librerias import pandas as pd import numpy as np import plotly.express as px import seaborn as sns import matplotlib.pyplot as plt

## Obtenemos el dataset del historial crediticio historial_credito = pd.read_csv('data/credit_record.csv') ## Obtenemos el dataset del registro de aplicación de credito registro_aplicacion = pd.read_csv('data/application_record.csv')

registro_aplicacion.head()

historial_credito.head()

## Info de los datasets print(historial_credito.shape) historial_credito.info()

print(registro_aplicacion.shape) registro_aplicacion.info()

## Numero de datos nulos y su porcentaje en las columnas porcentaje_nulos = registro_aplicacion.isnull().mean().round(4) * 100 pd.merge(registro_aplicacion.isnull().sum().reset_index(), porcentaje_nulos.reset_index(), how='inner', on='index', suffixes=("_Valores Nulos", "_Porcentaje de valores nulos"))

## Combinar ambos dataframes para hacer un concentrado por ID data = pd.merge(historial_credito, registro_aplicacion, how='inner', on='ID') data

## Eliminamos columnas que no vamos a ocupar data.drop(['NAME_INCOME_TYPE', 'FLAG_PHONE', 'FLAG_MOBIL', 'FLAG_EMAIL', 'FLAG_WORK_PHONE', 'OCCUPATION_TYPE'], axis=1, inplace=True)

## Nos quedamos con el último mes de actividad data = data[data['MONTHS_BALANCE'] == 0] data

## Creamos la variable edad data['Edad'] = (data['DAYS_BIRTH'] / 365) * -1 ## Funcion lambda tiene_empleo = lambda x: True if x < 0 else False # Aplicamos la función a la nueva variable data['Empleo'] = data.DAYS_EMPLOYED.apply(tiene_empleo) ## Presentamos el DataFrame data

# Eliminamos las variables antiguas data.drop(['DAYS_BIRTH', 'DAYS_EMPLOYED'], axis=1, inplace=True)

# Checamos el tipo de dato de edad print(data.Edad.dtypes) # Lo pasamos a entero data['Edad'] = data['Edad'].astype(int) # Volvemos a checar el tipo de dato de edad print(data.Edad.dtypes)

# Vamos a renombrar la variable STATUS como target y vamos a reorganizar su contenido target = lambda x: 1 if x in ('C', 'X', '0') else 0 data['Target'] = data.STATUS.apply(target) data

# Vemos como esta la proporción de los buenos con los malos data.Target.value_counts()

# Eliminamos las columnas no necesarias data_procesada = data.drop(['MONTHS_BALANCE', 'STATUS', 'CODE_GENDER', 'NAME_FAMILY_STATUS', 'NAME_EDUCATION_TYPE', 'NAME_HOUSING_TYPE'], axis=1) data_procesada

# Ponemos el ID como index data_procesada.set_index('ID', inplace=True)

# Hacemos el cambio de variables booleanas a número data_procesada.FLAG_OWN_CAR = data_procesada.FLAG_OWN_CAR.replace({"Y": 1, "N": 0}) data_procesada.FLAG_OWN_REALTY = data_procesada.FLAG_OWN_REALTY.replace({"Y": 1, "N": 0}) data_procesada.Empleo = data_procesada.Empleo.replace({True: 1, False: 0})

data_procesada

data_procesada.describe().round()

# Histogramas fig, axs = plt.subplots(ncols=4, nrows=2, figsize=(20,10)) index = 0 axs = axs.flatten() for k,v in data_procesada.items(): sns.distplot(v, ax=axs[index]) index += 1 plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=5.0)

from scipy import stats fig, axs = plt.subplots(ncols=4, nrows=2, figsize=(20,10)) index = 0 axs = axs.flatten() for k,v in data_procesada.items(): sns.boxplot(y=k, data=data_procesada, ax=axs[index]) index += 1 plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=5.0)

for k, v in data_procesada.items(): q1 = v.quantile(0.25) q3 = v.quantile(0.75) irq = q3 - q1 v_col = v[(v <= q1 - 1.5 * irq) | (v >= q3 + 1.5 * irq)] perc = np.shape(v_col)[0] * 100.0 / np.shape(data_procesada)[0] print("Variable %s outliers = %.2f%%" % (k, perc))

data_limpia = data_procesada[data_procesada.AMT_INCOME_TOTAL <= 387000] data_limpia = data_limpia[data_procesada.CNT_CHILDREN <= 2] data_limpia = data_limpia[data_procesada.CNT_FAM_MEMBERS <= 4]

# Comparamos las filas entre dataframes print(data_procesada.shape) print(data_limpia.shape)

# Checamos que ya no haya outliers variables = ['CNT_CHILDREN', 'AMT_INCOME_TOTAL', 'CNT_FAM_MEMBERS'] fig, axes = plt.subplots(1, len(variables), figsize=(15,6)) for ax, variable in zip(axes, variables): ax = sns.boxplot( y=variable, data=data_limpia, ax=ax) plt.tight_layout() plt.show()

#Resulta más intuitivo ver la matriz de correlación a través de un gráfico - heatmap de seaborn plt.figure(figsize=(20,10)) #Defino el tamaño del grafico ## Definimos la correlación sns.heatmap(data_limpia.corr(), annot=True)

fig = px.scatter(data_limpia, x="Edad", y="AMT_INCOME_TOTAL", color="Target") fig.show()

data_limpia

# Convertimos nuestra variable Target a número para poder hacer la regresión logistica y las demás métricas data_limpia.Target = data_limpia.Target.replace({"Bueno": 1, "Malo": 0}) X = data_limpia.drop("Target", axis=1) #Elimino de mi dataset la variable a predecir y = data_limpia.Target #Defino el Target

# (Si no esta instalada la libreria) !pip install imblearn

# importamos SMOTE para el balanceo de los datos from imblearn.over_sampling import SMOTE sm = SMOTE(random_state = 2)

# Balanceamos la información X, y= sm.fit_resample(X, y) # Vemos como esta la proporción de los buenos con los malos y.value_counts()

from sklearn.model_selection import train_test_split #Importamos la libreria para separar en train y test #Me quedo con 30% para test y 70% para train X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=42)

from sklearn.tree import DecisionTreeClassifier #Importamos el modelo arbol_de_decision = DecisionTreeClassifier(max_depth=2, random_state = 42) #Creamos el modelo

arbol_de_decision.fit(X_train, y_train)

y_train_pred = arbol_de_decision.predict(X_train) #Prediccion en Train y_test_pred = arbol_de_decision.predict(X_test) #Prediccion en Test

from sklearn.metrics import accuracy_score #Calculo el accuracy en Train train_accuracy = accuracy_score(y_train, y_train_pred) #Calculo el accuracy en Test test_accuracy_decisionTree = accuracy_score(y_test, y_test_pred) print('% de aciertos sobre el set de entrenamiento:', train_accuracy) print('% de aciertos sobre el set de evaluación:',test_accuracy_decisionTree)

from sklearn.metrics import confusion_matrix from sklearn.metrics import ConfusionMatrixDisplay cm = confusion_matrix(y_test, y_test_pred, labels= arbol_de_decision.classes_) disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=arbol_de_decision.classes_) disp.plot() plt.show()

X = data_limpia.drop("Target", axis=1) #Elimino de mi dataset la variable a predecir y = data_limpia.Target #Defino el Target

# Balanceamos la información X, y= sm.fit_resample(X, y) # Vemos como esta la proporción de los buenos con los malos y.value_counts()

#Separamos en train y test! (X_train, X_test, y_train, y_test) = train_test_split(X, y, stratify=y, test_size=0.30, random_state=10)

# Importamos el modelo from sklearn.ensemble import RandomForestClassifier #Creamos un random forest! model = RandomForestClassifier(random_state=10, max_features="log2") model.fit(X_train, y_train)

y_train_pred = model.predict(X_train) #Prediccion en Train y_test_pred = model.predict(X_test) #Prediccion en Test

#Calculo el accuracy en Train train_accuracy = accuracy_score(y_train, y_train_pred) #Calculo el accuracy en Test test_accuracy_randomForest = accuracy_score(y_test, y_test_pred) print('% de aciertos sobre el set de entrenamiento:', train_accuracy) print('% de aciertos sobre el set de evaluación:',test_accuracy_randomForest)

cm = confusion_matrix(y_test, y_test_pred, labels= model.classes_) disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=model.classes_) disp.plot()

from sklearn.metrics import precision_score from sklearn.metrics import recall_score from sklearn.metrics import f1_score print("Recall:") # Calculo de recall en Train train_recall = recall_score(y_train, y_train_pred) # Calculo de recall en Test test_recall = recall_score(y_test, y_test_pred) print('% de recall sobre el set de entrenamiento:', train_recall) print('% de recall sobre el set de evaluación:', test_recall) print("Precisión:") # Calculo de precisión en Train train_precision = precision_score(y_train, y_train_pred) # Calculo de precisión en Test test_precision = precision_score(y_test, y_test_pred) print('% de precisión sobre el set de entrenamiento:', train_precision) print('% de precisión sobre el set de evaluación:', test_precision) print("F1 Score:") # Calculo de f1 score en Train train_f1_score = f1_score(y_train, y_train_pred) # Calculo de f1 score en Test test_f1_score = f1_score(y_test, y_test_pred) print('% de f1 score sobre el set de entrenamiento:', train_f1_score) print('% de f1_score sobre el set de evaluación:', test_f1_score)

## Separamos las data X = data_limpia.drop("Target", axis=1) #Elimino de mi dataset la variable a predecir y = data_limpia.Target #Defino el Target

X, y= sm.fit_resample(X, y) # Vemos como esta la proporción de los buenos con los malos y.value_counts()

#Separamos en train y test! (X_train, X_test, y_train, y_test) = train_test_split(X, y, stratify=y, test_size=0.30, random_state=11)

# Importamos la libreria del modelo from sklearn.linear_model import LogisticRegression # Creamos una instancia de la Regresión Logística regresion_logistica = LogisticRegression() # Entrenamos la regresión logística con los datos de entrenamiento regresion_logistica.fit(X_train,y_train)

y_train_pred = regresion_logistica.predict(X_train) #Prediccion en Train y_test_pred = regresion_logistica.predict(X_test) #Prediccion en Test

#Calculo el accuracy en Train train_accuracy = accuracy_score(y_train, y_train_pred) #Calculo el accuracy en Test test_accuracy_regresion = accuracy_score(y_test, y_test_pred) print('% de aciertos sobre el set de entrenamiento:', train_accuracy) print('% de aciertos sobre el set de evaluación:',test_accuracy_regresion)

print("Recall:") # Calculo de recall en Train train_recall = recall_score(y_train, y_train_pred) # Calculo de recall en Test test_recall = recall_score(y_test, y_test_pred) print('% de recall sobre el set de entrenamiento:', train_recall) print('% de recall sobre el set de evaluación:', test_recall) print("Precisión:") # Calculo de precisión en Train train_precision = precision_score(y_train, y_train_pred) # Calculo de precisión en Test test_precision = precision_score(y_test, y_test_pred) print('% de precisión sobre el set de entrenamiento:', train_precision) print('% de precisión sobre el set de evaluación:', test_precision) print("F1 Score:") # Calculo de f1 score en Train train_f1_score = f1_score(y_train, y_train_pred) # Calculo de f1 score en Test test_f1_score = f1_score(y_test, y_test_pred) print('% de f1 score sobre el set de entrenamiento:', train_f1_score) print('% de f1_score sobre el set de evaluación:', test_f1_score)

# Desplegamos los valores de cada modelo para compararlos print('% de aciertos sobre el set de evaluación del Árbol de decisión:',test_accuracy_decisionTree) print('% de aciertos sobre el set de evaluación del Random Forest:',test_accuracy_randomForest) print('% de aciertos sobre el set de evaluación de la Regresión Logistica:',test_accuracy_regresion)

from sklearn.model_selection import LeaveOneOut from sklearn.model_selection import cross_val_score from numpy import mean from numpy import std

X = data_limpia.drop("Target", axis=1) #Elimino de mi dataset la variable a predecir y = data_limpia.Target #Defino el Target

# Balanceo los datos X, y= sm.fit_resample(X, y) # Vemos como esta la proporción de los buenos con los malos y.value_counts()

#Creamos el modelo cv = LeaveOneOut()

# Decision Tree model = RandomForestClassifier(random_state=10, max_features="log2")

# Evaluacion del Modelo # scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)

import scipy as sp from sklearn.model_selection import RandomizedSearchCV from sklearn.metrics import confusion_matrix, accuracy_score from sklearn.metrics import classification_report

X = data_limpia.drop("Target", axis=1) #Elimino de mi dataset la variable a predecir y = data_limpia.Target #Defino el Target

# Balanceamos la data X, y= sm.fit_resample(X, y) # Vemos como esta la proporción de los buenos con los malos y.value_counts()

#Separamos en train y test! (X_train, X_test, y_train, y_test) = train_test_split(X, y, stratify=y, test_size=0.30, random_state=10)

#Creamos nuestro objeto Decision Tree random_forest = RandomForestClassifier()

# Grilla para Random Search param_dist = {'criterion': ['gini', 'entropy'], 'max_depth': sp.stats.randint(1, 20), 'min_samples_split': sp.stats.randint(1, 20), 'random_state': sp.stats.randint(1, 20), 'min_samples_leaf': sp.stats.randint(1, 20), 'max_features': ['auto', 'sqrt', 'log2']} #Aplicamos la grilla al modelo model = RandomizedSearchCV(random_forest, param_dist, n_iter=100, random_state=0, cv=5)

#Entrenamos DecisionTree con la grilla definida arriba y CV con tamaño de Fold=5 model.fit(X_train, y_train)

print("Mejores parametros: "+str(model.best_params_)) print("Mejor Score: "+str(model.best_score_)+'\n')

#Analizamos qué obtuvimos scores = pd.DataFrame(model.cv_results_) scores

#Prediccion prediction = model.predict(X_test)

#Accuracy print('Exactitud:', accuracy_score(y_test, prediction))

# Importamos la libreria del modelo from sklearn.ensemble import AdaBoostClassifier X = data_limpia.drop("Target", axis=1) #Elimino de mi dataset la variable a predecir y = data_limpia.Target #Defino el Target

# Balanceamos la data X, y= sm.fit_resample(X, y) # Vemos como esta la proporción de los buenos con los malos y.value_counts()

# Separación en Train y Test X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3) # 70% training y 30% test

# Creamos el modelo AdaBoostClassifier ada = AdaBoostClassifier(n_estimators=50, learning_rate=1) # Se fitea el modelo ada.fit(X_train, y_train)

# Predicción en Train y_train_pred = ada.predict(X_train) # Predicción en Test y_test_pred = ada.predict(X_test)

# Calculo de accuracy en Train train_accuracy = accuracy_score(y_train, y_train_pred) # Calculo de accuracy en Test test_accuracy = accuracy_score(y_test, y_test_pred) print('% de aciertos sobre el set de entrenamiento:', train_accuracy) print('% de aciertos sobre el set de evaluación:', test_accuracy)

cm = confusion_matrix(y_test, y_test_pred, labels= ada.classes_) disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=ada.classes_) disp.plot() plt.show()

print("Recall:") # Calculo de recall en Train train_recall = recall_score(y_train, y_train_pred) # Calculo de recall en Test test_recall = recall_score(y_test, y_test_pred) print('% de recall sobre el set de entrenamiento:', train_recall) print('% de recall sobre el set de evaluación:', test_recall) print("Precisión:") # Calculo de precisión en Train train_precision = precision_score(y_train, y_train_pred) # Calculo de precisión en Test test_precision = precision_score(y_test, y_test_pred) print('% de precisión sobre el set de entrenamiento:', train_precision) print('% de precisión sobre el set de evaluación:', test_precision) print("F1 Score:") # Calculo de f1 score en Train train_f1_score = f1_score(y_train, y_train_pred) # Calculo de f1 score en Test test_f1_score = f1_score(y_test, y_test_pred) print('% de f1 score sobre el set de entrenamiento:', train_f1_score) print('% de f1_score sobre el set de evaluación:', test_f1_score)

# Instalamos la libreria si no la tenemos !pip install xgboost

# Importamos la libreria del modelo import xgboost as xgb X = data_limpia.drop("Target", axis=1) #Elimino de mi dataset la variable a predecir y = data_limpia.Target #Defino el Target

# Balanceamos la data X, y= sm.fit_resample(X, y) # Vemos como esta la proporción de los buenos con los malos y.value_counts()

# Separación en Train y Test X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3) # 70% training y 30% test

clf_xgb = xgb.XGBClassifier(objective='binary:logistic', n_estimators=40, seed=123)

clf_xgb.fit(X_train, y_train)

# Predicción en Train y_train_pred = clf_xgb.predict(X_train) # Predicción en Test y_test_pred = clf_xgb.predict(X_test)

# Calculo de accuracy en Train train_accuracy = accuracy_score(y_train, y_train_pred) # Calculo de accuracy en Test test_accuracy = accuracy_score(y_test, y_test_pred) print('% de aciertos sobre el set de entrenamiento:', train_accuracy) print('% de aciertos sobre el set de evaluación:', test_accuracy)

cm = confusion_matrix(y_test, y_test_pred, labels= clf_xgb.classes_) disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=clf_xgb.classes_) disp.plot() plt.show()

print("Recall:") # Calculo de recall en Train train_recall = recall_score(y_train, y_train_pred) # Calculo de recall en Test test_recall = recall_score(y_test, y_test_pred) print('% de recall sobre el set de entrenamiento:', train_recall) print('% de recall sobre el set de evaluación:', test_recall) print("Precisión:") # Calculo de precisión en Train train_precision = precision_score(y_train, y_train_pred) # Calculo de precisión en Test test_precision = precision_score(y_test, y_test_pred) print('% de precisión sobre el set de entrenamiento:', train_precision) print('% de precisión sobre el set de evaluación:', test_precision) print("F1 Score:") # Calculo de f1 score en Train train_f1_score = f1_score(y_train, y_train_pred) # Calculo de f1 score en Test test_f1_score = f1_score(y_test, y_test_pred) print('% de f1 score sobre el set de entrenamiento:', train_f1_score) print('% de f1_score sobre el set de evaluación:', test_f1_score)