Clasificacion con Scikit Learn

y_pred = logistic_complete.predict(x_test)

ConfusionMatrixDisplay.from_predictions(y_test,y_pred);

acc = accuracy_score(y_test, y_pred)
prec = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
roc = roc_auc_score(y_test, y_pred)

print("accuracy_score : ", acc)
print("precision_score : ", prec)
print("recall_score : ", recall)
print("f1_score : ", f1)
print("roc_auc_score : ", roc)

from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
from sklearn.metrics import f1_score
from sklearn.metrics import roc_auc_score

from sklearn.linear_model import LogisticRegression
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.linear_model import SGDClassifier
from sklearn.svm import LinearSVC
from sklearn.neighbors import RadiusNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.tree import DecisionTreeClassifier

titanic_df = pd.read_parquet('titanic_processed.parquet')

x_train.columns

FEATURES = list(x_train.columns)

FEATURES

result_dict = {}

def summarize_classification(y_test, y_pred):
    
    acc = accuracy_score(y_test, y_pred, normalize=True)
    prec = precision_score(y_test, y_pred)
    recall = recall_score(y_test, y_pred)
    f1 = f1_score(y_test, y_pred)
    roc = roc_auc_score(y_test, y_pred)
    
    return {'accuracy': acc, 
            'precision': prec,
            'recall':recall,
            'f1':f1,
            'roc':roc
            }

def build_model(classifier_fn,                
                name_of_y_col: str, 
                names_of_x_cols: list, 
                dataset: pd.DataFrame, 
                test_frac:float =0.2)-> dict:
    """
    Funcion para entrenar un modelo de clasificacion
    
    Args:
        classifier_fn: funcion de clasificacion
        name_of_y_col (list): nombre de la columna objetivo
        names_of_x_cols (list): lista de nombres de las columnas de caracteristicas
        dataset (pd.Dataframe): dataframe con los datos
        test_frac (float): fraccion de datos para el test, por defecto 0.2
        
    Returns:
        dict: diccionario con las metricas de desempeño del modelo en train y test  
    
    """
    
    # separar las columnas de caracteristicas y la columna objetivo
    X = dataset[names_of_x_cols]
    Y = dataset[name_of_y_col]
    
    # dividir los datos en train y test
    x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=test_frac)
    
    # crear el pipeline con el preprocesamiento y el modelo de clasificacion
    classifier_pipe = Pipeline(steps=[("preprocessor", preprocessor),
                                      ("model", classifier_fn)])
    
    # entrenar el pipeline del clasificador   
    model = classifier_pipe.fit(x_train, y_train)
    
    # predecir los datos de test
    y_pred = model.predict(x_test)

    # predecir los datos de train
    y_pred_train = model.predict(x_train)
    
    # calcular las metricas de desempeño
    train_summary = summarize_classification(y_train, y_pred_train)
    test_summary = summarize_classification(y_test, y_pred)
    
    # guardar las metricas de desempeño en un dataframe
    pred_results = pd.DataFrame({'y_test': y_test,
                                 'y_pred': y_pred})
    
    # calcular la matriz de confusion
    model_crosstab = pd.crosstab(pred_results.y_pred, pred_results.y_test)
    
    return {'train': train_summary, 
            'test': test_summary,
            'confusion_matrix': model_crosstab}

result_dict['logistic'] = build_model(LogisticRegression(solver='liblinear'),
                                      'survived',
                                      FEATURES,
                                      titanic_df)

result_dict['logistic'] 

result_dict['linear_discriminant_analysis'] = build_model(LinearDiscriminantAnalysis(solver='svd'),
                                                          'survived',
                                                          FEATURES,
                                                          titanic_df)
result_dict['linear_discriminant_analysis']

result_dict['linear_discriminant_analysis'] = build_model(LinearDiscriminantAnalysis(solver='svd'),
                                                          'survived',
                                                          FEATURES,
                                                          titanic_df)
result_dict['linear_discriminant_analysis']

result_dict['sgd'] = build_model(SGDClassifier(max_iter=1000,
                                               tol=1e-3),
                                 'survived',
                                 FEATURES,
                                 titanic_df)

result_dict['sgd']

result_dict['linear_svc'] = build_model(LinearSVC(C=1.0,
                                                   max_iter=1000,
                                                   tol=1e-3,
                                                   dual=False),
                                        'survived',
                                        FEATURES,
                                        titanic_df)

result_dict['linear_svc']

result_dict['radius_neighbors'] = build_model(RadiusNeighborsClassifier(radius=40.0),
                                              'survived',
                                              FEATURES,
                                              titanic_df)
result_dict['radius_neighbors']

result_dict['decision_tree'] = build_model(DecisionTreeClassifier(),
                                           'survived',
                                           FEATURES,
                                           titanic_df)

result_dict['decision_tree']

