Problem Decomposition Questions

from collections import defaultdict
from typing import List, Dict, Tuple

def compute_worst_f1_labels(dataset: List[Dict], predictions: List[int], top_k: int = 3) -> List[Tuple[int, float, float, float]]:
    """
    Compute precision, recall, F1 for each label and return top_k labels with lowest F1 (worst-performing).
    
    Args:
        dataset: list of dicts, each must contain key 'label' (int) for ground truth.
        predictions: list of predicted labels (ints), same length as dataset.
        top_k: number of worst labels to return (default 3).
    
    Returns:
        List of tuples (label, precision, recall, f1) sorted ascending by f1 (worst first).
    
    Notes:
        - If there are zero predicted positives for a label, precision is set to 0.0 safely.
        - If there are zero true positives + false negatives, recall is set to 0.0 safely.
    """
    if len(dataset) != len(predictions):
        raise ValueError("dataset and predictions must have same length")
    
    tp = defaultdict(int)
    fp = defaultdict(int)
    fn = defaultdict(int)
    labels_set = set()
    
    for item, pred in zip(dataset, predictions):
        true = item['label']
        labels_set.add(true)
        labels_set.add(pred)
        if pred == true:
            tp[true] += 1
        else:
            fp[pred] += 1
            fn[true] += 1
    
    results = []
    for lbl in labels_set:
        tp_v = tp[lbl]
        fp_v = fp[lbl]
        fn_v = fn[lbl]
        prec = tp_v / (tp_v + fp_v) if (tp_v + fp_v) > 0 else 0.0
        rec  = tp_v / (tp_v + fn_v) if (tp_v + fn_v) > 0 else 0.0
        f1   = (2 * prec * rec) / (prec + rec) if (prec + rec) > 0 else 0.0
        results.append((lbl, round(prec, 4), round(rec, 4), round(f1, 4)))
    
    # sort by f1 ascending and return top_k worst
    results.sort(key=lambda x: x[3])
    return results[:top_k]