#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Mar  4 15:25:33 2022

@author: tanu
"""
#%%

import os, sys
import pandas as pd
import numpy as np
import pprint as pp
#from copy import deepcopy
from sklearn import linear_model
from sklearn.linear_model import LogisticRegression, LinearRegression
from sklearn.naive_bayes import BernoulliNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier
from sklearn.neural_network import MLPClassifier
from xgboost import XGBClassifier
from sklearn.preprocessing import StandardScaler, MinMaxScaler, OneHotEncoder

from sklearn.compose import ColumnTransformer
from sklearn.compose import make_column_transformer

from sklearn.metrics import confusion_matrix, accuracy_score, precision_score, recall_score 
from sklearn.metrics import roc_auc_score, roc_curve, f1_score, matthews_corrcoef, jaccard_score
from sklearn.metrics import make_scorer
from sklearn.metrics import classification_report

from sklearn.metrics import average_precision_score

from sklearn.model_selection import cross_validate
from sklearn.model_selection import train_test_split
from sklearn.model_selection import StratifiedKFold

from sklearn.pipeline import Pipeline
from sklearn.pipeline import make_pipeline

from sklearn.feature_selection import RFE
from sklearn.feature_selection import RFECV
import itertools
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
print(np.__version__)
print(pd.__version__)
from statistics import mean, stdev, median, mode

from imblearn.over_sampling import RandomOverSampler
from imblearn.over_sampling import SMOTE
from imblearn.pipeline import Pipeline
#from sklearn.datasets import make_classification
from sklearn.model_selection import cross_validate
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.ensemble import AdaBoostClassifier
from imblearn.combine import SMOTEENN
from imblearn.under_sampling import EditedNearestNeighbours

from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
from sklearn.neural_network import MLPClassifier

from sklearn.linear_model import RidgeClassifier, SGDClassifier, PassiveAggressiveClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.svm import SVC
from xgboost import XGBClassifier
from sklearn.naive_bayes import MultinomialNB
from sklearn.linear_model import SGDClassifier
from sklearn.preprocessing import StandardScaler, MinMaxScaler, OneHotEncoder


#%%
rs = {'random_state': 42}
njobs = {'n_jobs': 10}

scoring_fn =  ({ 'fscore'       : make_scorer(f1_score)
                  , 'mcc'        : make_scorer(matthews_corrcoef)
                  , 'precision'  : make_scorer(precision_score)
                  , 'recall'     : make_scorer(recall_score)
                  , 'accuracy'   : make_scorer(accuracy_score)
                  ,  'roc_auc'   : make_scorer(roc_auc_score)
                  ,  'jaccard'   : make_scorer(jaccard_score)
            })    


# Multiple Classification - Model Pipeline
def MultClassPipeSKFCV(input_df, target, skf_cv, var_type = ['numerical', 'categorical','mixed']):

    '''
    @ param input_df: input features 
    @ type: df with input features WITHOUT the target variable
    
    @param target: target (or output) feature
    @type: df or np.array or Series
    
    @param skv_cv: stratifiedK fold int or object to allow shuffle and random state to pass
    @type: int or StratifiedKfold()
    
    @var_type: numerical, categorical and mixed to determine what col_transform to apply (MinMaxScalar and/or one-ho    t encoder)
    @type: list

    returns
    Dict containing multiple classification scores for each model and mean of each Stratified Kfold including training
       
    '''
    # determine categorical and numerical features
    numerical_ix = input_df.select_dtypes(include=['int64', 'float64']).columns
    numerical_ix
    categorical_ix = input_df.select_dtypes(include=['object', 'bool']).columns
    categorical_ix    

    # Determine preprocessing steps ~ var_type
    if var_type == 'numerical':
        t = [('num', MinMaxScaler(), numerical_ix)]

    if var_type == 'categorical':
        t = [('cat', OneHotEncoder(), categorical_ix)]
    
    if var_type == 'mixed':
        t = [('cat', OneHotEncoder(), categorical_ix)
             , ('num', MinMaxScaler(), numerical_ix)]
        
    col_transform = ColumnTransformer(transformers = t
                                       , remainder='passthrough')
    
    #%% Specify multiple Classification models
    log_reg = LogisticRegression(**rs)
    nb      = BernoulliNB()
    knn     = KNeighborsClassifier()
    svm     = SVC(**rs)
    mlp     = MLPClassifier(max_iter = 500, **rs)
    dt      = DecisionTreeClassifier(**rs)
    et      = ExtraTreesClassifier(**rs)
    rf      = RandomForestClassifier(**rs, n_estimators = 1000 )
    rf2     = RandomForestClassifier(
                          min_samples_leaf = 5
                          , n_estimators     = 100 #10
                          , bootstrap        = True
                          , oob_score        = True
                          , **njobs
                          , **rs
                          , max_features     = 'auto')
    xgb = XGBClassifier(**rs, verbosity = 0, use_label_encoder =False)
                        
    lda = LinearDiscriminantAnalysis()
    
    mnb = MultinomialNB()
    
    pa  = PassiveAggressiveClassifier(**rs, **njobs)
    
    sgd = SGDClassifier(**rs, **njobs)          

    models = [('Logistic Regression', log_reg)
            , ('Naive Bayes'        , nb)
            , ('K-Nearest Neighbors', knn) 
            , ('SVM'                , svm) 
            , ('MLP'                , mlp) 
            , ('Decision Tree'      , dt) 
            , ('Extra Trees'        , et) 
            , ('Random Forest'      , rf) 
            , ('Naive Bayes'        , nb)
            , ('Random Forest2'     , rf2) 
            , ('XGBoost'            , xgb)
            , ('LDA'                , lda)
            , ('MultinomialNB'      , mnb)
            , ('PassiveAggresive'   , pa)
            , ('StochasticGDescent' , sgd)]
        
    mm_skf_scoresD = {}
     
    for model_name, model_fn in models:
        print('\nModel_name:', model_name
        , '\nModel func:'    , model_fn
        , '\nList of models:', models)
    
        model_pipeline = Pipeline([
            ('prep'     , col_transform)
            , ('model'  , model_fn)])
            
        print('Running model pipeline:', model_pipeline)
        skf_cv_mod = cross_validate(model_pipeline
                              , input_df
                              , target
                              , cv = skf_cv
                              , scoring = scoring_fn
                              , return_train_score = True)
        mm_skf_scoresD[model_name] = {}
        for key, value in skf_cv_mod.items():
            print('\nkey:', key, '\nvalue:', value)
            print('\nmean value:', mean(value))
            mm_skf_scoresD[model_name][key] = round(mean(value),2)
            #pp.pprint(mm_skf_scoresD)
    return(mm_skf_scoresD)