initialized

app.py

@@ -0,0 +1,277 @@
+import streamlit as st 
+import pandas as pd
+import numpy as np
+
+import os
+import sys
+
+from company_bankruptcy.components.model_trainer import ModelTrainer
+from company_bankruptcy.components.data_transformation import DataTransformation
+from company_bankruptcy.utils.utils import load_object
+from company_bankruptcy.logger.logger import logging
+from company_bankruptcy.exception.exception import CustomException
+
+def get_prob(input_df, trained_models_dict, feature_selection_dict, opt_dict):
+    if best_model_name == 'Average Ensemble':
+            
+        default_prob = 0
+        for model_name in trained_models_dict:
+            if model_name == 'best_model_name':
+                continue
+            temp_features_list = feature_selection_dict[model_name][1]['selected_shap_feats']
+            temp_prob = trained_models_dict[model_name].predict_proba(input_df[temp_features_list])[:, 1]
+            default_prob += temp_prob
+        default_prob /= (len(trained_models_dict) - 1)
+
+    elif best_model_name == 'Optimized Ensemble':
+
+        rfm_features_list = feature_selection_dict['RandomForestClassifier'][1]['selected_shap_feats']
+        xgbm_features_list = feature_selection_dict['XGBClassifier'][1]['selected_shap_feats']
+        lrm_features_list = feature_selection_dict['LogisticRegression'][1]['selected_shap_feats']
+        svcm_features_list = feature_selection_dict['SVC'][1]['selected_shap_feats']
+
+        preds_list = []
+
+        for idx in opt_dict:
+            opt = opt_dict[idx]['opt']
+            rfm = opt_dict[idx]['rfm']
+            xgbm = opt_dict[idx]['xgbm']
+            lrm = opt_dict[idx]['lrm']
+            svcm = opt_dict[idx]['svcm']
+
+            rfm_probs = rfm.predict_proba(input_df[rfm_features_list])[:, 1]
+            xgbm_probs = xgbm.predict_proba(input_df[xgbm_features_list])[:, 1]
+            lrm_probs = lrm.predict_proba(input_df[lrm_features_list])[:, 1]
+            svcm_probs = svcm.predict_proba(input_df[svcm_features_list])[:, 1]
+
+            model_preds = np.column_stack([
+                rfm_probs,
+                xgbm_probs,
+                lrm_probs,
+                svcm_probs
+            ])
+
+            preds_list.append(opt.predict(model_preds))
+
+        default_prob = np.mean(np.column_stack(preds_list), axis=1)
+
+    elif best_model_name == 'Rank Ensemble':
+
+        rank_ensemble_list = []
+        prob_list = []
+        model_names_list = []
+
+        for model_name in trained_models_dict:
+            if model_name == 'best_model_name':
+                continue
+            temp_features_list = feature_selection_dict[model_name][1]['selected_shap_feats']
+            model_names_list.append(model_name)
+            rank_ensemble_list.append((model_name, trained_models_dict[model_name].best_score_))
+            prob_list.append(trained_models_dict[model_name].predict_proba(input_df[temp_features_list])[:, 1])
+
+        rank_ensemble_list = sorted(rank_ensemble_list, key=lambda x: x[1])
+
+        default_prob = 0
+        for i in range(len(rank_ensemble_list)):
+            default_prob += (i+1) * prob_list[model_names_list.index(rank_ensemble_list[i][0])]
+        default_prob /= (len(rank_ensemble_list) * (1 + len(rank_ensemble_list)) / 2)
+
+    else:
+        model = trained_models_dict[best_model_name]
+        temp_features_list = feature_selection_dict[best_model_name][1]['selected_shap_feats']
+        default_prob = model.predict_proba(input_df[temp_features_list])[:, 1]
+
+    return default_prob
+
+st.set_page_config(
+    page_title='Default Predictor',
+    layout='centered'
+)
+
+try:
+
+    st.title('Company Default Predictor')
+    
+    logging.info('Initiating dictionaries')
+    if 'trained_models_dict' not in st.session_state:
+        model_trainer_obj = ModelTrainer()
+        trained_models_dict = load_object(
+            os.path.join(
+                model_trainer_obj.model_trainer_config.trained_models_path,
+                'trained_models_dict.pkl'
+            )
+        )
+        opt_dict = load_object(
+            os.path.join(
+                model_trainer_obj.model_trainer_config.trained_models_path,
+                'opt_dict.pkl'
+            )
+        )
+
+        data_transformation_obj = DataTransformation()
+        feature_selection_dict = load_object(
+            data_transformation_obj.data_transformation_config.feature_selection_dict_file_path
+        )
+
+        example_data = pd.read_excel('app_input_example.xlsx')
+        # example_data = pd.read_csv('app_input_example.csv')
+
+        st.session_state['trained_models_dict'] = trained_models_dict
+        st.session_state['opt_dict'] = opt_dict
+        st.session_state['feature_selection_dict'] = feature_selection_dict
+        st.session_state['example_data'] = example_data
+
+    else:
+
+        trained_models_dict = st.session_state['trained_models_dict']
+        opt_dict = st.session_state['opt_dict']
+        feature_selection_dict = st.session_state['feature_selection_dict']
+        example_data = st.session_state['example_data']
+    logging.info('Dictionaries initiated')    
+    
+    logging.info('Checking button clicked')
+    if 'clicked' not in st.session_state:
+        st.session_state.clicked = False
+    logging.info(f'Button check passed with value {st.session_state.clicked}')
+    
+
+    st.subheader('Please, fill in the input boxes or provide an csv/excel file and click on submit button to get the default probability(ies).')
+
+    best_model_name = trained_models_dict['best_model_name']
+    
+    logging.info("Getting features' list")
+    if best_model_name in ['Average Ensemble', 'Optimized Ensemble', 'Rank Ensemble']:
+        features_list = []
+        for model_name in feature_selection_dict:
+            features_list.extend(
+                feature_selection_dict[model_name][1]['selected_shap_feats']
+            )
+        features_list = list(set(features_list))
+    else:
+        features_list = feature_selection_dict[best_model_name][1]['selected_shap_feats']
+    logging.info("Features' list found")
+
+    upload_container = st.container()
+    with upload_container:
+        upload_col1, upload_col2 = st.columns([0.6, 0.4])
+        uploaded_file = upload_col1.file_uploader(
+            'Upload a csv/excel file with data',
+            type=["csv", "xlsx"]
+        )
+
+        # example_data = pd.read_csv('app_input_example.csv')
+        # example_data = pd.read_csv('artifacts/data.csv')
+        # example_data = pd.read_excel('app_input_example.xlsx')
+
+        # @st.cache_data
+        # def convert_df(df):
+        #     return df.to_csv(index=False).encode("utf-8")
+        #     # return df.to_excel(index=False).encode("utf-8")
+        
+        # csv_data = convert_df(df=example_data[features_list])
+
+        csv_data = example_data[features_list].to_csv(index=False).encode("utf-8")
+
+        upload_col2.write('An example of the data file')
+        upload_col2.download_button(
+            'Download', 
+            data=csv_data, 
+            file_name='input_example.csv',
+            mime="text/csv"
+        )
+
+    n_cols = 2
+    n_rows = int((len(features_list) - len(features_list) % n_cols) / n_cols)
+    if len(features_list) % n_cols != 0:
+        n_rows += 1
+
+    logging.info('Constructing the app input structure')
+    input_dict = {}
+    feature_idx = 0
+    for i in range(n_rows):
+
+        temp_input_container = st.container()
+
+        with temp_input_container:
+            col1, col2 = st.columns(n_cols)
+            if i <= n_rows - 1 and len(features_list) % 2 == 0:
+                input_dict[features_list[feature_idx]] = [
+                    col1.number_input(
+                        features_list[feature_idx],
+                        format='%.6f' if features_list[feature_idx].split(' ')[-1] != 'Flag' else '%.0f'
+                    )
+                ]
+                input_dict[features_list[feature_idx+1]] = [
+                    col2.number_input(
+                        features_list[feature_idx+1],
+                        format='%.6f' if features_list[feature_idx+1].split(' ')[-1] != 'Flag' else '%.0f'
+                    )
+                ]
+            else:
+                input_dict[features_list[feature_idx]] = [
+                    col1.number_input(
+                        features_list[feature_idx],
+                        format='%.6f' if features_list[feature_idx].split(' ')[-1] != 'Flag' else '%.0f'
+                    )
+                ]
+
+        feature_idx += 2
+
+    logging.info('Input structure constructed')
+
+    def set_button_click():
+        st.session_state.clicked = True
+
+    st.button('Submit', on_click=set_button_click)
+
+    if st.session_state.clicked and uploaded_file is None:
+
+        st.session_state.clicked = False
+
+        logging.info(f'Calculating prob for {best_model_name}')
+
+        input_df = pd.DataFrame(input_dict)
+
+        default_prob = get_prob(input_df, trained_models_dict, feature_selection_dict, opt_dict)
+
+        st.write(f"Default probability: {default_prob[0]:.4f}")
+
+        logging.info(f'Default prob: {default_prob[0]:.4f}')
+
+    elif st.session_state.clicked and uploaded_file is not None:
+        st.session_state.clicked = False
+        # bites_data = uploaded_file.getvalue()
+        # stringio = StringIO(bites_data.decode('utf-8'))
+        # string_data = stringio.read()
+        logging.info('Loading uploaded data')
+        file_extension = uploaded_file.name.split('.')[-1]
+        if file_extension == 'csv':
+            input_df = pd.read_csv(uploaded_file)
+        else:
+            input_df = pd.read_excel(uploaded_file)
+        # input_df = pd.read_excel(uploaded_file)
+        logging.info('Uploaded data loaded')
+
+        with st.spinner('Please wait...'):
+            logging.info(f'Calculating probabilies for {best_model_name}')
+            default_prob = get_prob(input_df, trained_models_dict, feature_selection_dict, opt_dict)
+            logging.info('Probabilities calculated')
+
+            result_df = pd.DataFrame()
+            result_df['default_probability'] = default_prob
+
+            result_data = result_df.to_csv(index=False).encode("utf-8")
+
+        st.success('Done!')
+
+        st.download_button(
+            'Download the predicted probabilities',
+            data=result_data,
+            file_name='default_probabilities.csv',
+            mime='text/csv'
+        )
+
+except Exception as e:
+    logging.info('Error occured while creating streamlit app')
+    raise CustomException(e, sys)
+

