Configure hierarchical acousticbrainz.models logger

Author: amCap1712

acousticbrainz/models/__init__.py

@@ -1 +1,9 @@
-# -*- coding: utf-8 -*-
+import logging
+
+ACOUSTICBRAINZ_SKLEARN_LOGGER = "acousticbrainz.models"
+_logger = logging.getLogger(ACOUSTICBRAINZ_SKLEARN_LOGGER)
+_handler = logging.StreamHandler()
+_formatter = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
+_handler.setFormatter(_formatter)
+_logger.addHandler(_handler)
+_logger.setLevel(logging.INFO)

acousticbrainz/models/sklearn/classification/classification_task.py

@@ -1,17 +1,21 @@
+import logging
 import os
 import json
 from ..classification.classifier_grid import TrainGridClassifier
 from ..classification.evaluation import evaluation
 
 
+logger = logging.getLogger(__name__)
+
+
 class ClassificationTask:
     """
     This class is the core of the model classification. It loads the relevant classifier to
     be used for training, the features, the labels, and the tracks. It uses a corresponding
     to the configuration file declared class to train the model and then it uses that model
     for evaluation.
     """
-    def __init__(self, config, classifier, train_class, training_processes, X, y, exports_path, tracks, logger):
+    def __init__(self, config, classifier, train_class, training_processes, X, y, exports_path, tracks):
         """
         Args:
             config: The configuration data that contain the settings from the configuration
@@ -27,7 +31,6 @@ def __init__(self, config, classifier, train_class, training_processes, X, y, ex
             y: The labels (NumPy array) of the target class
             exports_path: Path to where the classification project's results will be stored to.
             tracks: The tracks (numpy.ndarray) that are exported from the Groundtruth file.
-            log_level: The logging level (0-4).
         """
         self.config = config
         self.classifier = classifier
