uniovi-simur-wearablepermed-ml 1.1.0__py3-none-any.whl

wearablepermed_ml/models/model_generator.py

@@ -0,0 +1,63 @@
+from models import *
+from basic_functions.address import *
+import pandas as pd
+from data import DataReader
+import ast
+
+# Model factory pattern
+def modelGenerator(modelID: str, data, params:dict={}, verbose=False, debug=False):
+    '''
+    ARGUMENTS
+        modelID (str)                       ID that indicates the model type
+        data    (featExtraction object)     Data object needed to train
+        params  (dict)                      the params that define the model 
+    '''
+    # data = data
+    # modelID = modelID
+    # params  = params
+
+    if verbose:
+        print("Building model")
+
+    if not params and not debug:
+        if verbose:
+            print("loading best hyperparameters")
+        params_path  = get_param_path(modelID)
+        df_params    = pd.read_csv(params_path,index_col=0)
+        params       = ast.literal_eval(df_params.loc[data.dataID,'params'])[0]
+
+    
+    # Aquí se llamarían a todos los modelos según su ID
+    # 1. CNN ESANN
+    if modelID == "ESANN":
+        model = SiMuRModel_ESANN(data, params)
+    
+    # 2. CNN CAPTURE-24
+    elif modelID == "CAPTURE24":
+        model = SiMuRModel_CAPTURE24(data, params)
+    
+    # 3. Random Forest
+    elif modelID == "RandomForest":
+        model = SiMuRModel_RandomForest(data, params)
+
+    # 4. XGBoost
+    elif modelID == "XGBoost":
+        model = SiMuRModel_XGBoost(data, params)
+
+    else:
+        model = None
+        raise Exception("Model not implemented")
+    return model
+
+# Unit testing
+if __name__ == "__main__": 
+    
+    # Test time models
+    # modelID = "SiMuRModel_ESANN_data_tot"
+    modelID = "SiMuRModel_CAPTURE24_data_tot"
+    # params = {"N_capas":3}
+    params = {"N_capas":6}
+    data = DataReader(p_train=0.7, dataset='data_tot')
+    
+    model = modelGenerator(modelID=modelID, data=data, params=params, debug=False)
+    model.train()

wearablepermed_ml/run_trainer_and_tester_30_times.py