artifacts/feature_selection_dict.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ffff597549a2c76e13872a5f2048d4b83da2a0f25eeccbade02a575871d84bf9
+size 1930217

artifacts/models/opt_dict.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f79cee91a25f02eb551b29c882f6afc778d175c4d755497234c1b2f49f3bbde
+size 15200636

artifacts/models/trained_models_dict.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9695d244584ea79581682da0530cbdfb3dd02c76598114626a09e5f3bac3b520
+size 1983143

company_bankruptcy/components/data_ingestion.py

@@ -0,0 +1,61 @@
+import pandas as pd
+import numpy as np
+
+from company_bankruptcy.logger.logger import logging
+from company_bankruptcy.exception.exception import CustomException
+from company_bankruptcy.data_access.mongo_db_connection import MongoOps
+from company_bankruptcy.constants.constants import DATABASE_NAME, COLLECTION_NAME, MONGODB_COLLECTION_STR
+
+import os
+import sys
+from pathlib import Path
+from dataclasses import dataclass
+
+from sklearn.model_selection import train_test_split
+
+MONGODB_COLLECTION_STR = "mongodb+srv://vcharchian:[email protected]/?retryWrites=true&w=majority&appName=Cluster0"
+
+@dataclass
+class DataIngestionConfig:
+    raw_data_path:str = os.path.join('artifacts', 'data.csv')
+    train_data_path:str = os.path.join('artifacts', 'train_data.csv')
+    test_data_path:str = os.path.join('artifacts', 'test_data.csv')
+
+class DataIngestion:
+
+    def __init__(self):
+        self.ingestion_config = DataIngestionConfig()
+
+    def initiate_data_ingestion(self):
+        logging.info('Data ingestion started')
+        try:
+            logging.info('Reading the raw data')
+            mongo_instance = MongoOps(
+                client_url=MONGODB_COLLECTION_STR
+            )
+            data = mongo_instance.get_records(coll_name=COLLECTION_NAME, db_name=DATABASE_NAME)
+            logging.info('Data loaded')
+            os.makedirs(os.path.dirname(os.path.join(self.ingestion_config.raw_data_path)), exist_ok=True)
+            logging.info('Saving the data')
+            data.to_csv(self.ingestion_config.raw_data_path, index=False)
+            logging.info('Data saved')
+            logging.info('Splitting the data into train and test sets')
+            train_df, test_df = train_test_split(
+                data, 
+                test_size=0.1, 
+                random_state=13, 
+                stratify=data['Bankrupt?']
+            )
+            logging.info('Saving train and test sets')
+            train_df.to_csv(self.ingestion_config.train_data_path, index=False)
+            test_df.to_csv(self.ingestion_config.test_data_path, index=False)
+            logging.info('Sets are saved')
+            logging.info('Data ingestion completed')
+            return (self.ingestion_config.train_data_path, self.ingestion_config.test_data_path)
+        except Exception as e:
+            logging.info('Error occured during data ingestion')
+            raise CustomException(e, sys)
+
+if __name__ == '__main__':
+    data_ingestion_obj = DataIngestion()
+    train_path, test_path = data_ingestion_obj.initiate_data_ingestion()

company_bankruptcy/components/data_transformation.py

@@ -0,0 +1,85 @@
+import pandas as pd
+from company_bankruptcy.logger.logger import logging
+from company_bankruptcy.exception.exception import CustomException
+
+import os
+import sys
+from dataclasses import dataclass
+
+from sklearn.model_selection import StratifiedKFold
+
+from company_bankruptcy.utils.utils import save_object, create_feature_selection_dict
+
+@dataclass
+class DataTransformationConfig:
+    feature_selection_dict_file_path = os.path.join('artifacts', 'feature_selection_dict.pkl')
+
+class DataTransformation:
+
+    def __init__(self):
+        self.data_transformation_config = DataTransformationConfig()
+
+    def initiate_data_transformation(self, train_path, test_path, n_cv_folds=10):
+
+        try:
+            logging.info('Loading training data')
+            train_df = pd.read_csv(train_path)
+            logging.info('Training data loaded')
+
+            logging.info('Loading testing data')
+            test_df = pd.read_csv(test_path)
+            logging.info('Testing data loaded')
+
+            logging.info('Removing Net Income Flag')
+            train_df.drop(columns=' Net Income Flag', inplace=True)
+            test_df.drop(columns=' Net Income Flag', inplace=True)
+            logging.info('Net Income Flag removed')
+
+            logging.info('Specifying nominal and numerical features as list')
+            nominal_features = [' Liability-Assets Flag']
+            numerical_features = [col for col in train_df.columns if col not in nominal_features and col!='Bankrupt?']
+            logging.info('Nominal and numerical features specified')
+
+            logging.info(f'Creating {n_cv_folds} CV folds for train data')
+            skfold = StratifiedKFold(n_splits=n_cv_folds, random_state=42, shuffle=True)
+            skfold_list = []
+            for train_idxs, valid_idxs in skfold.split(train_df, y=train_df['Bankrupt?']):
+                skfold_list.append((train_idxs, valid_idxs))
+            logging.info('CV folds created')
+            
+            # logging.info('Creating new columns using categorical and numerical iteractions')
+            # for feat in numerical_features:
+            #     train_df[f"feat{numerical_features.index(feat)}"] = train_df[feat] * train_df[' Liability-Assets Flag']
+            #     test_df[f"feat{numerical_features.index(feat)}"] = test_df[feat] * test_df[' Liability-Assets Flag']
+            #     numerical_features.append(f"feat{numerical_features.index(feat)}")
+            # logging.info('New columns created')
+
+            logging.info('Starting feature selection')
+            selected_features_dict = create_feature_selection_dict(
+                data=train_df, 
+                cv_fold_list=skfold_list, 
+                numerical_features=numerical_features, 
+                nominal_features=nominal_features
+            )
+            logging.info('Feature selection completed')
+
+            logging.info('Saving feature selection dictionary as pkl file')
+            save_object(
+                file_path=self.data_transformation_config.feature_selection_dict_file_path,
+                obj=selected_features_dict
+            )
+            logging.info('Dictionary saved')
+
+            return (train_df, test_df, skfold_list, numerical_features)
+
+        except Exception as e:
+            logging.info('Error occured during data transformation')
+            raise CustomException(e, sys)
+
+if __name__ == '__main__':
+
+    data_transformation_obj = DataTransformation()
+    train_df, test_df, cv_fold_list, numerical_features = data_transformation_obj.initiate_data_transformation(
+        train_path='artifacts\\train_data.csv', 
+        test_path='artifacts\\test_data.csv'
+    )

company_bankruptcy/components/model_evaluation.py