@@ -38,13 +41,12 @@ def __init__(self, config, classifier, train_class, training_processes, X, y, ex
         self.training_processes = training_processes
         self.exports_path = exports_path
         self.tracks = tracks
-        self.logger = logger
 
 
     def run(self):
         # grid search train
         if self.config["train_kind"] == "grid":
-            self.logger.info("Train Classifier: Classifier with GridSearchCV")
+            logger.info("Train Classifier: Classifier with GridSearchCV")
             grid_svm_train = TrainGridClassifier(config=self.config,
                                                  classifier=self.classifier,
                                                  class_name=self.train_class,
@@ -57,15 +59,15 @@ def run(self):
             grid_svm_train.train_grid_search_clf()
             grid_svm_train.export_best_classifier()
         else:
-            self.logger.error("Use a valid classifier in the configuration file.")
-        self.logger.info("Training the classifier is completed successfully.")
+            logger.error("Use a valid classifier in the configuration file.")
+        logger.info("Training the classifier is completed successfully.")
 
         # load best model to check its parameters
-        self.logger.debug("Loading the Best Model..")
+        logger.debug("Loading the Best Model..")
         best_model_name = "best_model_{}.json".format(self.train_class)
         with open(os.path.join(self.exports_path, best_model_name)) as best_model_file:
             best_model = json.load(best_model_file)
-        self.logger.debug("BEST MODEL: {}".format(best_model))
+        logger.debug("BEST MODEL: {}".format(best_model))
 
         # evaluation
         evaluation(config=self.config,
@@ -75,5 +77,4 @@ def run(self):
                    tracks=self.tracks,
                    process=best_model["preprocessing"],
                    exports_path=self.exports_path,
-                   logger=self.logger
                    )

acousticbrainz/models/sklearn/classification/classification_task_manager.py

@@ -1,3 +1,4 @@
+import logging
 import os
 from time import time
 from termcolor import colored
@@ -7,6 +8,8 @@
 from ..classification.classification_task import ClassificationTask
 
 
+logger = logging.getLogger(__name__)
+
 validClassifiers = ["svm", "NN"]
 validEvaluations = ["nfoldcrossvalidation"]
 
@@ -20,7 +23,7 @@ class ClassificationTaskManager:
     with their corresponding preprocessing steps and parameters declaration for the
     classifier, and executes the classification task for each step.
     """
-    def __init__(self, config, train_class, X, y, tracks, exports_path, logger):
+    def __init__(self, config, train_class, X, y, tracks, exports_path):
         """
         Args:
             config: The configuration file name.
@@ -34,7 +37,6 @@ def __init__(self, config, train_class, X, y, tracks, exports_path, logger):
         self.y = y
         self.tracks = tracks
         self.exports_path = exports_path
-        self.logger = logger
 
         self.results_path = ""
         self.logs_path = ""
@@ -72,33 +74,33 @@ def config_file_analysis(self):
         """
         Check the keys of the configuration template file if they are set up correctly.
         """
-        self.logger.info("---- CHECK FOR INAPPROPRIATE CONFIG FILE FORMAT ----")
+        logger.info("---- CHECK FOR INAPPROPRIATE CONFIG FILE FORMAT ----")
         if "processing" not in self.config:
-            self.logger.error("No preprocessing defined in config.")
+            logger.error("No preprocessing defined in config.")
 
         if "evaluations" not in self.config:
-            self.logger.error("No evaluations defined in config.")
-            self.logger.error("Setting default evaluation to 10-fold cross-validation")
+            logger.error("No evaluations defined in config.")
+            logger.error("Setting default evaluation to 10-fold cross-validation")
             self.config["evaluations"] = {"nfoldcrossvalidation": [{"nfold": [10]}]}
 
         for classifier in self.config['classifiers'].keys():
             if classifier not in validClassifiers:
-                self.logger.error("Not a valid classifier: {}".format(classifier))
+                logger.error("Not a valid classifier: {}".format(classifier))
                 raise ValueError("The classifier name must be valid.")
 
         for evaluation in self.config['evaluations'].keys():
             if evaluation not in validEvaluations:
-                self.logger.error("Not a valid evaluation: {}".format(evaluation))
+                logger.error("Not a valid evaluation: {}".format(evaluation))
                 raise ValueError("The evaluation must be valid.")
-        self.logger.info("No errors in config file format found.")
+        logger.info("No errors in config file format found.")
 
     def apply_processing(self):
         """
         Evaluation steps extraction and classification task execution for each step.
         """
         start_time = time()
         training_processes = TrainingProcesses(self.config).training_processes()
-        self.logger.info("Classifiers detected: {}".format(self.config["classifiers"].keys()))
+        logger.info("Classifiers detected: {}".format(self.config["classifiers"].keys()))
         for classifier in self.config["classifiers"].keys():
             print("Before Classification task: ", classifier)
             task = ClassificationTask(config=self.config,
@@ -109,18 +111,17 @@ def apply_processing(self):
                                       y=self.y,
                                       exports_path=self.exports_path,
                                       tracks=self.tracks,
-                                      logger=self.logger
                                       )
             try:
                 task.run()
             except Exception as e:
-                self.logger.error('Running task failed: {}'.format(e))
+                logger.error('Running task failed: {}'.format(e))
                 print(colored('Running task failed: {}'.format(e), "red"))
         end_time = time()
 
         print()
         print(colored("Last evaluation took place at: {}".format(datetime.now()), "magenta"))
-        self.logger.info("Last evaluation took place at: {}".format(datetime.now()))
+        logger.info("Last evaluation took place at: {}".format(datetime.now()))
 
         # test duration
         time_duration = end_time - start_time

acousticbrainz/models/sklearn/classification/classifier_grid.py

@@ -1,3 +1,4 @@
+import logging
 import os
 import json
 from termcolor import colored
@@ -9,8 +10,11 @@
 from ..transformation.transform import Transform
 
 
+logger = logging.getLogger(__name__)
+
+
 class TrainGridClassifier:
-    def __init__(self, config, classifier, class_name, X, y, tr_processes, exports_path, logger):
+    def __init__(self, config, classifier, class_name, X, y, tr_processes, exports_path):
         self.config = config
         self.classifier = classifier
         self.class_name = class_name
@@ -19,7 +23,6 @@ def __init__(self, config, classifier, class_name, X, y, tr_processes, exports_p
         self.tr_processes = tr_processes
         self.exports_path = exports_path
 
-        self.logger = logger
         self.best_models_list = []
         # self.train_grid_search_clf()
 
@@ -28,7 +31,7 @@ def train_grid_search_clf(self):
         process_counter = 1
         for tr_process in self.tr_processes:
             print(colored("Train process {} - {}".format(process_counter, tr_process), "green"))
-            self.logger.info("(Grid) - Train process {} - {}".format(process_counter, tr_process))
+            logger.info("(Grid) - Train process {} - {}".format(process_counter, tr_process))
             # initiate SVM classifier object
             if self.classifier == "svm":
                 grid_clf = SVC(gamma="auto", probability=True)
@@ -42,16 +45,14 @@ def train_grid_search_clf(self):
                                           df_feats=self.X,
                                           process=tr_process["preprocess"],
                                           train_class=self.class_name,
-                                          exports_path=self.exports_path,
-                                          logger=self.logger).post_processing()
+                                          exports_path=self.exports_path).post_processing()
 
             # train the grid classifier and return the trained model
             gsvc = train_grid(tr_process=tr_process,
                               grid_clf=grid_clf,
                               features_prepared=features_prepared,
                               y=self.y,
-                              config=self.config,
-                              logger=self.logger)
+                              config=self.config)
 
             # save best results for each train process
             # paths declaration for saving the grid training results