@@ -0,0 +1,130 @@
+import os                                                    # Para manejar rutas de archivos
+import subprocess                                            # Para ejecutar scripts Python como procesos separados
+import re                                                    # Para expresiones regulares, usado para extraer accuracy
+import numpy as np                                           # Para operaciones numéricas y guardar resultados
+
+N_RUNS = 30                                                  # Número de ejecuciones de train+test
+
+# Ruta Windows
+# case_id_folder = "D:\\DATA_PMP_File_Server\\output"          # Carpeta base de los datos
+# Ruta Linux
+# case_id_folder = "/mnt/nvme1n2/git/uniovi-simur-wearablepermed-data/output"
+case_id_folder = "/mnt/simur-fileserver/data/wearablepermed/output"
+
+case_id = "cases_dataset_PI_M/case_PI_M_BRF_superclasses"                                          # Identificador del caso
+
+# Argumentos para el script de entrenamiento
+train_args = [
+    # Ruta Windows
+    # "src\\wearablepermed_ml\\trainer.py",                  # Script de entrenamiento
+    # Ruta Linux                                             
+    "src/wearablepermed_ml/trainer.py",                      # Script de entrenamiento
+    "--case-id", case_id,                                    # ID del caso
+    "--case-id-folder", case_id_folder,                      # Carpeta de datos
+    "--ml-models", "RandomForest",                                  # Modelo ML a usar
+    "--training-percent", "70",                              # Porcentaje de datos para entrenamiento
+    # "--validation-percent", "20",                            # Porcentaje de datos para validación
+    "--create-superclasses"                                  # Flag opcional para crear superclases
+]
+
+# Argumentos para el script de test
+test_args = [
+    # Ruta Windows
+    # "src\\wearablepermed_ml\\tester.py",                     # Script de test
+    # Ruta Linux 
+    "src/wearablepermed_ml/tester.py",                       # Script de test
+    "--case-id", case_id,                                    # ID del caso
+    "--case-id-folder", case_id_folder,                      # Carpeta de datos
+    "--model-id", "RandomForest",                                   # Modelo ML usado para test
+    "--training-percent", "70",                              # Porcentaje usado en entrenamiento
+    # "--validation-percent", "20",                            # Porcentaje de datos para validaciones
+    "--create-superclasses"                                  # Flag opcional
+]
+
+# Ruta del ejecutable de Python del entorno virtual (Windows)
+# python_exe = os.path.join(".venv", "Scripts", "python.exe")
+# En Linux, será:
+python_exe = os.path.join(".venv", "bin", "python")
+
+accuracies = []                                                     # Lista donde se guardarán las accuracy de cada ejecución
+# recalls = []                                                        # Lista para los recall capturados
+f1_scores = []                                                      # Lista para los f1-score capturados
+
+for i in range(1, N_RUNS + 1):                                      # Bucle principal: repite N_RUNS veces
+    print(f"\n=== EJECUCIÓN {i} ===")                               # Indica el número de ejecución actual
+
+    # --- TRAIN ---
+    print(f"\n--- TRAIN (ejecución {i}) ---")                       # Mensaje de inicio de entrenamiento
+    subprocess.run([python_exe] + train_args, check=True)           # Ejecuta trainer.py con los argumentos definidos
+
+    # --- TEST ---
+    test_args_with_i = test_args + ["--run-index", str(i)]          # Agrega el índice de ejecución al comando de test
+    print(f"\n--- TEST (ejecución {i}) ---")                        # Mensaje de inicio de test
+
+    result = subprocess.run(                                        # Lanza tester.py y captura su salida
+        [python_exe] + test_args_with_i,                            # Comando completo (python + tester.py + args)
+        check=True,                                                 # Si hay error, lanza excepción
+        capture_output=True,                                        # Captura stdout y stderr
+        text=True                                                   # Interpreta la salida como texto (no bytes)
+    )
+
+    print(result.stdout)                                            # Muestra la salida completa del tester.py
+
+    # --- Extraer métricas ---
+    acc_match = re.search(r"Global accuracy score (test)\s*=\s*([0-9.]+)", result.stdout)  # Busca el accuracy en la salida
+    # recall_match = re.search(r"Global recall score\s*=\s*([0-9.]+)", result.stdout)  # Busca el recall
+    f1_match = re.search(r"Global F1 (test)[-\s]?score\s*=\s*([0-9.]+)", result.stdout)     # Busca el F1-score (permite F1-score o F1 score)
+
+    if acc_match:                                                   # Si se encontró el accuracy
+        acc = float(acc_match.group(1))                             # Convierte el valor capturado a float
+        accuracies.append(acc)                                      # Lo guarda en la lista
+        print(f"Accuracy capturado en la ejecución {i}: {acc} [%]") # Muestra el valor capturado
+    else:
+        print("No se encontró 'Global accuracy score' en la salida de tester.py")  # Aviso si no se encontró
+
+    # if recall_match:                                                # Si se encontró el recall
+    #     rec = float(recall_match.group(1))                          # Convierte a float
+    #     recalls.append(rec)                                         # Guarda el valor
+    #     print(f"Recall capturado en la ejecución {i}: {rec} [%]")   # Muestra el valor capturado
+    # else:
+    #     print("No se encontró 'Global recall score' en la salida de tester.py")     # Aviso si falta el dato
+
+    if f1_match:                                                    # Si se encontró el F1-score
+        f1 = float(f1_match.group(1))                               # Convierte a float
+        f1_scores.append(f1)                                        # Guarda el valor
+        print(f"F1-score capturado en la ejecución {i}: {f1} [%]")  # Muestra el valor capturado
+    else:
+        print("No se encontró 'Global F1-score' en la salida de tester.py")         # Aviso si no se encontró
+
+
+# --- RESUMEN FINAL ---
+print("\n=== RESUMEN FINAL ===")                                    # Título del resumen
+print("Accuracies:", accuracies)                                    # Muestra lista completa de accuracies
+# print("Recalls:", recalls)                                          # Muestra lista de recalls
+print("F1-scores:", f1_scores)                                      # Muestra lista de F1-scores
+
+if accuracies:                                                      # Si hay valores de accuracy
+    print(f"Accuracy mean: {np.mean(accuracies):.4f} | std: {np.std(accuracies):.4f}")  # Calcula y muestra media y std
+# if recalls:                                                         # Si hay valores de recall
+#     print(f"Recall mean: {np.mean(recalls):.4f} | std: {np.std(recalls):.4f}")          # Calcula y muestra media y std
+if f1_scores:                                                       # Si hay valores de f1
+    print(f"F1 mean: {np.mean(f1_scores):.4f} | std: {np.std(f1_scores):.4f}")          # Calcula y muestra media y std
+
+
+# --- GUARDAR EN .npz ---
+accuracies_test_path = os.path.join(case_id_folder, case_id, "metrics_test.npz")    # Ruta final donde guardar el archivo
+
+np.savez(                                                     # Guarda los datos en un archivo comprimido .npz
+    accuracies_test_path,                                     # Nombre/ruta del archivo de salida
+    accuracies=np.array(accuracies),                          # Lista de accuracies
+    # recalls=np.array(recalls),                                # Lista de recalls
+    f1_scores=np.array(f1_scores),                            # Lista de F1-scores
+    acc_mean=np.mean(accuracies),                             # Media de accuracy
+    acc_std=np.std(accuracies),                               # Desviación estándar de accuracy
+    # rec_mean=np.mean(recalls),                                # Media de recall
+    # rec_std=np.std(recalls),                                  # Desviación estándar de recall
+    f1_mean=np.mean(f1_scores),                               # Media de F1-score
+    f1_std=np.std(f1_scores)                                  # Desviación estándar de F1-score
+)
+
+print(f"\nResultados guardados en {accuracies_test_path}")         # Mensaje final de confirmación