@@ -0,0 +1,164 @@
+import pandas as pd
+import numpy as np
+
+from company_bankruptcy.logger.logger import logging
+from company_bankruptcy.exception.exception import CustomException
+from company_bankruptcy.utils.utils import load_object
+from company_bankruptcy.components.model_trainer import ModelTrainer
+from company_bankruptcy.components.data_transformation import DataTransformation
+
+import os
+import sys
+
+import mlflow
+import mlflow.sklearn
+import mlflow.xgboost
+
+from sklearn.metrics import roc_auc_score
+
+from urllib.parse import urlparse
+
+
+class ModelEvaluation:
+
+    def __init__(self):
+        
+        logging.info('Model evaluation started')
+
+    def initiate_model_evaluation(self, test_df):
+
+        try:
+
+            logging.info('Setting target variable')
+            y_test = test_df['Bankrupt?'].to_frame()
+            logging.info('Target variable set')
+
+            logging.info('Loading the trained models')
+            model_trainer_obj = ModelTrainer()
+            models_main_path = model_trainer_obj.model_trainer_config.trained_models_path
+            trained_models_dict = load_object(
+                os.path.join(models_main_path, 'trained_models_dict.pkl')
+            )
+            opt_dict = load_object(
+                os.path.join(models_main_path, 'opt_dict.pkl')
+            )
+            logging.info('Trained models loaded')
+
+            logging.info("Loading the features' dictionary")
+            data_transformation_obj = DataTransformation()
+            features_selection_dict_path = data_transformation_obj.data_transformation_config.feature_selection_dict_file_path
+            feature_selection_dict = load_object(features_selection_dict_path)
+            logging.info("Features' selection dictionary loaded")
+
+            test_score_dict = {}
+
+            logging.info('Finding test score for Average Ensemble')
+            y_test_pred_prob = 0
+            for model_name in trained_models_dict:
+                if model_name == 'best_model_name':
+                    continue
+                features_list = feature_selection_dict[model_name][1]['selected_shap_feats']
+                temp_prob = trained_models_dict[model_name].predict_proba(test_df[features_list])[:, 1]
+                y_test_pred_prob += temp_prob
+            y_test_pred_prob /= (len(trained_models_dict) - 1)
+            avg_ens_score = roc_auc_score(y_test, y_test_pred_prob)
+            test_score_dict['AverageEnsemble'] = avg_ens_score
+            logging.info('Average Ensemble score calculated')
+
+            logging.info('Finding test score for Optimized Ensemble')
+            rfm_features_list = feature_selection_dict['RandomForestClassifier'][1]['selected_shap_feats']
+            xgbm_features_list = feature_selection_dict['XGBClassifier'][1]['selected_shap_feats']
+            lrm_features_list = feature_selection_dict['LogisticRegression'][1]['selected_shap_feats']
+            svcm_features_list = feature_selection_dict['SVC'][1]['selected_shap_feats']
+                
+            preds_list = []
+
+            for idx in opt_dict:
+                opt = opt_dict[idx]['opt']
+                rfm = opt_dict[idx]['rfm']
+                xgbm = opt_dict[idx]['xgbm']
+                lrm = opt_dict[idx]['lrm']
+                svcm = opt_dict[idx]['svcm']
+
+                rfm_probs = rfm.predict_proba(test_df[rfm_features_list])[:, 1]
+                xgbm_probs = xgbm.predict_proba(test_df[xgbm_features_list])[:, 1]
+                lrm_probs = lrm.predict_proba(test_df[lrm_features_list])[:, 1]
+                svcm_probs = svcm.predict_proba(test_df[svcm_features_list])[:, 1]
+
+                model_preds = np.column_stack([
+                    rfm_probs,
+                    xgbm_probs,
+                    lrm_probs,
+                    svcm_probs
+                ])
+
+                preds_list.append(opt.predict(model_preds))
+
+            y_test_pred_prob = np.mean(np.column_stack(preds_list), axis=1)
+            optimized_ens_score = roc_auc_score(y_test, y_test_pred_prob)
+            test_score_dict['OptimizedEnsemble'] = optimized_ens_score
+            logging.info('Optimized Ensemble score calculated')
+
+            logging.info('Finding test score for Rank Ensemble')
+            rank_ensemble_list = []
+            prob_list = []
+            model_names_list = []
+
+            for model_name in trained_models_dict:
+                if model_name == 'best_model_name':
+                    continue
+                features_list = feature_selection_dict[model_name][1]['selected_shap_feats']
+                model_names_list.append(model_name)
+                rank_ensemble_list.append((model_name, trained_models_dict[model_name].best_score_))
+                prob_list.append(trained_models_dict[model_name].predict_proba(test_df[features_list])[:, 1])
+
+            rank_ensemble_list = sorted(rank_ensemble_list, key=lambda x: x[1])
+
+            y_test_pred_prob = 0
+            for i in range(len(rank_ensemble_list)):
+                y_test_pred_prob += (i+1) * prob_list[model_names_list.index(rank_ensemble_list[i][0])]
+            y_test_pred_prob /= (len(rank_ensemble_list) * (1 + len(rank_ensemble_list)) / 2)
+            rank_ens_score = roc_auc_score(y_test, y_test_pred_prob)
+            test_score_dict['RankEnsemble'] = rank_ens_score
+            logging.info('Rank Ensemble score calculated')
+            
+            for model_name in trained_models_dict:
+                if model_name == 'best_model_name':
+                    continue
+                logging.info(f'Finding test score for {model_name}')
+                features_list = feature_selection_dict[model_name][1]['selected_shap_feats']
+                model = trained_models_dict[model_name]
+                y_test_pred_prob = model.predict_proba(test_df[features_list])[:, 1]
+                temp_score = roc_auc_score(y_test, y_test_pred_prob)
+                test_score_dict[model_name] = temp_score
+                logging.info(f'{model_name} score calculated')
+            
+            logging.info('Getting mlflow tracking uri type')
+            tracking_uri_type_store = urlparse(mlflow.get_tracking_uri()).scheme
+            logging.info('Tracking uri got')
+
+            logging.info('Starting mlflow')
+            with mlflow.start_run():
+                for model_name in test_score_dict:
+                    mlflow.log_metric(f'{model_name} ROC-AUC', test_score_dict[model_name])
+                    if model_name in trained_models_dict.keys():
+                        model = trained_models_dict[model_name]
+                        if tracking_uri_type_store != 'file':
+                            # if model_name == 'XGBClassifier':
+                            #     mlflow.xgboost.log_model(model, f'{model_name}', registered_model_name=f'{model_name}_model')
+                            # else:
+                            mlflow.sklearn.log_model(model, f'{model_name}', registered_model_name=f'{model_name}_model')
+                        else:
+                            # if model_name == 'XGBClassifier':
+                            #     mlflow.xgboost.log_model(model, f'{model_name}')
+                            # else:
+                            mlflow.sklearn.log_model(model, f'{model_name}')
+
+            logging.info('mlflow succeeded')
+                
+
+        except Exception as e:
+
+            logging.info('Error occured during model evaluation')
+            raise CustomException(e, sys)
+

company_bankruptcy/components/model_trainer.py

@@ -0,0 +1,68 @@
+import pandas as pd
+import numpy as np
+from company_bankruptcy.logger.logger import logging
+from company_bankruptcy.exception.exception import CustomException
+from company_bankruptcy.utils.utils import save_object, find_optimal_model
+
+import os
+import sys
+from pathlib import Path
+from dataclasses import dataclass
+
+
+@dataclass
+class ModelTrainerConfig:
+    trained_models_path = os.path.join('artifacts', 'models')
+
+
+class ModelTrainer:
+
+    def __init__(self):
+        self.model_trainer_config = ModelTrainerConfig()
+
+    def initiate_model_training(self, train_df, test_df, features_dict_path, cv_fold_list, numerical_features):
+
+        try:
+
+            logging.info('Creating a directory to save trained models')
+            os.makedirs(
+                self.model_trainer_config.trained_models_path, exist_ok=True)
+            logging.info("Models' directory created")
+
+            logging.info('Finding the best model')
+            trained_models_dict, opt_dict = find_optimal_model(
+                train_df,
+                test_df,
+                features_dict_path,
+                cv_fold_list,
+                numerical_features
+            )
+
+            logging.info(
+                "Saving trained models' and ensemble optimized weights' dictionaries")
+            save_object(
+                file_path=os.path.join(
+                    self.model_trainer_config.trained_models_path, 'trained_models_dict.pkl'),
+                obj=trained_models_dict
+            )
+
+            save_object(
+                file_path=os.path.join(
+                    self.model_trainer_config.trained_models_path, 'opt_dict.pkl'),
+                obj=opt_dict
+            )
+            logging.info('Saving completed')
+
+        except Exception as e:
+            logging.info('Error occured during model training')
+            raise CustomException(e, sys)
+
+# if __name__ == '__main__':
+#     model_training_obj = ModelTrainer()
+#     model_training_obj.initiate_model_training(
+#         train_df, 
+#         test_df, 
+#         features_dict_path, 
+#         cv_fold_list, 
+#         numerical_features
+#     )

company_bankruptcy/constants/constants.py

@@ -0,0 +1,5 @@
+DATABASE_NAME = "bankruptcy"
+
+COLLECTION_NAME = "data"
+
+MONGODB_COLLECTION_STR = "MONGODB_COLLECTION_STR"

company_bankruptcy/data_access/mongo_db_connection.py

@@ -0,0 +1,104 @@
+import pandas as pd
+import pymongo
+import json
+
+from company_bankruptcy.exception.exception import CustomException
+from company_bankruptcy.logger.logger import logging
+from company_bankruptcy.constants.constants import DATABASE_NAME, COLLECTION_NAME, MONGODB_COLLECTION_STR
+
+import sys
+
+
+class MongoOps:
+
+    def __init__(self, client_url:str, database_name:str=None, collection_name:str=None):
+        self.client_url = client_url
+        self.database_name = database_name
+        self.collection_name = collection_name
+
+    def create_client(self):
+        logging.info('Initiating MongoClient')
+        client = pymongo.MongoClient(self.client_url)
+        logging.info('MongoClient initiated')
+        return client
+
+    def create_database(self):
+        logging.info('Creating Mongo database')
+        client = self.create_client()
+        database = client[self.database_name]
+        logging.info(f'Mongo database {self.database_name} created')
+        return database
+
+    def create_collection(self):
+        logging.info('Creating Mongo collection')
+        database = self.create_database()
+        collection = database[self.collection_name]
+        logging.info(f'Mongo collection {self.collection_name} created')
+        return collection
+    
+    def get_database(self, db_name:str):
+        logging.info(f'Accessing {db_name} database')
+        client = self.create_client()
+        database = client[db_name]
+        logging.info(f'{db_name} database accessed')
+        return database
+
+    def get_collection(self, coll_name:str, db_name:str):
+        logging.info(f'Accessing {coll_name} collection')
+        database = self.get_database(db_name)
+        collection = database[coll_name]
+        logging.info(f'{coll_name} collection accessed')
+        return collection
+
+    def insert_record(self, record:dict, coll_name:str, db_name:str):
+        collection = self.get_collection(coll_name, db_name)
+        logging.info(f'Starting record insertion into {coll_name} collection of {db_name} database')
+        if isinstance(record, list):
+            for data in record:
+                if type(data) != dict:
+                    logging.info("Records' list should have elements as dict")
+                    raise TypeError("Records' list should have elements as dict")
+            collection.insert_many(record)
+        elif isinstance(record, dict):
+            collection.insert_one(record)
+        logging.info(f'Insertion into {coll_name} collection of {db_name} database completed')
+
+    def insert_from_file(self, datafile:str, coll_name:str, db_name:str):
+        logging.info(f'Starting record insertion into {coll_name} collection of {db_name} database from {datafile}')
+        self.path = datafile
+
+        if self.path.endswith('.csv'):
+            df = pd.read_csv(self.path, encoding='utf-8')
+        elif self.path.endswith('.xlsx'):
+            df = pd.read_excel(self.path, encoding='utf-8')
+        logging.info('Data is loaded as a pandas dataframe')
+
+        logging.info('Converting the data into json')
+        datajson = json.loads(df.to_json(orient='record'))
+        logging.info('Conversion to json completed')
+
+        collection = self.get_collection(coll_name, db_name)
+
+        logging.info('Inserting json data')
+        collection.insert_many(datajson)
+        logging.info('Insertion completed')
+
+    def get_records(self, coll_name:str, db_name:str):
+        collection = self.get_collection(coll_name, db_name)
+        retrieved_data = pd.DataFrame(list(collection.find()))
+        try:
+            retrieved_data.drop(columns='_id', inplace=True)
+            logging.info('Loading the data from the database completed')
+        except Exception as e:
+            retrieved_data = pd.DataFrame()
+            logging.info('Loading the data from the database failed')
+            raise CustomException(e, sys)
+        return retrieved_data
+    
+if __name__ == '__main__':
+
+    mongo_instance = MongoOps(
+        client_url=MONGODB_COLLECTION_STR
+    )
+
+    retrieved_data = mongo_instance.get_records(coll_name=COLLECTION_NAME, db_name=DATABASE_NAME)

company_bankruptcy/exception/exception.py

@@ -0,0 +1,20 @@
+import sys
+
+
+class CustomException(Exception):
+
+    def __init__(self, error_message, error_details:sys):
+        self.error_message = error_message
+        _, _, exc_tb = error_details.exc_info()
+        self.lineno = exc_tb.tb_lineno
+        self.file_name = exc_tb.tb_frame.f_code.co_filename
+
+    def __str__(self):
+        return "Error occured in python script name [{0}] line number [{1}] error message [{2}]".format(
+            self.file_name, self.lineno, str(self.error_message))
+
+if __name__ == '__main__':
+    try:
+        1 / 0
+    except Exception as e:
+        raise CustomException(e, sys)

