| from sklearn.model_selection import GridSearchCV |
| from sklearn.ensemble import (RandomForestClassifier, AdaBoostClassifier, |
| GradientBoostingClassifier, BaggingClassifier) |
| from xgboost import XGBClassifier |
| from sklearn.svm import SVC |
| from sklearn.linear_model import LogisticRegression |
| from sklearn.metrics import precision_score, recall_score, f1_score, make_scorer |
| import logging |
| from sklearn.neural_network import MLPClassifier |
| import joblib |
| from collections import defaultdict |
| import config |
| import os |
| from sklearn.preprocessing import LabelEncoder |
| import numpy as np |
| from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay |
| import matplotlib.pyplot as plt |
| from utils import get_feature_name_list, get_file_name |
| from time import time |
|
|
|
|
| class FlexibleClassifier: |
| def __init__(self, dataset_dict, property_dict, params_dict, seed, logger, dataset_name, evaluation_mode, |
| dataset_size_version, neg_samples_num, load_trained_models=False, cv=5, dirty=False, |
| contamination_level=0.0, contaminated_indices_dict=None): |
| self.dataset_dict = dataset_dict |
| self.property_dict = property_dict |
| self.params_dict = params_dict |
| self.seed = seed |
| self.dataset_size_version = dataset_size_version |
| self.neg_samples_num = neg_samples_num |
| self.load_trained_models = load_trained_models |
| self.dirty = dirty |
| self.cv = cv |
| self.models_path = f"{config.FilePaths.saved_models_path}/{dataset_name}/" |
| self.dataset_name = dataset_name |
| self.logger = logger |
| self.evaluation_mode = evaluation_mode |
| self.contamination_level = contamination_level |
| self.contaminated_indices_dict = contaminated_indices_dict |
| self.model_dict = self._get_model_dict() |
| self.file_name = get_file_name() |
| self.scorer = make_scorer(f1_score, average='macro') |
| self.best_model_dict, self.result_dict = self._train_and_evaluate_all_models() |
| self._print_results() |
|
|
| def _get_model_dict(self): |
| model_dict = { |
| 'RandomForestClassifier': RandomForestClassifier(random_state=self.seed), |
| 'SVC': SVC(random_state=self.seed), |
| 'LogisticRegression': LogisticRegression(random_state=self.seed), |
| 'MLPClassifier': MLPClassifier(random_state=self.seed), |
| 'AdaBoostClassifier': AdaBoostClassifier(random_state=self.seed), |
| 'GradientBoostingClassifier': GradientBoostingClassifier(random_state=self.seed), |
| 'BaggingClassifier': BaggingClassifier(random_state=self.seed), |
| 'XGBClassifier': XGBClassifier(random_state=self.seed) |
| } |
| return model_dict |
|
|
| def _get_model_general_file_name(self): |
| general_file_name = (f"{self.evaluation_mode}_{self.file_name}_{self.dataset_size_version}_" |
| f"neg_samples_num={self.neg_samples_num}") |
| if self.contamination_level > 0.0: |
| general_file_name += f"_contamination_level={self.contamination_level}" |
| return general_file_name |
|
|
| def _save_model(self, model, model_name): |
| general_file_name = self._get_model_general_file_name() |
| if not os.path.exists(self.models_path[:-1]): |
| os.makedirs(self.models_path[:-1]) |
| try: |
| model_file_name = f'{self.models_path}{model_name}_{general_file_name}_seed{self.seed}.joblib' |
| feature_name_list = self._get_final_feature_name_list() |
| joblib.dump({'model': model, 'feature_name_list': feature_name_list}, model_file_name) |
| logging.info(f"Model {model_name} was saved successfully ({self.evaluation_mode})") |
| logging.info('') |
| except Exception as e: |
| logging.error(f"Error happened while saving model {model_name} ({self.evaluation_mode}): {e}") |
|
|
| def _load_model(self, model_name): |
| general_file_name = self._get_model_general_file_name() |
| try: |
| model = joblib.load(f'{self.models_path}{model_name}_{general_file_name}_seed{self.seed}.joblib') |
| logging.info(f"Model {model_name} was loaded successfully") |
| logging.info('') |
| print(f"Model {model_name} was loaded successfully {self.evaluation_mode})") |
| return model['model'] |
| except Exception as e: |
| logging.error(f"Error happened while loading model {model_name}: {e}. Starting training...") |
| print(f"Error happened while loading model {model_name}: {e}. Starting training...") |
| return None |
|
|
| @staticmethod |
| def _get_final_feature_name_list(): |
| operator = config.Features.operator |
| feature_name_list = get_feature_name_list(operator) |
| return feature_name_list |
|
|
| @staticmethod |
| def _get_neighborhood_feature_name_list(): |
| if config.Features.knn_buildings == 0: |
| return [] |
| with_knn = [f"{i}_nearest_building_dists" for i in range(1, config.Features.knn_buildings + 1)] |
| other_features = [feature for feature in config.Features.neighborhood if feature != "nearest_building_dists"] |
| return with_knn + other_features |
|
|
| @staticmethod |
| def _get_roads_feature_name_list(): |
| if config.Features.knn_roads == 0: |
| return [] |
| with_knn = [f"{i}_nearest_road_dists" for i in range(1, config.Features.knn_roads + 1)] |
| other_features = [feature for feature in config.Features.roads if feature != "nearest_road_dists"] |
| return with_knn + other_features |
|
|
| def _train_and_evaluate_all_models(self): |
| result_dict = defaultdict(dict) |
| best_model_dict = defaultdict(dict) |
| for model_name, model_params in self.params_dict.items(): |
| try: |
| best_model_dict, result_dict = self._train_and_evaluate_model_wrapper(result_dict, best_model_dict, |
| model_name, model_params) |
| except Exception as e: |
| logging.error(f"Error for model {model_name}: {e}") |
| return best_model_dict, result_dict |
|
|
| def _train_and_evaluate_model_wrapper(self, result_dict, best_model_dict, model_name, model_params): |
| if self.contaminated_indices_dict is not None: |
| best_model_dict[model_name], result_dict = self._train_and_evaluate_model_contam(result_dict, |
| model_name, |
| model_params) |
| elif self.dirty is True: |
| best_model_dict[model_name], result_dict = self._train_and_evaluate_model_dirty(result_dict, |
| model_name, |
| model_params) |
|
|
| else: |
| best_model_dict[model_name], result_dict = self._train_and_evaluate_model(result_dict, |
| model_name, |
| model_params) |
| return best_model_dict, result_dict |
|
|
| def _get_best_model(self, model_name, params): |
| if self.load_trained_models: |
| best_model = self._load_model(model_name) |
| if best_model is not None: |
| return best_model, 0.0 |
| model = self.model_dict[model_name] |
| best_model, training_time = self._train_model(model_name, model, params) |
| self._save_model(best_model, model_name) |
| return best_model, training_time |
|
|
| def _train_and_evaluate_model(self, result_dict, model_name, params): |
| best_model, training_time = self._get_best_model(model_name, params) |
| feature_name_list = self._get_final_feature_name_list() |
| data_type = 'train' if self.evaluation_mode == "blocking" else 'test' |
| x_test = self.dataset_dict[data_type]['X'] |
| start_time = time() |
| y_test_preds = best_model.predict(x_test) |
| inference_time = round(time() - start_time, 2) |
| self.logger.info(f"Model {model_name} was evaluated successfully in {inference_time} seconds") |
| result_dict = self._insert_results_to_dict(result_dict, model_name, y_test_preds, |
| training_time, inference_time) |
| return {'model': best_model, 'feature_name_list': feature_name_list}, result_dict |
|
|
| def _train_and_evaluate_model_contam(self, result_dict, model_name, params): |
| best_model, _ = self._get_best_model(model_name, params) |
| feature_name_list = self._get_final_feature_name_list() |
| contaminated_indices = self.contaminated_indices_dict['test'] |
| x_test_all = self.dataset_dict['test']['X'] |
| x_test_contaminated = x_test_all[contaminated_indices] |
| y_test_preds_all = best_model.predict(x_test_all) |
| y_test_preds_contaminated = best_model.predict(x_test_contaminated) |
| self.logger.info(f"Model {model_name} was evaluated successfully") |
| result_dict = self._insert_results_to_dict_contaminated(result_dict, model_name, y_test_preds_all, |
| y_test_preds_contaminated, contaminated_indices) |
| return {'model': best_model, 'feature_name_list': feature_name_list}, result_dict |
|
|
| def _train_and_evaluate_model_dirty(self, result_dict, model_name, params): |
| best_model, training_time = self._get_best_model(model_name, params) |
| feature_name_list = self._get_final_feature_name_list() |
| x_test = self.dataset_dict['test']['X'] |
| x_test_dirty = self.dataset_dict['test_dirty']['X'] |
| y_test_preds = best_model.predict(x_test) |
| y_test_preds_dirty = best_model.predict(x_test_dirty) |
| result_dict = self._insert_results_to_dict_dirty(result_dict, model_name, y_test_preds, y_test_preds_dirty) |
| return {'model': best_model, 'feature_name_list': feature_name_list}, result_dict |
|
|
| def _get_y_train(self, model_name): |
| y_train = self.dataset_dict['train']['Y'] |
| if model_name == 'XGBClassifier': |
| le = LabelEncoder() |
| return le.fit_transform(y_train) |
| else: |
| return y_train |
|
|
| def _train_model(self, model_name, model, params): |
| start_time = time() |
| if 'train' not in self.dataset_dict.keys(): |
| raise ValueError("You first need to run the code with " |
| "config.TrainingPhase.run_preparatory_phase = True") |
| x_train = self.dataset_dict['train']['X'] |
| y_train = self._get_y_train(model_name) |
| self.logger.info(f"Training model {model.__class__.__name__}...") |
| grid_search = GridSearchCV(model, params, cv=self.cv, scoring=self.scorer) |
| grid_search.fit(x_train, y_train) |
| best_model = grid_search.best_estimator_ |
| total_time = round(time() - start_time, 2) |
| self.logger.info(f"Model {model_name} was trained successfully in {total_time} seconds") |
| return best_model, total_time |
|
|
| def _insert_results_to_dict(self, result_dict, model_name, y_test_preds, training_time, |
| inference_time, y_prediction_file=None): |
| data_type = 'train' if self.evaluation_mode == "blocking" else 'test' |
| y_test = self.dataset_dict[data_type]['Y'] |
| result_dict[model_name]['precision'] = precision_score(y_test, y_test_preds, average='binary') |
| result_dict[model_name]['recall'] = recall_score(y_test, y_test_preds, average='binary') |
| result_dict[model_name]['f1'] = f1_score(y_test, y_test_preds, average='binary') |
| result_dict[model_name]['training_time'] = training_time |
| result_dict[model_name]['inference_time'] = inference_time |
| return result_dict |
|
|
| def _insert_results_to_dict_contaminated(self, result_dict, model_name, y_test_preds_all, |
| y_test_preds_contaminated, contaminated_indices): |
| y_test_all = self.dataset_dict['test']['Y'] |
| y_test_contaminated = y_test_all[contaminated_indices] |
| result_dict[model_name]['precision'] = precision_score(y_test_all, y_test_preds_all, average='binary') |
| result_dict[model_name]['recall'] = recall_score(y_test_all, y_test_preds_all, average='binary') |
| result_dict[model_name]['f1'] = f1_score(y_test_all, y_test_preds_all, average='binary') |
| result_dict[model_name]['precision_contaminated'] = precision_score(y_test_contaminated, |
| y_test_preds_contaminated, |
| average='binary') |
| result_dict[model_name]['recall_contaminated'] = recall_score(y_test_contaminated, |
| y_test_preds_contaminated, |
| average='binary') |
| result_dict[model_name]['f1_contaminated'] = f1_score(y_test_contaminated, y_test_preds_contaminated, |
| average='binary') |
| return result_dict |
|
|
| def _insert_results_to_dict_dirty(self, result_dict, model_name, y_test_preds, y_test_preds_dirty): |
| y_test = self.dataset_dict['test']['Y'] |
| y_test_dirty = self.dataset_dict['test_dirty']['Y'] |
| result_dict[model_name]['precision'] = precision_score(y_test, y_test_preds, average='binary') |
| result_dict[model_name]['recall'] = recall_score(y_test, y_test_preds, average='binary') |
| result_dict[model_name]['f1'] = f1_score(y_test, y_test_preds, average='binary') |
| result_dict[model_name]['precision_dirty'] = precision_score(y_test_dirty, y_test_preds_dirty, |
| average='binary') |
| result_dict[model_name]['recall_dirty'] = recall_score(y_test_dirty, y_test_preds_dirty, |
| average='binary') |
| result_dict[model_name]['f1_dirty'] = f1_score(y_test_dirty, y_test_preds_dirty, average='binary') |
| return result_dict |
|
|
| def _print_results(self): |
| for model_name, model_results in self.result_dict.items(): |
| eval_mode_message = f" {self.evaluation_mode} mode (results over train set)" if ( |
| self.evaluation_mode == "blocking") else "" |
| self.logger.info(f"{eval_mode_message}") |
| self.logger.info(f"Results for model {model_name}:") |
| self.logger.info(f"Precision: {round(model_results['precision'], 3)}") |
| self.logger.info(f"Recall: {round(model_results['recall'], 3)}") |
| self.logger.info(f"F1 score: {round(model_results['f1'], 3)}") |
| if self.contaminated_indices_dict is not None: |
| self.print_results_contaminated(model_results) |
| self.logger.info(3*'--------------------------') |
| self.logger.info('') |
| return |
|
|
| def print_results_contaminated(self, model_results): |
| self.logger.info(f"Contamination level: {self.contamination_level}") |
| self.logger.info(f"Precision (contaminated): {round(model_results['precision_contaminated'], 3)}") |
| self.logger.info(f"Recall (contaminated): {round(model_results['recall_contaminated'], 3)}") |
| self.logger.info(f"F1 score (contaminated): {round(model_results['f1_contaminated'], 3)}") |
| return |
|
|
| def feature_importance_extraction(self): |
| """ |
| Extracts the feature importance scores for the best model (used in the preparatory phase for blocking) |
| """ |
| feature_importance_dict = dict() |
| self.logger.info("Feature importance scores:\n") |
| for model_name in self.best_model_dict.keys(): |
| best_model = self.best_model_dict[model_name]['model'] |
| feature_name_list = self.best_model_dict[model_name]['feature_name_list'] |
| sorted_importance_scores = sorted(zip(feature_name_list, best_model.feature_importances_), |
| key=lambda x: x[1], reverse=True) |
| self._print_feature_importance_scores(sorted_importance_scores) |
| feature_importance_dict[model_name] = sorted_importance_scores |
| self._save_feature_importance_scores(feature_importance_dict) |
| self.logger.info(3 * '*******************************************') |
| self.logger.info(3 * '*******************************************') |
| return feature_importance_dict |
|
|
| def _save_feature_importance_scores(self, sorted_importance_scores): |
| general_file_name = ''.join((self.file_name, '_feature_importance_dict')) |
| feature_importance_file_name = f'{self.models_path}_{general_file_name}_seed={self.seed}.joblib' |
| joblib.dump(sorted_importance_scores, feature_importance_file_name) |
| self.logger.info(f"Feature importance scores were saved successfully") |
| self.logger.info('') |
| return |
|
|
| def _print_feature_importance_scores(self, sorted_importance_scores): |
| for feature, score in sorted_importance_scores: |
| self.logger.info(f"{feature}: {round(score, 3)}") |
| self.logger.info(3 * '==============================') |
| self.logger.info('') |
| return |
|
|
| def get_property_ratios(self): |
| property_ratios = dict() |
| for prop, curr_prop_dict in self.property_dict.items(): |
| ratio_hist = [curr_prop_dict['index'][ind] / curr_prop_dict['cands'][ind] for ind in |
| curr_prop_dict['index'].keys() if ind in curr_prop_dict['cands'].keys()] |
| property_ratios[prop] = {'mean': round(np.mean(ratio_hist), 3), |
| 'std': round(np.std(ratio_hist), 3)} |
| property_ratios = dict(sorted(property_ratios.items(), key=lambda item: item[1]['std'])) |
| self._save_property_ratios(property_ratios) |
| return property_ratios |
|
|
| def _save_property_ratios(self, property_ratios): |
| general_file_name = ''.join((self.file_name, '_property_ratios')) |
| property_ratios_file_name = f'{self.models_path}{general_file_name}_seed={self.seed}.joblib' |
| joblib.dump(property_ratios, property_ratios_file_name) |
| self.logger.info(f"Matching pairs property ratios were saved successfully") |
| self.logger.info('') |
| return |
|
|
