Vergelijk groepsmaten met de juiste noemers

import math

import re

import numpy as np

# Jouw functies

def group_confusions(labels, predictions, groups, group_ids):
    labels, predictions, groups, ids = _fair_data(labels, predictions, groups, group_ids)
    rows = {name: {'id': name, 'count': 0, 'tp': 0, 'fp': 0, 'tn': 0, 'fn': 0} for name in ids}
    for truth, prediction, name in zip(labels, predictions, groups):
        row = rows[name]
        row['count'] += 1
        key = ('tp' if prediction else 'fn') if truth else 'fp' if prediction else 'tn'
        row[key] += 1
    return list(rows.values())

def conditional_rates(count_rows):
    rows = _fair_counts(count_rows)
    result = []
    for row in rows:
        denoms = {'selection_rate': row['count'], 'tpr': row['tp'] + row['fn'], 'fpr': row['fp'] + row['tn']}
        numerators = {'selection_rate': row['tp'] + row['fp'], 'tpr': row['tp'], 'fpr': row['fp']}
        item = {'id': row['id'], 'denominators': denoms}
        for key in numerators:
            item[key] = numerators[key] / denoms[key] if denoms[key] else None
        result.append(item)
    return result

def fairness_gaps(rate_rows):
    rows = _fair_rates(rate_rows)
    result = {}
    unknown = {}
    for metric, key in [('selection_rate', 'selection_gap'), ('tpr', 'tpr_gap'), ('fpr', 'fpr_gap')]:
        unknown[metric] = [row['id'] for row in rows if row[metric] is None]
        values = [row[metric] for row in rows if row[metric] is not None]
        result[key] = None if unknown[metric] else max(values) - min(values)
    result['equalized_odds_gap'] = None if result['tpr_gap'] is None or result['fpr_gap'] is None else max(result['tpr_gap'], result['fpr_gap'])
    result['undefined_groups'] = unknown
    return result

# Gegeven helpers

def _fair_id(value):
    if type(value) is not str or re.fullmatch('[a-z][a-z0-9_-]{0,23}', value) is None:
        raise ValueError('Korte synthetische groepsnaam vereist')
    return value

def _fair_int(value):
    if isinstance(value, (bool, np.bool_)) or not isinstance(value, (int, np.integer)) or (not 0 <= int(value) <= 256):
        raise ValueError('Gehele telling binnen 0–256 vereist')
    return int(value)

def _fair_number(value):
    if isinstance(value, (bool, np.bool_)) or not isinstance(value, (int, float, np.integer, np.floating)):
        raise ValueError('Eindige fractie vereist')
    try:
        value = float(value)
    except (OverflowError, ValueError, TypeError):
        raise ValueError('Eindige fractie vereist') from None
    if not math.isfinite(value) or not 0 <= value <= 1:
        raise ValueError('Fractie binnen 0–1 vereist')
    return value

def _fair_data(labels, predictions, groups, group_ids):
    vectors = []
    for value in [labels, predictions]:
        raw = np.asarray(value)
        if raw.ndim != 1 or not 1 <= len(raw) <= 256 or raw.dtype.kind not in 'iu' or np.any((raw != 0) & (raw != 1)):
            raise ValueError('Binaire integer-vector van 1–256 rijen vereist')
        vectors.append(raw.astype(np.int64, copy=True))
    if len(vectors[0]) != len(vectors[1]) or type(groups) not in (list, tuple) or len(groups) != len(vectors[0]):
        raise ValueError('Evenveel labels, voorspellingen en groepen vereist')
    if type(group_ids) not in (list, tuple) or not 2 <= len(group_ids) <= 8:
        raise ValueError('Twee tot acht expliciete groepen vereist')
    ids = [_fair_id(value) for value in group_ids]
    if len(set(ids)) != len(ids):
        raise ValueError('Unieke groepsnamen vereist')
    selected = [_fair_id(value) for value in groups]
    if any((value not in ids for value in selected)):
        raise ValueError('Iedere rij moet bij een gevraagde groep horen')
    return (vectors[0], vectors[1], selected, ids)

def _fair_counts(rows):
    if type(rows) not in (list, tuple) or not 2 <= len(rows) <= 8:
        raise ValueError('Twee tot acht groepstellingen vereist')
    cleaned = []
    for row in rows:
        if type(row) is not dict or set(row) != {'id', 'count', 'tp', 'fp', 'tn', 'fn'}:
            raise ValueError('Volledige groepstelling vereist')
        item = {'id': _fair_id(row['id'])}
        for key in ['count', 'tp', 'fp', 'tn', 'fn']:
            item[key] = _fair_int(row[key])
        if item['count'] != sum((item[key] for key in ['tp', 'fp', 'tn', 'fn'])):
            raise ValueError('Telling moet uit de vier cellen volgen')
        cleaned.append(item)
    if len({row['id'] for row in cleaned}) != len(cleaned) or not 1 <= sum((row['count'] for row in cleaned)) <= 256:
        raise ValueError('Unieke groepen met samen 1–256 rijen vereist')
    return cleaned

def _fair_rates(rows):
    metrics = ['selection_rate', 'tpr', 'fpr']
    if type(rows) not in (list, tuple) or not 2 <= len(rows) <= 8:
        raise ValueError('Twee tot acht groepsmaten vereist')
    cleaned = []
    for row in rows:
        if type(row) is not dict or set(row) != {'id', 'denominators', *metrics}:
            raise ValueError('Drie groepsmaten met hun noemers vereist')
        denoms = row['denominators']
        if type(denoms) is not dict or set(denoms) != set(metrics):
            raise ValueError('Geef alle drie noemers')
        copied = {key: _fair_int(denoms[key]) for key in metrics}
        if copied['selection_rate'] != copied['tpr'] + copied['fpr']:
            raise ValueError('Positieve en negatieve labels moeten alle rijen vormen')
        item = {'id': _fair_id(row['id']), 'denominators': copied}
        for key in metrics:
            if copied[key] == 0:
                if row[key] is not None:
                    raise ValueError('Een lege noemer geeft onbekend, geen nul')
                item[key] = None
            else:
                item[key] = _fair_number(row[key])
        cleaned.append(item)
    if len({row['id'] for row in cleaned}) != len(cleaned) or not 1 <= sum((row['denominators']['selection_rate'] for row in cleaned)) <= 256:
        raise ValueError('Unieke groepen met samen 1–256 rijen vereist')
    return cleaned

Voer de code uit en verklaar voor jezelf waarom elke stap werkt.