company_bankruptcy/logger/logger.py

@@ -0,0 +1,20 @@
+import logging
+import os
+from datetime import datetime as dt
+
+LOG_FILE = f"{dt.now().strftime('%m_%d_%Y_%H_%M_%S')}.log"
+
+log_path = os.path.join(os.getcwd(), "logs")
+
+os.makedirs(log_path, exist_ok=True)
+
+LOG_FILEPATH = os.path.join(log_path, LOG_FILE)
+
+logging.basicConfig(
+    level=logging.INFO,
+    filename=LOG_FILEPATH,
+    format="[%(asctime)s] %(lineno)d %(name)s - %(levelname)s - %(message)s"
+)
+
+if __name__ == '__main__':
+    logging.info("Log testing executed!!!")

company_bankruptcy/pipeline/training_pipeline.py

@@ -0,0 +1,27 @@
+from company_bankruptcy.components.data_ingestion import DataIngestion
+from company_bankruptcy.components.data_transformation import DataTransformation
+from company_bankruptcy.components.model_trainer import ModelTrainer
+from company_bankruptcy.components.model_evaluation import ModelEvaluation
+
+def run_pipeline():
+
+    data_ingestion_obj = DataIngestion()
+    train_path, test_path = data_ingestion_obj.initiate_data_ingestion()
+    
+    data_transformation_obj = DataTransformation()
+    train_df, test_df, cv_fold_list, numerical_features = data_transformation_obj.initiate_data_transformation(
+        train_path=train_path, 
+        test_path=test_path
+    )
+    
+    model_training_obj = ModelTrainer()
+    model_training_obj.initiate_model_training(
+        train_df=train_df, 
+        test_df=test_df, 
+        features_dict_path=data_transformation_obj.data_transformation_config.feature_selection_dict_file_path, 
+        cv_fold_list=cv_fold_list, 
+        numerical_features=numerical_features
+    )
+    
+    model_evaluation_obj = ModelEvaluation()
+    model_evaluation_obj.initiate_model_evaluation(test_df)

company_bankruptcy/utils/utils.py