result_dict['naive_bayes'] = build_model(GaussianNB(),
                                         'survived',
                                         FEATURES,
                                         titanic_df)

result_dict['naive_bayes']

# Crear un diccionario solo con los resultados de prueba de cada modelo
nombre_modelos = result_dict.keys()
resultados_train = {} # crear diccionario vacio
resultados_test = {} # crear diccionario vacio
for nombre in nombre_modelos:
    resultados_train[nombre] = result_dict[nombre]['train']['f1']
    resultados_test[nombre] = result_dict[nombre]['test']['f1']

df_comparacion = pd.DataFrame([resultados_train, resultados_test], index=['train', 'test'])

# Plot the bar chart
fig, ax = plt.subplots(figsize=(10, 4))
df_comparacion.T.plot(kind='bar', ax=ax)

# Adjust the layout
ax.set_ylabel('F1 score')
ax.set_title('Model F1 Comparison')

# Set the x-tick labels inside the bars and rotate by 90 degrees
ax.set_xticks(range(len(df_comparacion.columns)))
ax.set_xticklabels([])

# Draw the x-tick labels inside the bars rotated by 90 degrees
for i, label in enumerate(df_comparacion.columns):
    bar_center = (df_comparacion.loc['train', label] +
                  df_comparacion.loc['test', label]) / 2
    ax.text(i, bar_center, label, ha='center',
            va='center_baseline', rotation=45)

plt.tight_layout()

# Grabar los resultados de cada modelo
from sklearn import model_selection

models = []

#logistic Regression
models.append(('Logistic', LogisticRegression(solver='liblinear')))

# Decision Tree classifier
models.append(('Decision Tree', DecisionTreeClassifier()))

#
models.append(('LDA', LinearDiscriminantAnalysis(solver= 'svd')))

# evaluate each model in turn
results = []
names = []
scoring = 'f1'
for name, model in models:
    # Kfol cross validation for model selection
    kfold = model_selection.KFold(n_splits=10)
    model_pipe = Pipeline(steps=[("preprocessor", preprocessor),
                                 ("model", model)])
    #X train , y train
    cv_results = model_selection.cross_val_score(model_pipe,
                                                 x_train, y_train,
                                                 cv=kfold,
                                                 scoring=scoring)
    results.append(cv_results)
    names.append(name)
    msg = f"({name}, {cv_results.mean()}, {cv_results.std()}"
    print(msg)

plt.figure(figsize = (15,8)) 
result_df = pd.DataFrame(results, index=names).T
result_df.boxplot()
plt.title("Resultados de Cross Validation");

from scipy.stats import f_oneway

model1 = result_df['Logistic']
model2 = result_df['Decision Tree']
model3 = result_df['LDA']

statistic, p_value = f_oneway(model1, model2, model3)

print(f'Statistic: {statistic}')
print(f'p_value: {p_value}')

alpha = 0.05  # nivel de significancia

if p_value < alpha:
    print("Existe una diferencia estadísticamente significativa en los resultados de cross-validation de los modelos.")
else:
    print("No Existe una diferencia estadísticamente significativa en los resultados de cross-validation de los modelos.")

titanic_df = pd.read_parquet('titanic_processed.parquet')

X = titanic_df.drop('survived', axis='columns')

Y = titanic_df['survived']

x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.2)

def summarize_classification(y_test, y_pred):
    
    acc = accuracy_score(y_test, y_pred, normalize=True)
    f1 = f1_score(y_test, y_pred)

    prec = precision_score(y_test, y_pred)
    recall = recall_score(y_test, y_pred)
    roc = roc_auc_score(y_test, y_pred)
    
    
    print("Test data count: ",len(y_test))
    print("f1_score : " , f1)
    print("accuracy_score : " , acc)
    print("precision_score : " , prec)
    print("recall_score : ", recall)
    print("roc_auc_score : ", roc)

from sklearn.model_selection import GridSearchCV

# cuando se usan pipelines se debe usar 
# el nombre del paso y luego __ y el parametro
parameters = {'model__max_depth': [4, 5, 7, 9, 10],
              'model__max_features': [2, 3, 4, 5, 6, 7, 8, 9],
              'model__criterion': ['gini', 'entropy'],
              }

DecisionTree_pipe = Pipeline(steps=[("preprocessor", preprocessor),
                                    ("model", DecisionTreeClassifier())])

grid_search = GridSearchCV(DecisionTree_pipe,
                           parameters, cv=3,
                           scoring='f1',
                           return_train_score=True)
grid_search.fit(x_train, y_train)

tree_cv_results = pd.DataFrame(grid_search.cv_results_)

(tree_cv_results[['params', 'mean_test_score', 'mean_train_score']]
 .sort_values(by='mean_test_score', ascending=False)
 .head(10))

grid_search.best_params_