wearablepermed_ml/tester.py

@@ -0,0 +1,156 @@
+from enum import Enum
+import os
+import sys
+import argparse 
+import logging
+
+from testing import testing
+
+__author__ = "Miguel Salinas <uo34525@uniovi.es>, Alejandro <uo265351@uniovi.es>"
+__copyright__ = "Uniovi"
+__license__ = "MIT"
+
+_logger = logging.getLogger(__name__)
+
+class ML_Model(Enum):
+    ESANN = 'ESANN'
+    CAPTURE24 = 'CAPTURE24'
+    RANDOM_FOREST = 'RandomForest'
+    XGBOOST = 'XGBoost'
+   
+def parse_args(args):
+    """Parse command line parameters
+
+    Args:
+      args (List[str]): command line parameters as list of strings
+          (for example  ``["--help"]``).
+
+    Returns:
+      :obj:`argparse.Namespace`: command line parameters namespace
+    """
+    parser = argparse.ArgumentParser(description="Machine Learning Model Trainer")
+    parser.add_argument(
+        "-case-id",
+        "--case-id",
+        dest="case_id",
+        required=True,
+        help="Case unique identifier."
+    ) 
+    parser.add_argument(
+        "-case-id-folder",
+        "--case-id-folder",
+        dest="case_id_folder",
+        required=True,
+        help="Choose the case id root folder."
+    )        
+    parser.add_argument(
+        "-model-id",
+        "--model-id",
+        dest="model_id",
+        required=True,
+        help="Choose the model id."
+    )
+    parser.add_argument(
+        "-create-superclasses",
+        "--create-superclasses",
+        dest="create_superclasses",
+        action='store_true',
+        help="Create activity superclasses (true/false)."
+    )  
+    parser.add_argument(
+        "-create-superclasses-CPA-METs",
+        "--create-superclasses-CPA-METs",
+        dest="create_superclasses_CPA_METs",
+        action='store_true',
+        help="Create activity superclasses (true/false) with the CPA/METs method."
+    )  
+    parser.add_argument(
+        '-training-percent',
+        '--training-percent',
+        dest='training_percent',
+        type=int,
+        default=70,
+        required=True,
+        help="Training percent"
+    )    
+    parser.add_argument(
+        '-validation-percent',
+        '--validation-percent',
+        dest='validation_percent',
+        type=int,
+        default=0,
+        help="Validation percent"
+    )
+    parser.add_argument(
+        '-run-index',
+        '--run-index',
+        dest='run_index',
+        type=str,
+        default=1,
+        help="Run index of each iteration of the test step."
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        dest="loglevel",
+        help="set loglevel to DEBUG.",
+        action="store_const",
+        const=logging.DEBUG,
+    )
+    parser.add_argument(
+        "-vv",
+        "--very-verbose",
+        dest="loglevel",
+        help="set loglevel to INFO.",
+        action="store_const",
+        const=logging.INFO,
+    )    
+    return parser.parse_args(args)
+
+def setup_logging(loglevel):
+    """Setup basic logging
+
+    Args:
+      loglevel (int): minimum loglevel for emitting messages
+    """
+    logformat = "[%(asctime)s] %(levelname)s:%(name)s:%(message)s"
+    logging.basicConfig(
+        level=loglevel, stream=sys.stdout, format=logformat, datefmt="%Y-%m-%d %H:%M:%S"
+    )
+
+def main(args):
+    """Wrapper allowing :func:`fib` to be called with string arguments in a CLI fashion
+
+    Instead of returning the value from :func:`fib`, it prints the result to the
+    ``stdout`` in a nicely formatted message.
+
+    Args:
+      args (List[str]): command line parameters as list of strings
+          (for example  ``["--verbose", "42"]``).
+    """
+    args = parse_args(args)
+    setup_logging(args.loglevel)
+
+    # create the output case id folder if not exist
+    case_id_folder = os.path.join(args.case_id_folder, args.case_id)
+    os.makedirs(case_id_folder, exist_ok=True)
+
+    _logger.info("Tester starts here")
+    testing.tester(case_id_folder,
+                   args.model_id,
+                   args.create_superclasses,
+                   args.create_superclasses_CPA_METs,
+                   args.training_percent,
+                   args.validation_percent,
+                   args.run_index)
+    _logger.info("Script ends here")
+
+def run():
+    """Calls :func:`main` passing the CLI arguments extracted from :obj:`sys.argv`
+
+    This function can be used as entry point to create console scripts with setuptools.
+    """
+    main(sys.argv[1:])
+
+if __name__ == "__main__":
+    run()   

