nextrec 0.1.4__py3-none-any.whl → 0.1.8__py3-none-any.whl

nextrec/basic/metrics.py

@@ -5,55 +5,33 @@ Date: create on 27/10/2025
 Author:
     Yang Zhou,zyaztec@gmail.com
 """
-
 import logging
 import numpy as np
 from sklearn.metrics import (
-    roc_auc_score,
-    log_loss,
-    mean_squared_error,
-    mean_absolute_error,
-    accuracy_score,
-    precision_score,
-    recall_score,
-    f1_score,
-    r2_score,
+    roc_auc_score, log_loss, mean_squared_error, mean_absolute_error,
+    accuracy_score, precision_score, recall_score, f1_score, r2_score,
 )
 
 
-CLASSIFICATION_METRICS = {
-    "auc",
-    "gauc",
-    "ks",
-    "logloss",
-    "accuracy",
-    "acc",
-    "precision",
-    "recall",
-    "f1",
-    "micro_f1",
-    "macro_f1",
-}
-REGRESSION_METRICS = {"mse", "mae", "rmse", "r2", "mape", "msle"}
+CLASSIFICATION_METRICS = {'auc', 'gauc', 'ks', 'logloss', 'accuracy', 'acc', 'precision', 'recall', 'f1', 'micro_f1', 'macro_f1'}
+REGRESSION_METRICS = {'mse', 'mae', 'rmse', 'r2', 'mape', 'msle'}
 TASK_DEFAULT_METRICS = {
-    "binary": ["auc", "gauc", "ks", "logloss", "accuracy", "precision", "recall", "f1"],
-    "regression": ["mse", "mae", "rmse", "r2", "mape"],
-    "multilabel": ["auc", "hamming_loss", "subset_accuracy", "micro_f1", "macro_f1"],
-    "matching": ["auc", "gauc", "precision@10", "hitrate@10", "map@10", "cosine"]
-    + [f"recall@{k}" for k in (5, 10, 20)]
-    + [f"ndcg@{k}" for k in (5, 10, 20)]
-    + [f"mrr@{k}" for k in (5, 10, 20)],
+    'binary': ['auc', 'gauc', 'ks', 'logloss', 'accuracy', 'precision', 'recall', 'f1'],
+    'regression': ['mse', 'mae', 'rmse', 'r2', 'mape'],
+    'multilabel': ['auc', 'hamming_loss', 'subset_accuracy', 'micro_f1', 'macro_f1'],
+    'matching': ['auc', 'gauc', 'precision@10', 'hitrate@10', 'map@10','cosine']+ [f'recall@{k}' for k in (5,10,20)] + [f'ndcg@{k}' for k in (5,10,20)] + [f'mrr@{k}' for k in (5,10,20)]
 }
 
 
+
 def compute_ks(y_true: np.ndarray, y_pred: np.ndarray) -> float:
     """Compute Kolmogorov-Smirnov statistic."""
     sorted_indices = np.argsort(y_pred)[::-1]
     y_true_sorted = y_true[sorted_indices]
-
+    
     n_pos = np.sum(y_true_sorted == 1)
     n_neg = np.sum(y_true_sorted == 0)
-
+    
     if n_pos > 0 and n_neg > 0:
         cum_pos_rate = np.cumsum(y_true_sorted == 1) / n_pos
         cum_neg_rate = np.cumsum(y_true_sorted == 0) / n_neg
@@ -66,9 +44,7 @@ def compute_mape(y_true: np.ndarray, y_pred: np.ndarray) -> float:
     """Compute Mean Absolute Percentage Error."""
     mask = y_true != 0
     if np.any(mask):
-        return float(
-            np.mean(np.abs((y_true[mask] - y_pred[mask]) / y_true[mask])) * 100
-        )
+        return float(np.mean(np.abs((y_true[mask] - y_pred[mask]) / y_true[mask])) * 100)
     return 0.0
 
 
@@ -79,7 +55,9 @@ def compute_msle(y_true: np.ndarray, y_pred: np.ndarray) -> float:
 
 
 def compute_gauc(
-    y_true: np.ndarray, y_pred: np.ndarray, user_ids: np.ndarray | None = None
+    y_true: np.ndarray,
+    y_pred: np.ndarray,
+    user_ids: np.ndarray | None = None
 ) -> float:
     if user_ids is None:
         # If no user_ids provided, fall back to regular AUC
@@ -87,37 +65,37 @@ def compute_gauc(
             return float(roc_auc_score(y_true, y_pred))
         except:
             return 0.0
-
+    
     # Group by user_id and calculate AUC for each user
     user_aucs = []
     user_weights = []
-
+    
     unique_users = np.unique(user_ids)
-
+    
     for user_id in unique_users:
         mask = user_ids == user_id
         user_y_true = y_true[mask]
         user_y_pred = y_pred[mask]
-
+        
         # Skip users with only one class (cannot compute AUC)
         if len(np.unique(user_y_true)) < 2:
             continue
-
+        
         try:
             user_auc = roc_auc_score(user_y_true, user_y_pred)
             user_aucs.append(user_auc)
             user_weights.append(len(user_y_true))
         except:
             continue
-
+    
     if len(user_aucs) == 0:
         return 0.0
-
+    
     # Weighted average
     user_aucs = np.array(user_aucs)
     user_weights = np.array(user_weights)
     gauc = float(np.sum(user_aucs * user_weights) / np.sum(user_weights))
-
+    
     return gauc
 
 
@@ -125,7 +103,7 @@ def _group_indices_by_user(user_ids: np.ndarray, n_samples: int) -> list[np.ndar
     """Group sample indices by user_id. If user_ids is None, treat all as one group."""
     if user_ids is None:
         return [np.arange(n_samples)]
-
+    
     user_ids = np.asarray(user_ids)
     if user_ids.shape[0] != n_samples:
         logging.warning(
@@ -135,19 +113,17 @@ def _group_indices_by_user(user_ids: np.ndarray, n_samples: int) -> list[np.ndar
             n_samples,
         )
         return [np.arange(n_samples)]
-
+    
     unique_users = np.unique(user_ids)
     groups = [np.where(user_ids == u)[0] for u in unique_users]
     return groups
 
 
-def _compute_precision_at_k(
-    y_true: np.ndarray, y_pred: np.ndarray, user_ids: np.ndarray | None, k: int
-) -> float:
+def _compute_precision_at_k(y_true: np.ndarray, y_pred: np.ndarray, user_ids: np.ndarray | None, k: int) -> float:
     y_true = (y_true > 0).astype(int)
     n = len(y_true)
     groups = _group_indices_by_user(user_ids, n)
-
+    
     precisions = []
     for idx in groups:
         if idx.size == 0:
@@ -159,18 +135,16 @@ def _compute_precision_at_k(
         topk = order[:k_user]
         hits = labels[topk].sum()
         precisions.append(hits / float(k_user))
-
+    
     return float(np.mean(precisions)) if precisions else 0.0
 
 
-def _compute_recall_at_k(
-    y_true: np.ndarray, y_pred: np.ndarray, user_ids: np.ndarray | None, k: int
-) -> float:
+def _compute_recall_at_k(y_true: np.ndarray, y_pred: np.ndarray, user_ids: np.ndarray | None, k: int) -> float:
     """Compute Recall@K."""
     y_true = (y_true > 0).astype(int)
     n = len(y_true)
     groups = _group_indices_by_user(user_ids, n)
-
+    
     recalls = []
     for idx in groups:
         if idx.size == 0:
@@ -185,18 +159,16 @@ def _compute_recall_at_k(
         topk = order[:k_user]
         hits = labels[topk].sum()
         recalls.append(hits / float(num_pos))
-
+    
     return float(np.mean(recalls)) if recalls else 0.0
 
 
-def _compute_hitrate_at_k(
-    y_true: np.ndarray, y_pred: np.ndarray, user_ids: np.ndarray | None, k: int
-) -> float:
+def _compute_hitrate_at_k(y_true: np.ndarray, y_pred: np.ndarray, user_ids: np.ndarray | None, k: int) -> float:
     """Compute HitRate@K."""
     y_true = (y_true > 0).astype(int)
     n = len(y_true)
     groups = _group_indices_by_user(user_ids, n)
-
+    
     hits_per_user = []
     for idx in groups:
         if idx.size == 0:
@@ -210,18 +182,16 @@ def _compute_hitrate_at_k(
         topk = order[:k_user]
         hits = labels[topk].sum()
         hits_per_user.append(1.0 if hits > 0 else 0.0)
-
+    
     return float(np.mean(hits_per_user)) if hits_per_user else 0.0
 
 
-def _compute_mrr_at_k(
-    y_true: np.ndarray, y_pred: np.ndarray, user_ids: np.ndarray | None, k: int
-) -> float:
+def _compute_mrr_at_k(y_true: np.ndarray, y_pred: np.ndarray, user_ids: np.ndarray | None, k: int) -> float:
     """Compute MRR@K."""
     y_true = (y_true > 0).astype(int)
     n = len(y_true)
     groups = _group_indices_by_user(user_ids, n)
-
+    
     mrrs = []
     for idx in groups:
         if idx.size == 0:
@@ -234,14 +204,14 @@ def _compute_mrr_at_k(
         k_user = min(k, idx.size)
         topk = order[:k_user]
         ranked_labels = labels[order]
-
+        
         rr = 0.0
         for rank, lab in enumerate(ranked_labels[:k_user], start=1):
             if lab > 0:
                 rr = 1.0 / rank
                 break
         mrrs.append(rr)
-
+    
     return float(np.mean(mrrs)) if mrrs else 0.0
 
 
@@ -254,14 +224,12 @@ def _compute_dcg_at_k(labels: np.ndarray, k: int) -> float:
     return float(np.sum(gains / discounts))
 
 
-def _compute_ndcg_at_k(
-    y_true: np.ndarray, y_pred: np.ndarray, user_ids: np.ndarray | None, k: int
-) -> float:
+def _compute_ndcg_at_k(y_true: np.ndarray, y_pred: np.ndarray, user_ids: np.ndarray | None, k: int) -> float:
     """Compute NDCG@K."""
     y_true = (y_true > 0).astype(int)
     n = len(y_true)
     groups = _group_indices_by_user(user_ids, n)
-
+    
     ndcgs = []
     for idx in groups:
         if idx.size == 0:
@@ -270,29 +238,27 @@ def _compute_ndcg_at_k(
         if labels.sum() == 0:
             continue
         scores = y_pred[idx]
-
+        
         order = np.argsort(scores)[::-1]
         ranked_labels = labels[order]
         dcg = _compute_dcg_at_k(ranked_labels, k)
-
+        
         # ideal DCG
         ideal_labels = np.sort(labels)[::-1]
         idcg = _compute_dcg_at_k(ideal_labels, k)
         if idcg == 0.0:
             continue
         ndcgs.append(dcg / idcg)
-
+    
     return float(np.mean(ndcgs)) if ndcgs else 0.0
 
 
-def _compute_map_at_k(
-    y_true: np.ndarray, y_pred: np.ndarray, user_ids: np.ndarray | None, k: int
-) -> float:
+def _compute_map_at_k(y_true: np.ndarray, y_pred: np.ndarray, user_ids: np.ndarray | None, k: int) -> float:
     """Mean Average Precision@K."""
     y_true = (y_true > 0).astype(int)
     n = len(y_true)
     groups = _group_indices_by_user(user_ids, n)
-
+    
     aps = []
     for idx in groups:
         if idx.size == 0:
@@ -301,23 +267,23 @@ def _compute_map_at_k(
         num_pos = labels.sum()
         if num_pos == 0:
             continue
-
+        
         scores = y_pred[idx]
         order = np.argsort(scores)[::-1]
         k_user = min(k, idx.size)
-
+        
         hits = 0
         sum_precisions = 0.0
         for rank, i in enumerate(order[:k_user], start=1):
             if labels[i] > 0:
                 hits += 1
                 sum_precisions += hits / float(rank)
-
+        
         if hits == 0:
             aps.append(0.0)
         else:
             aps.append(sum_precisions / float(num_pos))
-
+    
     return float(np.mean(aps)) if aps else 0.0
 
 
@@ -326,26 +292,24 @@ def _compute_cosine_separation(y_true: np.ndarray, y_pred: np.ndarray) -> float:
     y_true = (y_true > 0).astype(int)
     pos_mask = y_true == 1
     neg_mask = y_true == 0
-
+    
     if not np.any(pos_mask) or not np.any(neg_mask):
         return 0.0
-
+    
     pos_mean = float(np.mean(y_pred[pos_mask]))
     neg_mean = float(np.mean(y_pred[neg_mask]))
     return pos_mean - neg_mean
 
 
 def configure_metrics(
-    task: str | list[str],  # 'binary' or ['binary', 'regression']
-    metrics: (
-        list[str] | dict[str, list[str]] | None
-    ),  # ['auc', 'logloss'] or {'task1': ['auc'], 'task2': ['mse']}
-    target_names: list[str],  # ['target1', 'target2']
+    task: str | list[str],                            # 'binary' or ['binary', 'regression']
+    metrics: list[str] | dict[str, list[str]] | None, # ['auc', 'logloss'] or {'task1': ['auc'], 'task2': ['mse']}
+    target_names: list[str]                           # ['target1', 'target2'] 
 ) -> tuple[list[str], dict[str, list[str]] | None, str]:
     """Configure metrics based on task and user input."""
     primary_task = task[0] if isinstance(task, list) else task
     nums_task = len(task) if isinstance(task, list) else 1
-
+    
     metrics_list: list[str] = []
     task_specific_metrics: dict[str, list[str]] | None = None
 
@@ -387,62 +351,48 @@ def configure_metrics(
             if primary_task not in TASK_DEFAULT_METRICS:
                 raise ValueError(f"Unsupported task type: {primary_task}")
             metrics_list = TASK_DEFAULT_METRICS[primary_task]
-
+    
     if not metrics_list:
         # Inline get_default_metrics_for_task logic
         if primary_task not in TASK_DEFAULT_METRICS:
             raise ValueError(f"Unsupported task type: {primary_task}")
         metrics_list = TASK_DEFAULT_METRICS[primary_task]
-
+    
     best_metrics_mode = get_best_metric_mode(metrics_list[0], primary_task)
-
+    
     return metrics_list, task_specific_metrics, best_metrics_mode
 
 
 def get_best_metric_mode(first_metric: str, primary_task: str) -> str:
     """Determine if metric should be maximized or minimized."""
     first_metric_lower = first_metric.lower()
-
+    
     # Metrics that should be maximized
-    if first_metric_lower in {
-        "auc",
-        "gauc",
-        "ks",
-        "accuracy",
-        "acc",
-        "precision",
-        "recall",
-        "f1",
-        "r2",
-        "micro_f1",
-        "macro_f1",
-    }:
-        return "max"
-
+    if first_metric_lower in {'auc', 'gauc', 'ks', 'accuracy', 'acc', 'precision', 'recall', 'f1', 'r2', 'micro_f1', 'macro_f1'}:
+        return 'max'
+    
     # Ranking metrics that should be maximized (with @K suffix)
-    if (
-        first_metric_lower.startswith("recall@")
-        or first_metric_lower.startswith("precision@")
-        or first_metric_lower.startswith("hitrate@")
-        or first_metric_lower.startswith("hr@")
-        or first_metric_lower.startswith("mrr@")
-        or first_metric_lower.startswith("ndcg@")
-        or first_metric_lower.startswith("map@")
-    ):
-        return "max"
-
+    if (first_metric_lower.startswith('recall@') or 
+        first_metric_lower.startswith('precision@') or 
+        first_metric_lower.startswith('hitrate@') or 
+        first_metric_lower.startswith('hr@') or 
+        first_metric_lower.startswith('mrr@') or 
+        first_metric_lower.startswith('ndcg@') or 
+        first_metric_lower.startswith('map@')):
+        return 'max'
+    
     # Cosine separation should be maximized
-    if first_metric_lower == "cosine":
-        return "max"
-
+    if first_metric_lower == 'cosine':
+        return 'max'
+    
     # Metrics that should be minimized
-    if first_metric_lower in {"logloss", "mse", "mae", "rmse", "mape", "msle"}:
-        return "min"
-
+    if first_metric_lower in {'logloss', 'mse', 'mae', 'rmse', 'mape', 'msle'}:
+        return 'min'
+    
     # Default based on task type
-    if primary_task == "regression":
-        return "min"
-    return "max"
+    if primary_task == 'regression':
+        return 'min'
+    return 'max'
 
 
 def compute_single_metric(
@@ -450,111 +400,80 @@ def compute_single_metric(
     y_true: np.ndarray,
     y_pred: np.ndarray,
     task_type: str,
-    user_ids: np.ndarray | None = None,
+    user_ids: np.ndarray | None = None
 ) -> float:
     """Compute a single metric given true and predicted values."""
     y_p_binary = (y_pred > 0.5).astype(int)
-
+    
     try:
         metric_lower = metric.lower()
-
+        
         # recall@K
-        if metric_lower.startswith("recall@"):
-            k = int(metric_lower.split("@")[1])
+        if metric_lower.startswith('recall@'):
+            k = int(metric_lower.split('@')[1])
             return _compute_recall_at_k(y_true, y_pred, user_ids, k)
 
         # precision@K
-        if metric_lower.startswith("precision@"):
-            k = int(metric_lower.split("@")[1])
+        if metric_lower.startswith('precision@'):
+            k = int(metric_lower.split('@')[1])
             return _compute_precision_at_k(y_true, y_pred, user_ids, k)
 
         # hitrate@K / hr@K
-        if metric_lower.startswith("hitrate@") or metric_lower.startswith("hr@"):
-            k_str = metric_lower.split("@")[1]
+        if metric_lower.startswith('hitrate@') or metric_lower.startswith('hr@'):
+            k_str = metric_lower.split('@')[1]
             k = int(k_str)
             return _compute_hitrate_at_k(y_true, y_pred, user_ids, k)
 
         # mrr@K
-        if metric_lower.startswith("mrr@"):
-            k = int(metric_lower.split("@")[1])
+        if metric_lower.startswith('mrr@'):
+            k = int(metric_lower.split('@')[1])
             return _compute_mrr_at_k(y_true, y_pred, user_ids, k)
 
         # ndcg@K
-        if metric_lower.startswith("ndcg@"):
-            k = int(metric_lower.split("@")[1])
+        if metric_lower.startswith('ndcg@'):
+            k = int(metric_lower.split('@')[1])
             return _compute_ndcg_at_k(y_true, y_pred, user_ids, k)
 
         # map@K
-        if metric_lower.startswith("map@"):
-            k = int(metric_lower.split("@")[1])
+        if metric_lower.startswith('map@'):
+            k = int(metric_lower.split('@')[1])
             return _compute_map_at_k(y_true, y_pred, user_ids, k)
 
         # cosine for matching task
-        if metric_lower == "cosine":
+        if metric_lower == 'cosine':
             return _compute_cosine_separation(y_true, y_pred)
-
-        if metric == "auc":
-            value = float(
-                roc_auc_score(
-                    y_true,
-                    y_pred,
-                    average="macro" if task_type == "multilabel" else None,
-                )
-            )
-        elif metric == "gauc":
+        
+        if metric == 'auc':
+            value = float(roc_auc_score(y_true, y_pred, average='macro' if task_type == 'multilabel' else None))
+        elif metric == 'gauc':
             value = float(compute_gauc(y_true, y_pred, user_ids))
-        elif metric == "ks":
+        elif metric == 'ks':
             value = float(compute_ks(y_true, y_pred))
-        elif metric == "logloss":
+        elif metric == 'logloss':
             value = float(log_loss(y_true, y_pred))
-        elif metric in ("accuracy", "acc"):
+        elif metric in ('accuracy', 'acc'):
             value = float(accuracy_score(y_true, y_p_binary))
-        elif metric == "precision":
-            value = float(
-                precision_score(
-                    y_true,
-                    y_p_binary,
-                    average="samples" if task_type == "multilabel" else "binary",
-                    zero_division=0,
-                )
-            )
-        elif metric == "recall":
-            value = float(
-                recall_score(
-                    y_true,
-                    y_p_binary,
-                    average="samples" if task_type == "multilabel" else "binary",
-                    zero_division=0,
-                )
-            )
-        elif metric == "f1":
-            value = float(
-                f1_score(
-                    y_true,
-                    y_p_binary,
-                    average="samples" if task_type == "multilabel" else "binary",
-                    zero_division=0,
-                )
-            )
-        elif metric == "micro_f1":
-            value = float(
-                f1_score(y_true, y_p_binary, average="micro", zero_division=0)
-            )
-        elif metric == "macro_f1":
-            value = float(
-                f1_score(y_true, y_p_binary, average="macro", zero_division=0)
-            )
-        elif metric == "mse":
+        elif metric == 'precision':
+            value = float(precision_score(y_true, y_p_binary, average='samples' if task_type == 'multilabel' else 'binary', zero_division=0))
+        elif metric == 'recall':
+            value = float(recall_score(y_true, y_p_binary, average='samples' if task_type == 'multilabel' else 'binary', zero_division=0))
+        elif metric == 'f1':
+            value = float(f1_score(y_true, y_p_binary, average='samples' if task_type == 'multilabel' else 'binary', zero_division=0))
+        elif metric == 'micro_f1':
+            value = float(f1_score(y_true, y_p_binary, average='micro', zero_division=0))
+        elif metric == 'macro_f1':
+            value = float(f1_score(y_true, y_p_binary, average='macro', zero_division=0))
+        elif metric == 'mse':
             value = float(mean_squared_error(y_true, y_pred))
-        elif metric == "mae":
+        elif metric == 'mae':
             value = float(mean_absolute_error(y_true, y_pred))
-        elif metric == "rmse":
+        elif metric == 'rmse':
             value = float(np.sqrt(mean_squared_error(y_true, y_pred)))
-        elif metric == "r2":
+        elif metric == 'r2':
             value = float(r2_score(y_true, y_pred))
-        elif metric == "mape":
+        elif metric == 'mape':
             value = float(compute_mape(y_true, y_pred))
-        elif metric == "msle":
+        elif metric == 'msle':
             value = float(compute_msle(y_true, y_pred))
         else:
             logging.warning(f"Metric '{metric}' is not supported, returning 0.0")
@@ -562,40 +481,35 @@ def compute_single_metric(
     except Exception as exception:
         logging.warning(f"Failed to compute metric {metric}: {exception}")
         value = 0.0
-
+    
     return value
 
-
 def evaluate_metrics(
     y_true: np.ndarray | None,
     y_pred: np.ndarray | None,
-    metrics: list[str],  # example: ['auc', 'logloss']
-    task: str | list[str],  # example: 'binary' or ['binary', 'regression']
-    target_names: list[str],  # example: ['target1', 'target2']
-    task_specific_metrics: (
-        dict[str, list[str]] | None
-    ) = None,  # example: {'target1': ['auc', 'logloss'], 'target2': ['mse']}
-    user_ids: np.ndarray | None = None,  # example: User IDs for GAUC computation
-) -> dict:  # {'auc': 0.75, 'logloss': 0.45, 'mse_target2': 3.2}
+    metrics: list[str],                                        # example: ['auc', 'logloss']
+    task: str | list[str],                                     # example: 'binary' or ['binary', 'regression']
+    target_names: list[str],                                   # example: ['target1', 'target2']
+    task_specific_metrics: dict[str, list[str]] | None = None, # example: {'target1': ['auc', 'logloss'], 'target2': ['mse']}
+    user_ids: np.ndarray | None = None                         # example: User IDs for GAUC computation
+) -> dict:                                                     # {'auc': 0.75, 'logloss': 0.45, 'mse_target2': 3.2}
     """Evaluate specified metrics for given true and predicted values."""
     result = {}
-
+    
     if y_true is None or y_pred is None:
         return result
-
+    
     # Main evaluation logic
     primary_task = task[0] if isinstance(task, list) else task
     nums_task = len(task) if isinstance(task, list) else 1
-
+    
     # Single task evaluation
     if nums_task == 1:
         for metric in metrics:
             metric_lower = metric.lower()
-            value = compute_single_metric(
-                metric_lower, y_true, y_pred, primary_task, user_ids
-            )
+            value = compute_single_metric(metric_lower, y_true, y_pred, primary_task, user_ids)
             result[metric_lower] = value
-
+    
     # Multi-task evaluation
     else:
         for metric in metrics:
@@ -605,9 +519,7 @@ def evaluate_metrics(
                 should_compute = True
                 if task_specific_metrics is not None and task_idx < len(target_names):
                     task_name = target_names[task_idx]
-                    should_compute = metric_lower in task_specific_metrics.get(
-                        task_name, []
-                    )
+                    should_compute = metric_lower in task_specific_metrics.get(task_name, [])
                 else:
                     # Get task type for specific index
                     if isinstance(task, list) and task_idx < len(task):
@@ -615,51 +527,31 @@ def evaluate_metrics(
                     elif isinstance(task, str):
                         task_type = task
                     else:
-                        task_type = "binary"
-
-                    if task_type in ["binary", "multilabel"]:
-                        should_compute = metric_lower in {
-                            "auc",
-                            "ks",
-                            "logloss",
-                            "accuracy",
-                            "acc",
-                            "precision",
-                            "recall",
-                            "f1",
-                            "micro_f1",
-                            "macro_f1",
-                        }
-                    elif task_type == "regression":
-                        should_compute = metric_lower in {
-                            "mse",
-                            "mae",
-                            "rmse",
-                            "r2",
-                            "mape",
-                            "msle",
-                        }
-
+                        task_type = 'binary'
+                    
+                    if task_type in ['binary', 'multilabel']:
+                        should_compute = metric_lower in {'auc', 'ks', 'logloss', 'accuracy', 'acc', 'precision', 'recall', 'f1', 'micro_f1', 'macro_f1'}
+                    elif task_type == 'regression':
+                        should_compute = metric_lower in {'mse', 'mae', 'rmse', 'r2', 'mape', 'msle'}
+                
                 if not should_compute:
                     continue
-
+                
                 target_name = target_names[task_idx]
-
+                
                 # Get task type for specific index
                 if isinstance(task, list) and task_idx < len(task):
                     task_type = task[task_idx]
                 elif isinstance(task, str):
                     task_type = task
                 else:
-                    task_type = "binary"
-
+                    task_type = 'binary'
+                
                 y_true_task = y_true[:, task_idx]
                 y_pred_task = y_pred[:, task_idx]
-
+                
                 # Compute metric
-                value = compute_single_metric(
-                    metric_lower, y_true_task, y_pred_task, task_type, user_ids
-                )
-                result[f"{metric_lower}_{target_name}"] = value
-
+                value = compute_single_metric(metric_lower, y_true_task, y_pred_task, task_type, user_ids)
+                result[f'{metric_lower}_{target_name}'] = value
+    
     return result