@@ -0,0 +1,974 @@
+import os
+import sys
+import pickle
+import numpy as np
+import pandas as pd
+
+from company_bankruptcy.logger.logger import logging
+from company_bankruptcy.exception.exception import CustomException
+
+from sklearn.svm import SVC
+from sklearn.feature_selection import RFE
+from sklearn.feature_selection import r_regression, SelectKBest
+from sklearn.feature_selection import mutual_info_regression, mutual_info_classif
+from sklearn.feature_selection import f_classif, chi2
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score, f1_score, roc_auc_score
+from sklearn.preprocessing import StandardScaler
+from sklearn.model_selection import GridSearchCV
+from sklearn.pipeline import Pipeline
+from sklearn.compose import ColumnTransformer
+
+from xgboost import XGBClassifier
+
+from scipy import stats
+from scipy.special import softmax
+from scipy.optimize import fmin
+
+from functools import partial
+
+from statsmodels.stats.outliers_influence import variance_inflation_factor
+
+from boruta import BorutaPy
+
+import shap
+
+from collections import Counter
+
+from tqdm.auto import tqdm
+import gc
+
+import warnings
+warnings.filterwarnings('ignore')
+
+
+def save_object(file_path, obj):
+    try:
+        dir_path = os.path.dirname(file_path)
+
+        os.makedirs(dir_path, exist_ok=True)
+
+        with open(file_path, "wb") as file_obj:
+            pickle.dump(obj, file_obj)
+
+    except Exception as e:
+        raise CustomException(e, sys)
+
+def load_object(file_path):
+    try:
+        with open(file_path, 'rb') as file_obj:
+            return pickle.load(file_obj)
+    except Exception as e:
+        logging.info('Exception Occured in load_object function utils')
+        raise CustomException(e, sys)
+
+
+def get_shap_features(shap_values, features, topk=10):
+    '''
+    Returns topk features selected using shap values
+
+    Args:
+        shap_values (object): shap explainer
+        features (list): list of features' name
+
+    Returns:
+        list: topk features derived from shap values
+    '''
+    # Calculates the feature importance (mean absolute shap value) for each feature
+    importances = []
+    for i in range(shap_values.values.shape[1]):
+        importances.append(np.mean(np.abs(shap_values.values[:, i])))
+    # Calculates the normalized version
+    importances_norm = softmax(importances)
+    # Organize the importances and columns in a dictionary
+    feature_importances = {fea: imp for imp, fea in zip(importances, features)}
+    feature_importances_norm = {fea: imp for imp,
+                                fea in zip(importances_norm, features)}
+    # Sorts the dictionary
+    feature_importances = {k: v for k, v in sorted(
+        feature_importances.items(), key=lambda item: item[1], reverse=True)}
+    feature_importances_norm = {k: v for k, v in sorted(
+        feature_importances_norm.items(), key=lambda item: item[1], reverse=True)}
+    # Prints the feature importances
+    selected_topk_feats = []
+
+    for idx, (k, v) in enumerate(feature_importances.items()):
+        # print(f"{k} -> {v:.4f} (softmax = {feature_importances_norm[k]:.4f})")
+        if idx <= topk:
+            selected_topk_feats.append(k)
+
+    return selected_topk_feats
+
+
+class FSelector():
+    '''
+    Helps to select features based on BorutaPy, RFE, and various statistics
+    '''
+
+    def __init__(self, X, y, num_feats, ordinal_feats, nominal_feats, model, is_target_cat=True, select_n_feats=15):
+        '''
+        Initializes some parameters
+
+        Args:
+            X (pd.DataFrame): contains features' values
+            y (pd.DataFrame): contains target values
+            num_feats (list): list of numerical features' names
+            ordinal_feats (list): list of ordinal features' names
+            nominal_feats (list): list of nominal features' names
+            model (model object): can be any type of model like RandomForest, LogisticRegression, etc.
+            is_target_cat (bool): indicates whether the target is categorical or not
+            select_n_feats (int): specifies the number of features to output
+        '''
+
+        self.X = X
+        self.y = y
+        self.num_feats = num_feats
+        self.ordinal_feats = ordinal_feats
+        self.nominal_feats = nominal_feats
+        self.model = model
+        self.is_target_cat = is_target_cat
+        self.select_n_feats = select_n_feats
+
+    def calculate_vif(self, X):
+
+        vif = pd.DataFrame()
+        vif["features"] = X.columns
+        vif["VIF"] = [variance_inflation_factor(
+            X.values, i) for i in range(X.shape[1])]
+
+        return vif
+
+    def select_feats_via_vif(self):
+
+        num_features = self.num_feats.copy()
+
+        vif_df = self.calculate_vif(self.X[num_features])
+
+        while vif_df[vif_df['VIF'] >= 10].shape[0] != 0:
+            vif_df.sort_values('VIF', ascending=False, inplace=True)
+            vif_df.reset_index(drop=True, inplace=True)
+            # print(vif_df)
+            elimination_candidate = vif_df.iloc[0]['features']
+            # print(elimination_candidate)
+            num_features = [i for i in num_features if i !=
+                            elimination_candidate]
+            new_X = self.X[num_features]
+            vif_df = self.calculate_vif(new_X)
+
+        return list(vif_df['features'].values)
+
+    def get_spearmanr(self, X, y):
+        # return np.array([stats.spearmanr(X.values[:, f], y.values).correlation for f in range(X.shape[1])])
+        spearman_values = [stats.spearmanr(
+            X.values[:, f], y.values).correlation for f in range(X.shape[1])]
+        temp_sp_df = pd.DataFrame(
+            {'spearman': spearman_values, 'feats': list(X.columns)})
+        temp_sp_df['abs_spearman'] = np.abs(temp_sp_df['spearman'])
+        temp_sp_df.sort_values('abs_spearman', ascending=False, inplace=True)
+        temp_sp_df.reset_index(drop=True, inplace=True)
+        return temp_sp_df.iloc[:15]['feats'].to_list()
+
+    def get_kendalltau(self, X, y):
+        # return [stats.kendalltau(X.values[:, f], y.values).correlation for f in range(X.shape[1])]
+        kendall_values = [stats.spearmanr(
+            X.values[:, f], y.values).correlation for f in range(X.shape[1])]
+        temp_ken_df = pd.DataFrame(
+            {'kendall': kendall_values, 'feats': list(X.columns)})
+        temp_ken_df['abs_kendall'] = np.abs(temp_ken_df['kendall'])
+        temp_ken_df.sort_values('abs_kendall', ascending=False, inplace=True)
+        temp_ken_df.reset_index(drop=True, inplace=True)
+        return temp_ken_df.iloc[:15]['feats'].to_list()
+
+    def get_pointbiserialr(self, X, y):
+        return [stats.pointbiserialr(X.values[:, f], y.values).correlation for f in range(X.shape[1])]
+
+    def get_boruta_feats(self):
+        feat_selector = BorutaPy(
+            self.model, n_estimators='auto', verbose=2, random_state=1)
+        feat_selector.fit(np.array(self.X), np.array(self.y))
+        boruta_selected_features = list(
+            self.X.iloc[:, feat_selector.support_].columns)
+        return boruta_selected_features
+
+    def get_kbest(self, X, feats_list, metric):
+        selector = SelectKBest(metric, k=self.select_n_feats)
+        selector.fit_transform(X[feats_list], self.y)
+        selected_feats_idxs_list = list(selector.get_support(indices=True))
+        column_names = [feats_list[i] for i in selected_feats_idxs_list]
+        return column_names
+
+    def get_rfe_feats(self):
+        model_rfe = RFE(self.model, n_features_to_select=self.select_n_feats)
+        model_rfe.fit(self.X, self.y)
+        model_rfe_feats = list(
+            self.X.iloc[:, list(model_rfe.support_)].columns)
+        return model_rfe_feats
+
+    # def get_shap_feats(self, feats_list, topk=10):
+    #     model = self.model
+    #     X = self.X[feats_list]
+    #     model.fit(self.X, self.y)
+    #     explainer = shap.Explainer(model.predict, X, max_evals = int(2 * X.shape[1] + 1), verbose=0)
+    #     shap_values = explainer(X)
+    #     selected_shap_features = get_feature_importances_shap_values(
+    #         shap_values, features=list(X.columns), topk=topk
+    #     )
+    #     return selected_shap_features
+
+    def get_features(self):
+
+        if self.num_feats is not None:
+
+            if self.is_target_cat:
+
+                temp_n_feats = self.select_n_feats
+                if len(self.num_feats) < self.select_n_feats:
+                    self.select_n_feats = 'all'
+
+                # self.num_kendalltau_feats = self.get_kendalltau(self.X[self.num_feats], self.y)
+                self.num_f_feats = self.get_kbest(
+                    X=self.X, feats_list=self.num_feats, metric=f_classif)
+                self.num_mi_feats = self.get_kbest(
+                    X=self.X, feats_list=self.num_feats, metric=mutual_info_classif)
+
+                self.select_n_feats = temp_n_feats
+
+                self.selected_num_feats = []
+                # self.selected_num_feats.extend(self.num_kendalltau_feats)
+                self.selected_num_feats.extend(self.num_f_feats)
+                self.selected_num_feats.extend(self.num_mi_feats)
+
+            else:
+
+                self.vif_feats = self.select_feats_via_vif()
+
+                temp_n_feats = self.select_n_feats
+                if len(self.num_feats) < self.select_n_feats:
+                    self.select_n_feats = 'all'
+
+                self.pearson_feats = self.get_kbest(
+                    X=self.X, feats_list=self.num_feats, metric=r_regression, k=self.select_n_feats)
+
+                self.select_n_feats = temp_n_feats
+                # self.num_spearmanr_feats = self.get_kbest(X=self.X, feats_list=self.num_feats, metric=stats.spearmanr, k=self.select_n_feats)
+                # self.num_kendalltau_feats = self.get_kbest(X=self.X, feats_list=self.num_feats, metric=stats.kendalltau, k=self.select_n_feats)
+                self.num_spearmanr_feats = self.get_spearmanr(
+                    self.X[self.num_feats], self.y)
+                self.num_kendalltau_feats = self.get_kendalltau(
+                    self.X[self.num_feats], self.y)
+                # self.num_spearmanr_feats = SelectKBest(self.get_spearmanr, k=self.select_n_feats).fit_transform(self.X[self.num_feats], self.y)
+                # self.num_kendalltau_feats = SelectKBest(self.get_kendalltau, k=self.select_n_feats).fit_transform(self.X[self.num_feats], self.y)
+
+                self.selected_num_feats = []
+                self.selected_num_feats.extend(self.pearson_feats)
+                self.selected_num_feats.extend(self.num_spearmanr_feats)
+                self.selected_num_feats.extend(self.num_kendalltau_feats)
+                # self.selected_num_feats = list(set(self.selected_num_feats))
+
+        else:
+
+            self.selected_num_feats = []
+
+        if self.ordinal_feats is not None:
+
+            if self.is_target_cat:
+
+                temp_n_feats = self.select_n_feats
+                if len(self.ordinal_feats) < self.select_n_feats:
+                    self.select_n_feats = 'all'
+
+                self.ordinal_mi_feats = self.get_kbest(
+                    X=self.X, feats_list=self.ordinal_feats, metric=mutual_info_classif)
+                self.ordinal_chi2_feats = self.get_kbest(
+                    X=self.X, feats_list=self.ordinal_feats, metric=chi2)
+
+                self.selected_ordinal_feats = []
+                self.selected_ordinal_feats.extend(self.ordinal_mi_feats)
+                self.selected_ordinal_feats.extend(self.ordinal_chi2_feats)
+
+                self.select_n_feats = temp_n_feats
+
+            else:
+
+                self.ordinal_spearmanr_feats = self.get_spearmanr(
+                    self.X[self.ordinal_feats], self.y)
+                self.ordinal_kendalltau_feats = self.get_kendalltau(
+                    self.X[self.ordinal_feats], self.y)
+
+                # self.ordinal_spearmanr_feats = self.get_kbest(X=self.X, feats_list=self.ordinal_feats, metric=stats.spearmanr, k=self.select_n_feats)
+                # self.ordinal_kendalltau_feats = self.get_kbest(X=self.X, feats_list=self.ordinal_feats, metric=stats.kendalltau, k=self.select_n_feats)
+
+                # self.ordinal_spearmanr_feats = SelectKBest(self.get_spearmanr, k=self.select_n_feats).fit_transform(self.X[self.ordinal_feats], self.y)
+                # self.ordinal_kendalltau_feats = SelectKBest(self.get_kendalltau, k=self.select_n_feats).fit_transform(self.X[self.ordinal_feats], self.y)
+
+                self.selected_ordinal_feats = []
+                self.selected_ordinal_feats.extend(
+                    self.ordinal_spearmanr_feats)
+                self.selected_ordinal_feats.extend(
+                    self.ordinal_kendalltau_feats)
+                # self.selected_ordinal_feats = list(set(self.selected_ordinal_feats))
+
+        else:
+            self.selected_ordinal_feats = []
+
+        if self.nominal_feats is not None:
+
+            if self.is_target_cat:
+
+                temp_n_feats = self.select_n_feats
+                if len(self.nominal_feats) < self.select_n_feats:
+                    self.select_n_feats = 'all'
+
+                self.nominal_mi_feats = self.get_kbest(
+                    X=self.X, feats_list=self.nominal_feats, metric=mutual_info_classif)
+                self.nominal_chi2_feats = self.get_kbest(
+                    X=self.X, feats_list=self.nominal_feats, metric=chi2)
+
+                self.selected_nominal_feats = []
+                self.selected_nominal_feats.extend(self.nominal_mi_feats)
+                self.selected_nominal_feats.extend(self.nominal_chi2_feats)
+
+                self.select_n_feats = temp_n_feats
+
+            else:
+
+                temp_n_feats = self.select_n_feats
+                if len(self.nominal_feats) < self.select_n_feats:
+                    self.select_n_feats = 'all'
+
+                self.f_feats = self.get_kbest(
+                    X=self.X, feats_list=self.nominal_feats, metric=f_classif, k=self.select_n_feats)
+                self.mi_feats = self.get_kbest(
+                    X=self.X, feats_list=self.nominal_feats, metric=mutual_info_regression, k=self.select_n_feats)
+
+                self.select_n_feats = temp_n_feats
+
+                # # self.f_feats = f_classif(self.X[self.nominal_feats], self.y)[0]
+                # self.f_feats = SelectKBest(f_classif, k=self.select_n_feats).fit_transform(self.X[self.nominal_feats], self.y).columns
+
+                # # self.mi_feats = mutual_info_regression(self.X[self.nominal_feats], self.y)
+                # self.mi_feats = SelectKBest(mutual_info_regression, k=self.select_n_feats).fit_transform(self.X[self.nominal_feats], self.y).columns
+
+                self.selected_nominal_feats = []
+                self.selected_nominal_feats.extend(self.f_feats)
+                self.selected_nominal_feats.extend(self.mi_feats)
+                # self.selected_nominal_feats = list(set(self.selected_nominal_feats))
+
+        else:
+
+            self.selected_nominal_feats = []
+
+        if self.model is not None:
+            # np.int = np.int32
+            # np.float = np.float64
+            # np.bool = np.bool_
+            if isinstance(self.model, RandomForestClassifier) or isinstance(self.model, XGBClassifier):
+                self.boruta_feats = self.get_boruta_feats()
+            if not isinstance(self.model, SVC):
+                self.rfe_feats = self.get_rfe_feats()
+        else:
+            self.boruta_feats = []
+            self.rfe_feats = []
+
+        if len(self.selected_num_feats) != 0:
+            if isinstance(self.model, RandomForestClassifier) or isinstance(self.model, XGBClassifier):
+                self.selected_num_feats.extend(self.boruta_feats)
+            if not isinstance(self.model, SVC):
+                self.selected_num_feats.extend(self.rfe_feats)
+            num_feats_dict = dict(Counter(self.selected_num_feats))
+            self.selected_num_feats = [
+                i for i in num_feats_dict if num_feats_dict[i] >= 2]
+
+        if len(self.selected_ordinal_feats) != 0:
+            if isinstance(self.model, RandomForestClassifier) or isinstance(self.model, XGBClassifier):
+                self.selected_ordinal_feats.extend(self.boruta_feats)
+            if not isinstance(self.model, SVC):
+                self.selected_ordinal_feats.extend(self.rfe_feats)
+            ordinal_feats_dict = dict(Counter(self.selected_ordinal_feats))
+            self.selected_ordinal_feats = [
+                i for i in ordinal_feats_dict if ordinal_feats_dict[i] >= 2]
+
+        if len(self.selected_nominal_feats) != 0:
+            if isinstance(self.model, RandomForestClassifier) or isinstance(self.model, XGBClassifier):
+                self.selected_nominal_feats.extend(self.boruta_feats)
+            if not isinstance(self.model, SVC):
+                self.selected_nominal_feats.extend(self.rfe_feats)
+            nominal_feats_dict = dict(Counter(self.selected_nominal_feats))
+            self.selected_nominal_feats = [
+                i for i in nominal_feats_dict if nominal_feats_dict[i] >= 2]
+
+        self.selected_feats = []
+        self.selected_feats.extend(self.selected_num_feats)
+        self.selected_feats.extend(self.selected_ordinal_feats)
+        self.selected_feats.extend(self.selected_nominal_feats)
+        if isinstance(self.model, RandomForestClassifier) or isinstance(self.model, XGBClassifier):
+            self.selected_feats.extend(self.boruta_feats)
+        self.selected_feats = list(set(self.selected_feats))
+
+        # self.selected_feats = self.get_shap_feats(self.selected_feats)
+
+        return self.selected_feats
+
+
+def create_feature_selection_dict(data, cv_fold_list, numerical_features, nominal_features):
+    '''
+    Returns feature selection dictionary for 4 different models
+
+    Args:
+        data (pd.DataFrame): train data 
+        cv_fold_list (list): contains tuples of indeces of train and validation data for each fold
+        numerical_features (list): contains the names of numerical features
+        nominal_features (list): contains the names of nominal features
+
+    Returns:
+        dict: contains selected features, train and validation scores, models and scalers used
+    '''
+
+    selected_features_dict = {}
+
+    for idx in tqdm(range(1)):
+
+        X_train = data.iloc[cv_fold_list[idx][0]].reset_index(drop=True)
+        y_train = data.iloc[cv_fold_list[idx][0]
+                            ]['Bankrupt?'].to_frame().reset_index(drop=True)
+
+        X_valid = data.iloc[cv_fold_list[idx][1]].reset_index(drop=True)
+        y_valid = data.iloc[cv_fold_list[idx][1]
+                            ]['Bankrupt?'].to_frame().reset_index(drop=True)
+
+        new_numerical_features = []
+        for feat in numerical_features:
+            X_train[f"feat{numerical_features.index(feat)}"] = X_train[feat] * \
+                X_train[' Liability-Assets Flag']
+            X_valid[f"feat{numerical_features.index(feat)}"] = X_valid[feat] * \
+                X_valid[' Liability-Assets Flag']
+            new_numerical_features.append(
+                f"feat{numerical_features.index(feat)}")
+
+        numerical_features.extend(new_numerical_features)
+
+        # getting categorical features
+        categorical_features = nominal_features.copy()
+
+        # getting all features
+        all_features = []
+        all_features.extend(categorical_features)
+        all_features.extend(numerical_features)
+
+        X_train = X_train[all_features]
+        X_valid = X_valid[all_features]
+
+        models_list = [RandomForestClassifier(), XGBClassifier(
+        ), LogisticRegression(), SVC(probability=True)]
+        model_names_list = ['RandomForestClassifier',
+                            'XGBClassifier', 'LogisticRegression', 'SVC']
+
+        for model_idx in tqdm(range(len(model_names_list))):
+
+            model_name = model_names_list[model_idx]
+
+            selected_features_dict[model_name] = {}
+
+            # feature selection
+            model = models_list[model_idx]
+
+            if isinstance(model, LogisticRegression) or isinstance(model, SVC):
+
+                scaler = StandardScaler()
+
+                X_train2 = scaler.fit_transform(X_train[numerical_features])
+                X_train2 = pd.DataFrame(X_train2, columns=numerical_features)
+                X_train2 = pd.concat(
+                    [X_train2, X_train[categorical_features]], axis=1)
+
+                fselector = FSelector(
+                    X=X_train2,
+                    y=y_train,
+                    num_feats=numerical_features,
+                    ordinal_feats=None,
+                    nominal_feats=nominal_features,
+                    model=model
+                )
+
+            else:
+
+                fselector = FSelector(
+                    X=X_train,
+                    y=y_train,
+                    num_feats=numerical_features,
+                    ordinal_feats=None,
+                    nominal_feats=nominal_features,
+                    model=model
+                )
+
+            selected_features = fselector.get_features()
+
+            if len(selected_features) == 0:
+                continue
+
+            # selecting features using shap values
+            if isinstance(model, LogisticRegression) or isinstance(model, SVC):
+
+                X_valid2 = scaler.transform(X_valid[numerical_features])
+                X_valid2 = pd.DataFrame(X_valid2, columns=numerical_features)
+                X_valid2 = pd.concat(
+                    [X_valid2, X_valid[categorical_features]], axis=1)
+
+                X_train_filtered = X_train2[selected_features]
+                X_valid_filtered = X_valid2[selected_features]
+
+            else:
+
+                X_train_filtered = X_train[selected_features]
+                X_valid_filtered = X_valid[selected_features]
+
+            # model training using selected features
+            model.fit(X_train_filtered, y_train)
+
+            explainer = shap.Explainer(
+                model.predict,
+                X_train_filtered,
+                # max_evals = int(2 * X_train_filtered.shape[1] + 1),
+                # verbose=0
+            )
+            shap_values = explainer(X_train_filtered)
+            selected_shap_features = get_shap_features(
+                shap_values,
+                features=list(X_train_filtered.columns),
+                topk=10
+            )
+
+            # model training using shap features
+            model = models_list[model_idx]
+            model.fit(X_train_filtered[selected_shap_features], y_train)
+
+            # metric calculation
+            y_train_pred = model.predict(
+                X_train_filtered[selected_shap_features])
+            y_train_pred_prob = model.predict_proba(
+                X_train_filtered[selected_shap_features])[:, 1]
+
+            y_valid_pred = model.predict(
+                X_valid_filtered[selected_shap_features])
+            y_valid_pred_prob = model.predict_proba(
+                X_valid_filtered[selected_shap_features])[:, 1]
+
+            train_acc = accuracy_score(y_train, y_train_pred)
+            train_f1 = f1_score(y_train, y_train_pred)
+            train_roc_auc = roc_auc_score(y_train, y_train_pred_prob)
+
+            valid_acc = accuracy_score(y_valid, y_valid_pred)
+            valid_f1 = f1_score(y_valid, y_valid_pred)
+            valid_roc_auc = roc_auc_score(y_valid, y_valid_pred_prob)
+
+            selected_features_dict[model_name][idx+1] = {}
+            selected_features_dict[model_name][idx +
+                                               1]['selected_feats'] = selected_features
+            selected_features_dict[model_name][idx +
+                                               1]['selected_shap_feats'] = selected_shap_features
+            selected_features_dict[model_name][idx+1]['train_acc'] = train_acc
+            selected_features_dict[model_name][idx+1]['train_f1'] = train_f1
+            selected_features_dict[model_name][idx +
+                                               1]['train_roc_auc'] = train_roc_auc
+            selected_features_dict[model_name][idx+1]['valid_acc'] = valid_acc
+            selected_features_dict[model_name][idx+1]['valid_f1'] = valid_f1
+            selected_features_dict[model_name][idx +
+                                               1]['valid_roc_auc'] = valid_roc_auc
+            selected_features_dict[model_name][idx+1]['model'] = model
+            if isinstance(model, LogisticRegression) or isinstance(model, SVC):
+                selected_features_dict[model_name][idx+1]['scaler'] = scaler
+
+            # print(f"##### {model_name} #####")
+            # print(f"Selected features: {selected_features}")
+            # print("Train:")
+            # print(f"Accuracy: {train_acc:.5f}, F1: {train_f1:.5f}, ROC-AUC: {train_roc_auc:.5f}")
+            # print("Validation:")
+            # print(f"Accuracy: {valid_acc:.5f}, F1: {valid_f1:.5f}, ROC-AUC: {valid_roc_auc:.5f}")
+
+            logging.info(f"##### {model_name} #####")
+            logging.info(f"Selected features: {selected_features}")
+            logging.info('Train:')
+            logging.info(
+                f"Accuracy: {train_acc:.5f}, F1: {train_f1:.5f}, ROC-AUC: {train_roc_auc:.5f}")
+            logging.info('Validation:')
+            logging.info(
+                f"Accuracy: {valid_acc:.5f}, F1: {valid_f1:.5f}, ROC-AUC: {valid_roc_auc:.5f}")
+
+        del X_train, y_train, X_valid, y_valid, X_train_filtered, X_valid_filtered, model
+        gc.collect()
+
+    return selected_features_dict
+
+
+def get_mean_ensemble_prediction(prob_list):
+    prob_array = np.vstack(prob_list).T
+    return np.mean(prob_array, axis=1)
+
+
+class OptimizeAUC:
+    def __init__(self):
+        self.coef_ = 0
+
+    def _auc(self, coef, X, y):
+        X_coef = X * coef
+        preds = np.sum(X_coef, axis=1)
+        auc_score = roc_auc_score(y, preds)
+        return -1 * auc_score
+
+    def fit(self, X, y):
+        loss_partial = partial(self._auc, X=X, y=y)
+        initial_coef = np.random.dirichlet(np.ones(X.shape[1]), size=1)
+        self.coef_ = fmin(loss_partial, initial_coef, disp=True)
+
+    def predict(self, X):
+        X_coef = X * self.coef_
+        preds = np.sum(X_coef, axis=1)
+        return preds
+
+
+def get_optimized_ensemble(train_df, test_df, cv_fold_list, selected_features_dict, trained_models_dict, numerical_features):
+    '''
+    Finds the optimized weights for ensembling using the train data and evaluates it on test data
+
+    Args:
+        train_df (pd.DataFrame): train data 
+        test_df (pd.DataFrame): test data 
+        cv_fold_list (list): contains tuples of indeces of train and validation data for each fold
+        selected_features_dict (dict): selected features dictionary where keys are models' names
+        trained_models_dict (dict): trained models dictionary where keys are models' names
+        numerical_features (list): contains the names of numerical features
+
+    Returns:
+        dict: contains all optimized weights for each fold
+        float: ROC-AUC score
+    '''
+
+    opt_dict = {}
+
+    test_preds_list = []
+    # valid_preds_list = []
+
+    X_test_rf = test_df[selected_features_dict['RandomForestClassifier']
+                        [1]['selected_shap_feats']]
+    X_test_xgb = test_df[selected_features_dict['XGBClassifier']
+                         [1]['selected_shap_feats']]
+    X_test_lr = test_df[selected_features_dict['LogisticRegression']
+                        [1]['selected_shap_feats']]
+    X_test_svc = test_df[selected_features_dict['SVC']
+                         [1]['selected_shap_feats']]
+
+    y_test = test_df['Bankrupt?'].to_frame()
+
+    for idx in range(len(cv_fold_list)):
+
+        logging.info(f'Starting calculations for Fold {idx+1}')
+
+        X_train = train_df.iloc[cv_fold_list[idx][0]].reset_index(drop=True)
+        y_train = train_df.iloc[cv_fold_list[idx][0]
+                                ]['Bankrupt?'].to_frame().reset_index(drop=True)
+
+        X_valid = train_df.iloc[cv_fold_list[idx][1]].reset_index(drop=True)
+        y_valid = train_df.iloc[cv_fold_list[idx][1]
+                                ]['Bankrupt?'].to_frame().reset_index(drop=True)
+
+        # RandomForest
+        logging.info('Starting RandomForest calculations')
+        rf_selected_features = selected_features_dict['RandomForestClassifier'][1]['selected_shap_feats']
+        X_train_rf = X_train[rf_selected_features]
+        X_valid_rf = X_valid[rf_selected_features]
+
+        rf_gscv = trained_models_dict['RandomForestClassifier']
+
+        rfm = RandomForestClassifier(**rf_gscv.best_params_)
+        rfm.fit(X_train_rf, y_train)
+        rfm_valid_probs = rfm.predict_proba(X_valid_rf)[:, 1]
+
+        rfm_test_probs = rfm.predict_proba(X_test_rf)[:, 1]
+        logging.info('RandomForest calculations completed')
+
+        # XGBoost
+        logging.info('Starting XGBoost calculations')
+        xgb_selected_features = selected_features_dict['XGBClassifier'][1]['selected_shap_feats']
+        X_train_xgb = X_train[xgb_selected_features]
+        X_valid_xgb = X_valid[xgb_selected_features]
+
+        xgb_gscv = trained_models_dict['XGBClassifier']
+
+        xgbm = XGBClassifier(**xgb_gscv.best_params_)
+        xgbm.fit(X_train_xgb, y_train)
+        xgbm_valid_probs = xgbm.predict_proba(X_valid_xgb)[:, 1]
+        xgbm_test_probs = xgbm.predict_proba(X_test_xgb)[:, 1]
+        logging.info('XGBoost calculations completed')
+
+        # LogisticRegression
+        logging.info('Starting LogisticRegression calculations')
+        lr_selected_features = selected_features_dict['LogisticRegression'][1]['selected_shap_feats']
+        X_train_lr = X_train[lr_selected_features]
+        X_valid_lr = X_valid[lr_selected_features]
+
+        lr_gscv = trained_models_dict['LogisticRegression']
+
+        lr_params = {k.replace('model__', ''): v for k,
+                     v in lr_gscv.best_params_.items()}
+        selected_shap_features = selected_features_dict['LogisticRegression'][1]['selected_shap_feats']
+        num_feat = [
+            col for col in selected_shap_features if col in numerical_features]
+        num_trans = Pipeline([('scale', StandardScaler())])
+        preprocessor = ColumnTransformer(
+            transformers=[('num', num_trans, num_feat)], remainder='passthrough')
+        lrm = Pipeline(
+            [
+                ('preproc', preprocessor),
+                ('lr', LogisticRegression(**lr_params))
+            ]
+        )
+        lrm.fit(X_train_lr, y_train)
+        lrm_valid_probs = lrm.predict_proba(X_valid_lr)[:, 1]
+        lrm_test_probs = lrm.predict_proba(X_test_lr)[:, 1]
+        logging.info('LogisticRegression calculations completed')
+
+        # SVC
+        logging.info('Starting SVC calculations')
+        svc_selected_features = selected_features_dict['SVC'][1]['selected_shap_feats']
+        X_train_svc = X_train[svc_selected_features]
+        X_valid_svc = X_valid[svc_selected_features]
+
+        svc_gscv = trained_models_dict['SVC']
+
+        svc_params = {k.replace('model__', ''): v for k,
+                      v in svc_gscv.best_params_.items()}
+        selected_shap_features = selected_features_dict['SVC'][1]['selected_shap_feats']
+        num_feat = [
+            col for col in selected_shap_features if col in numerical_features]
+        num_trans = Pipeline([('scale', StandardScaler())])
+        preprocessor = ColumnTransformer(
+            transformers=[('num', num_trans, num_feat)], remainder='passthrough')
+        svcm = Pipeline(
+            [
+                ('preproc', preprocessor),
+                ('svc', SVC(probability=True, **svc_params))
+            ]
+        )
+        svcm.fit(X_train_svc, y_train)
+        svcm_valid_probs = svcm.predict_proba(X_valid_svc)[:, 1]
+        svcm_test_probs = svcm.predict_proba(X_test_svc)[:, 1]
+        logging.info('SVC calculations completed')
+
+        logging.info('Optimizing Ensemble weights')
+        valid_preds = np.column_stack([
+            rfm_valid_probs,
+            xgbm_valid_probs,
+            lrm_valid_probs,
+            svcm_valid_probs
+        ])
+
+        opt = OptimizeAUC()
+        opt.fit(valid_preds, y_valid)
+        opt_dict[idx] = {}
+        opt_dict[idx]['opt'] = opt
+        opt_dict[idx]['rfm'] = rfm
+        opt_dict[idx]['xgbm'] = xgbm
+        opt_dict[idx]['lrm'] = lrm
+        opt_dict[idx]['svcm'] = svcm
+        logging.info('Optimization finished')
+
+        # valid_preds_list.append(opt.predict(valid_preds))
+
+        logging.info('Calculating predictions for test set')
+        test_preds = np.column_stack([
+            rfm_test_probs,
+            xgbm_test_probs,
+            lrm_test_probs,
+            svcm_test_probs
+        ])
+
+        test_preds_list.append(opt.predict(test_preds))
+        logging.info('Test set predictions calculated')
+
+    logging.info('Getting the score for test set')
+    opt_y_test_pred_prob = np.mean(np.column_stack(test_preds_list), axis=1)
+    opt_test_roc_auc = roc_auc_score(y_test, opt_y_test_pred_prob)
+    logging.info('Test score calculated')
+
+    return (opt_dict, opt_test_roc_auc)
+
+
+def find_optimal_model(train_df, test_df, features_dict_path, cv_fold_list, numerical_features):
+    '''
+    Finds the best model for the train data and evaluates it on test data
+
+    Args:
+        train_df (pd.DataFrame): train data 
+        test_df (pd.DataFrame): test data 
+        features_dict_path (str): path to selected features dictionary
+        cv_fold_list (list): contains tuples of indeces of train and validation data for each fold
+        numerical_features (list): contains the names of numerical features
+
+    Returns:
+        dict: contains all trained models and the name of the best model
+        dict: contains all optimized weights of ensembling for each fold
+    '''
+    logging.info('Loading selected features dictionary')
+    selected_features_dict = load_object(file_path=features_dict_path)
+    logging.info('Selected features dictionary loaded')
+
+    models_list = [RandomForestClassifier(), XGBClassifier(),
+                   LogisticRegression(), SVC(probability=True)]
+    model_names_list = ['RandomForestClassifier',
+                        'XGBClassifier', 'LogisticRegression', 'SVC']
+    model_params_list = [
+        {
+            'n_estimators': [5, 10, 15, 25, 50, 100, 120, 300, 500],
+            'max_depth': [2, 3, 5, 8, 15, 25, 30, None]
+        },
+        {
+            'eta': [0.01, 0.015, 0.025, 0.05, 0.1, 0.3, 0.4, 0.5, 0.6, 0.7, 0.9],
+            'max_depth': [3, 5, 6, 7, 9, 12, 15, 17, 25],
+            'n_estimators': [50, 100, 150, 200, 500, 1000]
+        },
+        {'model__penalty': ['l1', 'l2'], 'model__C': [
+            0.001, 0.01, 0.1, 1, 10, 100, 1000]},
+        {'model__C': [1, 10, 100, 1000], 'model__gamma': [
+            1, 0.1, 0.001, 0.0001], 'model__kernel': ['linear', 'rbf']}
+    ]
+
+    trained_models_dict = {}
+
+    best_score = 0
+    best_model_name = None
+
+    
+    y_train = train_df['Bankrupt?'].to_frame()
+    y_test = test_df['Bankrupt?'].to_frame()
+
+    y_train_pred_prob_list = []
+    y_test_pred_prob_list = []
+    rank_ensemble_list = []
+
+    for model_idx in tqdm(range(len(model_names_list))):
+
+        # y_train_pred_prob = np.zeros(X_train.shape)
+
+        model_name = model_names_list[model_idx]
+
+        selected_shap_features = selected_features_dict[model_name][1]['selected_shap_feats']
+
+        X_train = train_df[selected_shap_features]
+        X_test = test_df[selected_shap_features]
+
+        logging.info(f'Starting {model_name} training')
+        params_dict = model_params_list[model_idx]
+
+        model = models_list[model_idx]
+
+        if isinstance(model, LogisticRegression) or isinstance(model, SVC):
+            num_feat = [
+                col for col in selected_shap_features if col in numerical_features]
+            num_trans = Pipeline([('scale', StandardScaler())])
+            preprocessor = ColumnTransformer(
+                transformers=[('num', num_trans, num_feat)], remainder='passthrough')
+            pipe = Pipeline(
+                [
+                    ('preproc', preprocessor),
+                    ('model', model)
+                ]
+            )
+
+            model_gscv = GridSearchCV(
+                pipe,
+                param_grid=params_dict,
+                scoring='roc_auc',
+                cv=cv_fold_list,
+                n_jobs=-1,
+                verbose=4
+            )
+        else:
+            model_gscv = GridSearchCV(
+                model,
+                param_grid=params_dict,
+                scoring='roc_auc',
+                cv=cv_fold_list,
+                n_jobs=-1,
+                verbose=4
+            )
+
+        model_gscv.fit(X_train, y_train)
+        logging.info(f'{model_name} training finished')
+
+        trained_models_dict[model_name] = model_gscv
+
+        rank_ensemble_list.append((model_name, model_gscv.best_score_))
+
+        # for train_idxs, valid_idxs in cv_fold_list:
+        #     temp_model = models_list[model_idx]
+        #     y_train_pred_prob[valid_idxs, :] = model_gscv.predict_proba(X_train[valid_idxs, :])[:, 1]
+        # y_train_pred_prob_list.append(y_train_pred_prob)
+
+        logging.info('Getting ROC-AUC for test set')
+        y_test_pred_prob = model_gscv.predict_proba(X_test)[:, 1]
+        y_test_pred_prob_list.append(y_test_pred_prob)
+        test_roc_auc = roc_auc_score(y_test, y_test_pred_prob)
+        logging.info(
+            f'{model_name}:  Validation score = {model_gscv.best_score_:.4f}, Test score = {test_roc_auc:.4f}')
+
+        if test_roc_auc > best_score:
+            best_score = test_roc_auc
+            best_model_name = model_name
+
+    logging.info('Getting Average Ensemble score')
+    # avg_ens_y_train_pred_prob = get_mean_ensemble_prediction(y_train_pred_prob_list)
+    # avg_ens_train_roc_auc = roc_auc_score(y_test, avg_ens_y_train_pred_prob)
+
+    avg_ens_y_test_pred_prob = get_mean_ensemble_prediction(
+        y_test_pred_prob_list)
+    avg_ens_test_roc_auc = roc_auc_score(y_test, avg_ens_y_test_pred_prob)
+    logging.info(f'Average Ensemble: Test score = {avg_ens_test_roc_auc:.4f}')
+    # logging.info(f'Average Ensemble:  Validation score = {avg_ens_train_roc_auc:.4f}, Test score = {avg_ens_test_roc_auc:.4f}')
+
+    if avg_ens_test_roc_auc > best_score:
+        best_score = avg_ens_test_roc_auc
+        best_model_name = 'Average Ensemble'
+
+    logging.info('Getting Rank Ensemble score')
+    rank_ensemble_list = sorted(rank_ensemble_list, key=lambda x: x[1])
+
+    # rank_ens_y_train_pred_prob = 0
+    rank_ens_y_test_pred_prob = 0
+    for i in range(len(rank_ensemble_list)):
+        # rank_ens_y_train_pred_prob += (i+1) * y_train_pred_prob_list[model_names_list.index(rank_ensemble_list[i][0])]
+        rank_ens_y_test_pred_prob += (
+            i+1) * y_test_pred_prob_list[model_names_list.index(rank_ensemble_list[i][0])]
+    # rank_ens_y_train_pred_prob /= len(rank_ensemble_list) * (1+ len(rank_ensemble_list)) / 2
+    rank_ens_y_test_pred_prob /= len(rank_ensemble_list) * \
+        (1 + len(rank_ensemble_list)) / 2
+    rank_ens_test_roc_auc = roc_auc_score(y_test, rank_ens_y_test_pred_prob)
+
+    logging.info(f'Rank Ensemble:  Test score = {rank_ens_test_roc_auc:.4f}')
+    # logging.info(f'Rank Ensemble:  Validation score = {rank_ens_y_train_pred_prob:.4f}, Test score = {rank_ens_y_test_pred_prob:.4f}')
+
+    if rank_ens_test_roc_auc > best_score:
+        best_score = rank_ens_test_roc_auc
+        best_model_name = 'Rank Ensemble'
+
+    logging.info('Getting Optimized Ensemble score')
+    opt_dict, opt_test_roc_auc = get_optimized_ensemble(
+        train_df,
+        test_df,
+        cv_fold_list,
+        selected_features_dict,
+        trained_models_dict,
+        numerical_features
+    )
+
+    logging.info(f'Optimized Ensemble:  Test score = {opt_test_roc_auc:.4f}')
+
+    if opt_test_roc_auc > best_score:
+        best_score = opt_test_roc_auc
+        best_model_name = 'Optimized Ensemble'
+
+    trained_models_dict['best_model_name'] = best_model_name
+
+    logging.info(f'{best_model_name} is the best model')
+
+    return (trained_models_dict, opt_dict)