modelo = DecisionTreeClassifier(criterion='entropy',
                                max_depth=4,
                                max_features=8)

DecisionTree_pipe = Pipeline(steps=[("preprocessor", preprocessor),
                                    ("model", modelo)])

decision_tree_model = DecisionTree_pipe.fit(x_train, y_train)

y_pred = decision_tree_model.predict(x_test)

summarize_classification(y_test, y_pred)

# cuando se usan pipelines se debe usar
# el nombre del paso y luego __ y el parametro
parameters = {'model__penalty': ['l1', 'l2'], 
              'model__C': [0.1, 0.4, 0.8, 1, 2, 5]}

modelo = LogisticRegression(solver='liblinear')
logistic_pipe = Pipeline(steps=[("preprocessor", preprocessor),
                                ("model", modelo)])

grid_search = GridSearchCV(logistic_pipe,
                           parameters, cv=3,
                           scoring='f1',
                           return_train_score=True)
grid_search.fit(x_train, y_train)

reg_log_cv_results = pd.DataFrame(grid_search.cv_results_)

(reg_log_cv_results[['params', 'mean_test_score', 'mean_train_score']]
 .sort_values(by='mean_test_score', ascending=False)
 .head(10))

grid_search.best_params_

modelo = LogisticRegression(solver='liblinear',
                            C=0.4,
                            penalty='l2')
logistic_pipe = Pipeline(steps=[("preprocessor", preprocessor),
                                ("model", modelo)])

logistic_model = logistic_pipe.fit(x_train, y_train)

y_pred = logistic_model.predict(x_test)

summarize_classification(y_test, y_pred)

from sklearn.metrics import classification_report
from sklearn.metrics import PrecisionRecallDisplay
from sklearn.metrics import ConfusionMatrixDisplay

from sklearn.metrics import roc_curve
from sklearn.metrics import RocCurveDisplay

y_pred = decision_tree_model.predict(x_test)

print(classification_report(y_test, y_pred))

ConfusionMatrixDisplay.from_predictions(y_test,y_pred);

PrecisionRecallDisplay.from_predictions(y_test,y_pred);

dt_plot = RocCurveDisplay.from_estimator(decision_tree_model, x_test, y_test)
plt.show()

y_pred = logistic_model.predict(x_test)

print(classification_report(y_test, y_pred))

ConfusionMatrixDisplay.from_predictions(y_test,y_pred);

PrecisionRecallDisplay.from_predictions(y_test,y_pred);

log_plot = RocCurveDisplay.from_estimator(logistic_model, x_test, y_test)
plt.show()

ax = plt.gca()
dt_plot.plot(ax=ax, alpha=0.8)
log_plot.plot(ax=ax, alpha=0.8)
plt.title('ROC Curve - Decision Tree vs Logistic Regression')
plt.show()

dfFeatures = pd.DataFrame({'Features':decision_tree_model['preprocessor']
                                      .get_feature_names_out(),
                           'Importances':decision_tree_model['model']
                                         .feature_importances_})
dfFeatures.sort_values(by='Importances',ascending=False)

x_train = x_train.drop(columns=['sibsp', 'parch', 'embarked'])

cols_numericas = ["age", "fare"]
cols_categoricas = ["sex"]
cols_categoricas_ord = ["pclass"]

numeric_pipe = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ])

categorical_pipe = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('onehot', OneHotEncoder())])

categorical_ord_pipe = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('onehot', OrdinalEncoder())])

preprocessor = ColumnTransformer(
    transformers=[
        ('numericas', numeric_pipe, cols_numericas),
        ('categoricas', categorical_pipe, cols_categoricas),
        ('categoricas ordinales', categorical_ord_pipe, cols_categoricas_ord)
])



modelo = DecisionTreeClassifier(criterion='entropy',
                                max_depth=4,
                                max_features=8)

DecisionTree_pipe = Pipeline(steps=[("preprocessor", preprocessor),
                                    ("model", modelo)])

DecisionTree_pipe.fit(x_train, y_train)

x_test = x_test.drop(columns=['sibsp', 'parch', 'embarked'])
y_pred = DecisionTree_pipe.predict(x_test)

print(classification_report(y_test, y_pred))

columnas_base = ['sex', 'pclass', 'age', 'fare', 'survived']
titanic_df = pd.read_parquet('titanic_processed.parquet',
                              columns= columnas_base)

X = titanic_df.drop('survived', axis='columns')
y = titanic_df['survived']

DecisionTree_pipe.fit(X, y)

from joblib import dump, load # libreria de serializacion

# grabar el modelo en un archivo
dump(DecisionTree_pipe, 'DecisionTree_pipe-titanic.joblib')

from joblib import load

mi_modelo = load('DecisionTree_pipe-titanic.joblib')

x_test.head()

# hacer la prediccion solo de las primeras 5 filas de test
mi_modelo.predict(x_test.head())