wearablepermed_ml/testing/testing.py

@@ -0,0 +1,203 @@
+from enum import Enum
+import json
+from data import DataReader
+from models.model_generator import modelGenerator
+from basic_functions.address import *
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.metrics import accuracy_score, f1_score, recall_score, classification_report, confusion_matrix
+import joblib
+
+class ML_Model(Enum):
+    ESANN = 'ESANN'
+    CAPTURE24 = 'CAPTURE24'
+    RANDOM_FOREST = 'RandomForest'
+    XGBOOST = 'XGBoost'
+    
+def tester(case_id_folder, model_id, create_superclasses, create_superclasses_CPA_METs, training_percent, validation_percent, run_index):
+    # Cargar el LabelEncoder
+    # Ver las clases asociadas a cada número
+    test_label_encoder_path = os.path.join(case_id_folder, "label_encoder.pkl")
+    label_encoder = joblib.load(test_label_encoder_path)
+
+    print(label_encoder.classes_)
+
+    # class_names_total = ['CAMINAR CON LA COMPRA', 'CAMINAR CON MÓVIL O LIBRO', 'CAMINAR USUAL SPEED',
+    # 'CAMINAR ZIGZAG', 'DE PIE BARRIENDO', 'DE PIE DOBLANDO TOALLAS',
+    # 'DE PIE MOVIENDO LIBROS', 'DE PIE USANDO PC', 'FASE REPOSO CON K5',
+    # 'INCREMENTAL CICLOERGOMETRO', 'SENTADO LEYENDO', 'SENTADO USANDO PC',
+    # 'SENTADO VIENDO LA TV', 'SIT TO STAND 30 s', 'SUBIR Y BAJAR ESCALERAS',
+    # 'TAPIZ RODANTE', 'TROTAR', 'YOGA']
+    
+    # class_names_total = ['CAMINAR CON LA COMPRA', 'CAMINAR CON MÓVIL O LIBRO', 'CAMINAR USUAL SPEED',
+    # 'CAMINAR ZIGZAG', 'DE PIE BARRIENDO', 'DE PIE DOBLANDO TOALLAS',
+    # 'DE PIE MOVIENDO LIBROS', 'DE PIE USANDO PC', 'FASE REPOSO CON K5',
+    # 'INCREMENTAL CICLOERGOMETRO', 'SENTADO LEYENDO', 'SENTADO USANDO PC',
+    # 'SENTADO VIENDO LA TV', 'SUBIR Y BAJAR ESCALERAS',
+    # 'TAPIZ RODANTE', 'TROTAR', 'YOGA']
+    
+    class_names_total = label_encoder.classes_
+
+    print(len(class_names_total))
+
+    # Obtener el mapeo de cada etiqueta a su número asignado
+    mapeo = dict(zip(label_encoder.classes_, range(len(label_encoder.classes_))))
+    print("Mapeo de etiquetas:", mapeo)
+
+    # Lectura de hiperparámetros óptimos de cada modelo, previamente buscados
+    # ------------------------------------------------------------------------------------
+    if (model_id == ML_Model.ESANN.value):
+        test_dataset_path = os.path.join(case_id_folder, "data_all.npz")
+        # Ruta al archivo de hiperparámetros guardados
+        hp_json_path = os.path.join(case_id_folder, "mejores_hiperparametros_ESANN.json")
+        # Cargar hiperparámetros desde el archivo JSON
+        with open(hp_json_path, "r") as f:
+            best_hp_values = json.load(f)  # Diccionario: {param: valor}
+    
+    elif (model_id == ML_Model.CAPTURE24.value):
+        test_dataset_path = os.path.join(case_id_folder, "data_all.npz")
+        # Ruta al archivo de hiperparámetros guardados
+        hp_json_path = os.path.join(case_id_folder, "mejores_hiperparametros_CAPTURE24.json")
+        # Cargar hiperparámetros desde el archivo JSON
+        with open(hp_json_path, "r") as f:
+            best_hp_values = json.load(f)  # Diccionario: {param: valor}
+    
+    elif (model_id == ML_Model.RANDOM_FOREST.value):
+        test_dataset_path = os.path.join(case_id_folder, "data_feature_all.npz")
+        # Ruta al archivo de hiperparámetros guardados
+        hp_json_path = os.path.join(case_id_folder, "mejores_hiperparametros_BRF.json")
+        # Cargar hiperparámetros desde el archivo JSON
+        with open(hp_json_path, "r") as f:
+            best_hp_values = json.load(f)  # Diccionario: {param: valor}
+
+    elif (model_id == ML_Model.XGBOOST.value):
+        test_dataset_path = os.path.join(case_id_folder, "data_feature_all.npz")
+        # Ruta al archivo de hiperparámetros guardados
+        hp_json_path = os.path.join(case_id_folder, "mejores_hiperparametros_XGB.json")
+        # Cargar hiperparámetros desde el archivo JSON
+        with open(hp_json_path, "r") as f:
+            best_hp_values = json.load(f)  # Diccionario: {param: valor}
+        
+    # Testeamos el rendimiento del modelo de clasificación con los DATOS TOTALES
+    data = DataReader(modelID=model_id, 
+                      create_superclasses=create_superclasses,
+                      create_superclasses_CPA_METs = create_superclasses_CPA_METs, 
+                      p_train = training_percent, 
+                      p_validation=validation_percent, 
+                      file_path=test_dataset_path, 
+                      label_encoder_path=test_label_encoder_path)
+
+    # Construir modelo usando modelGenerator y los hiperparámetros
+    model = modelGenerator(
+        modelID=model_id,
+        data=data,
+        params=best_hp_values,  # Pasamos directamente el diccionario de hiperparámetros óptimos
+        debug=False
+    )
+
+    model.load(model_id, case_id_folder)
+
+    # print train/test sizes
+    print(model.X_test.shape)
+    print(model.X_train.shape)
+
+    # testing the model
+    y_predicted_train = model.predict(model.X_train)
+    y_predicted_validation = model.predict(model.X_validation)
+    y_predicted_test = model.predict(model.X_test)
+
+    # get the class with the highest probability
+    if (model_id == ML_Model.ESANN.value or model_id == ML_Model.CAPTURE24.value):
+        y_final_prediction_train = np.argmax(y_predicted_train, axis=1)
+        y_final_prediction_validation = np.argmax(y_predicted_validation, axis=1)
+        y_final_prediction_test = np.argmax(y_predicted_test, axis=1)  # Trabajamos con clasificación multicategoría, no necesario para los bosques aleatorios
+
+    else:
+        y_final_prediction_train = y_predicted_train
+        y_final_prediction_validation = y_predicted_validation
+        y_final_prediction_test = y_predicted_test   # esta línea solo es necesaria para los bosques aleatorios y XGBoost
+
+
+    print(model.y_test)
+    print(model.y_test.shape)
+
+    print(y_predicted_test)
+    print(y_predicted_test.shape)
+
+    # Matriz de confusión
+    # Obtener todas las clases posibles desde 0 hasta N-1
+    num_classes = len(class_names_total)  # Asegurar que contiene todas las clases esperadas
+    all_classes = np.arange(num_classes)  # Crear array con todas las clases (0, 1, 2, ..., N-1)
+
+    # Crear la matriz de confusión asegurando que todas las clases están representadas
+    cm = confusion_matrix(model.y_test, y_final_prediction_test, labels=all_classes)
+
+    # Graficar la matriz de confusión
+    confusion_matrix_test_path = os.path.join(case_id_folder, "confusion_matrix_test_"+run_index+".png")
+
+    plt.figure(figsize=(10,7))
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=class_names_total, yticklabels=class_names_total)
+    plt.xlabel('Predicted label')
+    plt.ylabel('True label')
+    plt.title('Confusion Matrix Test')
+    plt.savefig(confusion_matrix_test_path, bbox_inches='tight')
+
+    # -------------------------------------------------
+    # MÉTRICAS DE TEST GLOBALES
+    print("-------------------------------------------------\n")
+
+    # Accuracy
+    acc_score_train = accuracy_score(model.y_train, y_final_prediction_train)
+    print("Global accuracy score (train) = "+str(round(acc_score_train*100,2))+" [%]")
+    
+    acc_score_validation = accuracy_score(model.y_validation, y_final_prediction_validation)
+    print("Global accuracy score (validation) = "+str(round(acc_score_validation*100,2))+" [%]")
+    
+    acc_score_test = accuracy_score(model.y_test, y_final_prediction_test)
+    print("Global accuracy score (test) = "+str(round(acc_score_test*100,2))+" [%]")
+
+    # F1 Score
+    F1_score_train = f1_score(model.y_train, y_final_prediction_train, average='macro')    # revisar las opciones de average
+    print("Global F1 score (train) = "+str(round(F1_score_train*100,2))+" [%]")
+    
+    F1_score_validation = f1_score(model.y_validation, y_final_prediction_validation, average='macro')    # revisar las opciones de average
+    print("Global F1 score (validation) = "+str(round(F1_score_validation*100,2))+" [%]")
+    
+    F1_score_test = f1_score(model.y_test, y_final_prediction_test, average='macro')    # revisar las opciones de average
+    print("Global F1 score (test) = "+str(round(F1_score_test*100,2))+" [%]")
+
+    # Recall global
+    # recall_score_global = recall_score(model.y_test, y_final_predicton, average='macro')
+    # print("Global recall score = "+str(round(recall_score_global*100,2))+" [%]")
+
+    # Save to a file
+    clasification_global_report_path = os.path.join(case_id_folder, "clasification_global_report_"+run_index+".txt")
+    with open(clasification_global_report_path, "w") as f:
+        f.write(f"Global F1 Score (train): {F1_score_train:.4f}\n")
+        f.write(f"Global accuracy score (train): {acc_score_train:.4f}\n")
+        f.write(f"Global F1 Score (validation): {F1_score_validation:.4f}\n")
+        f.write(f"Global accuracy score (validation): {acc_score_validation:.4f}\n")
+        f.write(f"Global F1 Score (test): {F1_score_test:.4f}\n")
+        f.write(f"Global accuracy score (test): {acc_score_test:.4f}\n")
+        # f.write(f"Global recall score: {recall_score_global:.4f}\n")
+
+    # -------------------------------------------------
+    # Obtener todas las clases posibles desde 0 hasta N-1
+    num_classes = len(class_names_total)  # Número total de clases
+    all_classes = np.arange(num_classes)  # Crea un array con todas las clases (0, 1, 2, ..., N-1)
+
+    # Tabla de métricas para cada clase
+    classification_per_class_report = classification_report(
+        model.y_test,
+        y_final_prediction_test,
+        labels=all_classes,
+        target_names=class_names_total,
+        zero_division=0
+    )
+    print(classification_per_class_report)        
+
+    # Save per-class report to a file
+    clasification_per_class_report_path = os.path.join(case_id_folder, "clasification_per_class_report_"+run_index+".txt")
+    with open(clasification_per_class_report_path, "w") as f:        
+        f.write(classification_per_class_report)