@@ -65,8 +66,7 @@ def train_grid_search_clf(self):
                                              class_name=self.class_name,
                                              tr_process=tr_process,
                                              results_path=results_path,
-                                             best_process_model_path=best_process_model_path,
-                                             logger=self.logger)
+                                             best_process_model_path=best_process_model_path)
 
             # return a list that includes the best models exported from each processing
             self.best_models_list.append(results_dict)
@@ -81,21 +81,21 @@ def train_grid_search_clf(self):
     def export_best_classifier(self):
         # Gather the best scores from the exported grid clf models
         scores = [x["score"] for x in self.best_models_list]
-        self.logger.info("This is the max score of all the training processes: {}".format(max(scores)))
+        logger.info("This is the max score of all the training processes: {}".format(max(scores)))
         for model in self.best_models_list:
             if model["score"] == max(scores):
-                self.logger.info("Best {} model parameters:".format(self.class_name))
+                logger.info("Best {} model parameters:".format(self.class_name))
                 # log2 --> convert values to initial parameters' values
                 # model["params"]["C"] = math.log2(model["params"]["C"])
                 # model["params"]["gamma"] = math.log2(model["params"]["gamma"])
-                self.logger.info("{}".format(model))
+                logger.info("{}".format(model))
                 best_model_name = "best_model_{}.json".format(self.class_name)
                 with open(os.path.join(self.exports_path, best_model_name), "w") as best_model:
                     json.dump(model, best_model, indent=4)
-                    self.logger.info("Best {} model parameters saved successfully to disk.".format(self.class_name))
+                    logger.info("Best {} model parameters saved successfully to disk.".format(self.class_name))
 
 
-def train_grid(tr_process, grid_clf, features_prepared, y, config, logger):
+def train_grid(tr_process, grid_clf, features_prepared, y, config):
     # define the length of parameters
     parameters_grid = {'kernel': tr_process["kernel"],
                        'C': tr_process["C"],
@@ -136,7 +136,7 @@ def train_grid(tr_process, grid_clf, features_prepared, y, config, logger):
     return gsvc
 
 
-def save_grid_results(gsvc, class_name, tr_process, results_path, best_process_model_path, logger):
+def save_grid_results(gsvc, class_name, tr_process, results_path, best_process_model_path):
     results_best_dict_name = "result_{}_{}_best_{}.json" \
         .format(class_name, tr_process["preprocess"], gsvc.best_score_)