requirements.txt

@@ -0,0 +1,160 @@
+alembic==1.13.1
+altair==5.3.0
+aniso8601==9.0.1
+annotated-types==0.6.0
+anyio==4.3.0
+appdirs==1.4.4
+asttokens @ file:///home/conda/feedstock_root/build_artifacts/asttokens_1698341106958/work
+attrs==23.2.0
+blinker==1.7.0
+Boruta==0.3
+BorutaShap==1.0.17
+cachetools==5.3.3
+certifi==2024.2.2
+charset-normalizer==3.3.2
+click==8.1.7
+cloudpickle==3.0.0
+colorama @ file:///home/conda/feedstock_root/build_artifacts/colorama_1666700638685/work
+comm @ file:///home/conda/feedstock_root/build_artifacts/comm_1710320294760/work
+-e git+https://github.com/VaheC/CompanyBankruptcy.git@0c9aba9c454511775cdf83313b15ca93d56c3356#egg=CompanyBankruptcy
+contourpy==1.2.1
+cycler==0.12.1
+debugpy @ file:///C:/b/abs_c0y1fjipt2/croot/debugpy_1690906864587/work
+decorator @ file:///home/conda/feedstock_root/build_artifacts/decorator_1641555617451/work
+Deprecated==1.2.14
+distro==1.9.0
+dnspython==1.16.0
+docker==7.1.0
+dynaconf==3.2.5
+ensure==1.0.2
+entrypoints==0.4
+et-xmlfile==1.1.0
+evidently==0.4.22
+exceptiongroup @ file:///home/conda/feedstock_root/build_artifacts/exceptiongroup_1704921103267/work
+executing @ file:///home/conda/feedstock_root/build_artifacts/executing_1698579936712/work
+Faker==25.2.0
+filelock==3.14.0
+Flask==3.0.3
+fonttools==4.51.0
+from-root==1.3.0
+fsspec==2024.3.1
+gitdb==4.0.11
+GitPython==3.1.43
+graphene==3.3
+graphql-core==3.2.3
+graphql-relay==3.2.0
+greenlet==3.0.3
+h11==0.14.0
+httpcore==1.0.5
+httptools==0.6.1
+httpx==0.27.0
+idna==3.6
+imbalanced-learn==0.12.2
+imblearn==0.0
+importlib-metadata==6.11.0
+ipykernel @ file:///D:/bld/ipykernel_1708996677248/work
+ipython @ file:///D:/bld/ipython_1709559926914/work
+iterative-telemetry==0.0.8
+itsdangerous==2.2.0
+jedi @ file:///home/conda/feedstock_root/build_artifacts/jedi_1696326070614/work
+Jinja2==3.1.3
+joblib==1.4.0
+jsonschema==4.21.1
+jsonschema-specifications==2023.12.1
+jupyter_client @ file:///home/conda/feedstock_root/build_artifacts/jupyter_client_1710255804825/work
+jupyter_core @ file:///D:/bld/jupyter_core_1710257272359/work
+kiwisolver==1.4.5
+lightgbm==4.3.0
+litestar==2.8.3
+llvmlite==0.42.0
+Mako==1.3.5
+Markdown==3.6
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+matplotlib==3.8.4
+matplotlib-inline @ file:///home/conda/feedstock_root/build_artifacts/matplotlib-inline_1713250518406/work
+mdurl==0.1.2
+mlflow==2.13.0
+msgspec==0.18.6
+multidict==6.0.5
+mypy-extensions==1.0.0
+nest_asyncio @ file:///home/conda/feedstock_root/build_artifacts/nest-asyncio_1705850609492/work
+nltk==3.8.1
+numba==0.59.1
+numpy==1.26.4
+openpyxl==3.1.2
+opentelemetry-api==1.24.0
+opentelemetry-sdk==1.24.0
+opentelemetry-semantic-conventions==0.45b0
+packaging==23.2
+pandas==2.2.1
+parso @ file:///home/conda/feedstock_root/build_artifacts/parso_1712320355065/work
+patsy==0.5.6
+pickleshare @ file:///home/conda/feedstock_root/build_artifacts/pickleshare_1602536217715/work
+pillow==10.3.0
+platformdirs @ file:///home/conda/feedstock_root/build_artifacts/platformdirs_1706713388748/work
+plotly==5.22.0
+polyfactory==2.16.0
+prompt-toolkit @ file:///home/conda/feedstock_root/build_artifacts/prompt-toolkit_1702399386289/work
+protobuf==4.25.3
+psutil @ file:///C:/Windows/Temp/abs_b2c2fd7f-9fd5-4756-95ea-8aed74d0039flsd9qufz/croots/recipe/psutil_1656431277748/work
+pure-eval @ file:///home/conda/feedstock_root/build_artifacts/pure_eval_1642875951954/work
+pyarrow==15.0.2
+pydantic==2.7.1
+pydantic_core==2.18.2
+pydeck==0.8.1b0
+Pygments @ file:///home/conda/feedstock_root/build_artifacts/pygments_1700607939962/work
+pymongo==4.7.2
+pyparsing==3.1.2
+python-dateutil @ file:///home/conda/feedstock_root/build_artifacts/python-dateutil_1709299778482/work
+python-dotenv==1.0.1
+pytz==2024.1
+pywin32==305.1
+PyYAML==6.0.1
+pyzmq @ file:///C:/b/abs_89aq69t0up/croot/pyzmq_1705605705281/work
+querystring-parser==1.2.4
+referencing==0.34.0
+regex==2024.5.10
+requests==2.31.0
+rich==13.7.1
+rich-click==1.8.1
+rpds-py==0.18.0
+scikit-learn==1.4.2
+scipy==1.13.0
+seaborn==0.13.2
+shap==0.45.0
+shellingham==1.5.4
+six @ file:///home/conda/feedstock_root/build_artifacts/six_1620240208055/work
+slicer==0.0.7
+smmap==5.0.1
+sniffio==1.3.1
+SQLAlchemy==2.0.30
+sqlparse==0.5.0
+stack-data @ file:///home/conda/feedstock_root/build_artifacts/stack_data_1669632077133/work
+statsmodels==0.14.2
+streamlit==1.28.0
+tenacity==8.2.3
+threadpoolctl==3.5.0
+toml==0.10.2
+toolz==0.12.1
+tornado @ file:///D:/bld/tornado_1656937966227/work
+tqdm==4.66.2
+traitlets @ file:///home/conda/feedstock_root/build_artifacts/traitlets_1713535121073/work
+typer==0.12.3
+typing-inspect==0.9.0
+typing_extensions @ file:///home/conda/feedstock_root/build_artifacts/typing_extensions_1712329955671/work
+tzdata==2024.1
+tzlocal==5.2
+ujson==5.10.0
+urllib3==2.2.1
+uvicorn==0.29.0
+validators==0.28.3
+waitress==3.0.0
+watchdog==4.0.0
+watchfiles==0.21.0
+wcwidth @ file:///home/conda/feedstock_root/build_artifacts/wcwidth_1704731205417/work
+websockets==12.0
+Werkzeug==3.0.3
+wrapt==1.16.0
+xgboost==2.0.3
+zipp @ file:///home/conda/feedstock_root/build_artifacts/zipp_1695255097490/work