File size: 18,587 Bytes
d934656 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 | 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
|