Kies drempels op validatie en houd ze daarna vast

import itertools

import math

import re

import numpy as np

# Jouw functies

def threshold_profile(labels, scores, thresholds):
    labels, scores, thresholds = _th_inputs(labels, scores, thresholds)
    result = []
    for threshold in thresholds:
        predicted = scores >= threshold
        result.append({'threshold': float(threshold), 'count': len(labels), 'tp': int(np.count_nonzero((labels == 1) & predicted)), 'fp': int(np.count_nonzero((labels == 0) & predicted)), 'tn': int(np.count_nonzero((labels == 0) & ~predicted)), 'fn': int(np.count_nonzero((labels == 1) & ~predicted))})
    return result

def combine_policies(group_profiles, fp_cost=1.0, fn_cost=1.0):
    groups = _th_profiles(group_profiles)
    fp_cost = _th_number(fp_cost, 0, 100)
    fn_cost = _th_number(fn_cost, 0, 100)
    result = []
    for (i, left), (j, right) in itertools.product(enumerate(groups[0]['profiles']), enumerate(groups[1]['profiles'])):
        gaps = {}
        for metric, num_fields, den_fields in [('selection_gap', ['tp', 'fp'], ['count']), ('tpr_gap', ['tp'], ['tp', 'fn']), ('fpr_gap', ['fp'], ['fp', 'tn'])]:
            values = []
            for row in [left, right]:
                den = sum((row[field] for field in den_fields))
                values.append(sum((row[field] for field in num_fields)) / den if den else None)
            gaps[metric] = None if None in values else abs(values[0] - values[1])
        gaps['equalized_odds_gap'] = None if gaps['tpr_gap'] is None or gaps['fpr_gap'] is None else max(gaps['tpr_gap'], gaps['fpr_gap'])
        result.append({'id': f'{i}:{j}', 'thresholds': {groups[0]['id']: left['threshold'], groups[1]['id']: right['threshold']}, 'weighted_cost': fp_cost * (left['fp'] + right['fp']) + fn_cost * (left['fn'] + right['fn']), 'error_count': left['fp'] + right['fp'] + left['fn'] + right['fn'], 'row_count': left['count'] + right['count'], **gaps})
    return result

def choose_policy(candidate_rows, criterion='equalized_odds', tolerance=0.1):
    rows = _th_candidates(candidate_rows)
    if type(criterion) is not str or criterion not in ['selection', 'opportunity', 'equalized_odds']:
        raise ValueError('Een expliciet ondersteund empirisch criterium vereist')
    tolerance = _th_number(tolerance, 0, 1)
    field = {'selection': 'selection_gap', 'opportunity': 'tpr_gap', 'equalized_odds': 'equalized_odds_gap'}[criterion]
    eligible = []
    rejected = {}
    for row in rows:
        if row[field] is None:
            rejected[row['id']] = 'unknown'
        elif row[field] > tolerance:
            rejected[row['id']] = 'above-tolerance'
        else:
            eligible.append(row)
    chosen = min(eligible, key=lambda row: (row['weighted_cost'], row[field], tuple(row['thresholds'].values()), row['id']))['id'] if eligible else None
    return {'criterion': criterion, 'tolerance': tolerance, 'chosen_id': chosen, 'eligible_ids': sorted((row['id'] for row in eligible)), 'rejected': rejected}

# Gegeven helpers

def _th_number(value, low, high):
    if isinstance(value, (bool, np.bool_)) or not isinstance(value, (int, float, np.integer, np.floating)):
        raise ValueError('Eindige begrensde scalar vereist')
    try:
        value = float(value)
    except (OverflowError, ValueError, TypeError):
        raise ValueError('Eindige begrensde scalar vereist') from None
    if not math.isfinite(value) or not low <= value <= high:
        raise ValueError('Eindige begrensde scalar vereist')
    return value

def _th_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 _th_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 _th_inputs(labels, scores, thresholds):
    raw = np.asarray(labels)
    if raw.ndim != 1 or len(raw) > 256 or raw.dtype.kind not in ('iuf' if len(raw) == 0 else 'iu') or np.any((raw != 0) & (raw != 1)):
        raise ValueError('Binaire integer-labels vereist; een lege numerieke vector mag')
    labels = raw.astype(np.int64, copy=True)
    raw = np.asarray(scores)
    if raw.ndim != 1 or len(raw) != len(labels) or raw.dtype.kind not in 'iuf' or (not np.isfinite(raw).all()):
        raise ValueError('Evenveel eindige reële scores vereist')
    scores = raw.astype(float, copy=True)
    if np.any(scores < 0) or np.any(scores > 1):
        raise ValueError('Geconverteerde scores binnen 0–1 vereist')
    raw = np.asarray(thresholds)
    if raw.ndim != 1 or not 1 <= len(raw) <= 9 or raw.dtype.kind not in 'iuf' or (not np.isfinite(raw).all()):
        raise ValueError('Een tot negen eindige drempels vereist')
    thresholds = raw.astype(float, copy=True)
    if np.any(thresholds < 0) or np.any(thresholds > 1) or np.any(np.diff(thresholds) <= 0):
        raise ValueError('Strikt stijgende geconverteerde drempels binnen 0–1 vereist')
    return (labels, scores, thresholds)

def _th_profiles(group_profiles):
    if type(group_profiles) not in (list, tuple) or len(group_profiles) != 2:
        raise ValueError('Precies twee expliciete groepsprofielen vereist')
    result = []
    for group in group_profiles:
        if type(group) is not dict or set(group) != {'id', 'profiles'}:
            raise ValueError('Groepsnaam en drempelprofielen vereist')
        name = _th_id(group['id'])
        rows = group['profiles']
        if type(rows) not in (list, tuple) or not 1 <= len(rows) <= 9:
            raise ValueError('Een tot negen drempelprofielen vereist')
        cleaned = []
        for row in rows:
            if type(row) is not dict or set(row) != {'threshold', 'count', 'tp', 'fp', 'tn', 'fn'}:
                raise ValueError('Volledig drempelprofiel vereist')
            item = {'threshold': _th_number(row['threshold'], 0, 1)}
            for key in ['count', 'tp', 'fp', 'tn', 'fn']:
                item[key] = _th_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')
            if cleaned:
                previous = cleaned[-1]
                if item['threshold'] <= previous['threshold'] or item['count'] != previous['count'] or item['tp'] + item['fn'] != previous['tp'] + previous['fn'] or (item['fp'] + item['tn'] != previous['fp'] + previous['tn']):
                    raise ValueError('Dezelfde gelabelde groep en stijgende drempels vereist')
                if item['tp'] > previous['tp'] or item['fp'] > previous['fp']:
                    raise ValueError('Een hogere drempel kan niet meer positieve voorspellingen geven')
            cleaned.append(item)
        result.append({'id': name, 'profiles': cleaned})
    if result[0]['id'] == result[1]['id'] or not 1 <= sum((group['profiles'][0]['count'] for group in result)) <= 256:
        raise ValueError('Twee unieke groepen met samen 1–256 rijen vereist')
    return result

def _th_candidates(rows):
    fields = {'id', 'thresholds', 'weighted_cost', 'error_count', 'row_count', 'selection_gap', 'tpr_gap', 'fpr_gap', 'equalized_odds_gap'}
    if type(rows) not in (list, tuple) or not 1 <= len(rows) <= 81:
        raise ValueError('Een tot 81 kandidaat-samenvattingen vereist')
    cleaned = []
    names = None
    seen_ids = set()
    seen_thresholds = set()
    count = None
    for row in rows:
        if type(row) is not dict or set(row) != fields or type(row['id']) is not str or (re.fullmatch('[0-8]:[0-8]', row['id']) is None):
            raise ValueError('Volledige kandidaat met grid-id vereist')
        if row['id'] in seen_ids:
            raise ValueError('Unieke kandidaat-ids vereist')
        thresholds = row['thresholds']
        if type(thresholds) is not dict or len(thresholds) != 2:
            raise ValueError('Twee groepsdrempels vereist')
        ids = [_th_id(value) for value in thresholds]
        if names is None:
            names = ids
        if ids != names:
            raise ValueError('Behoud dezelfde groepsnamen en volgorde')
        thresholds = {name: _th_number(thresholds[name], 0, 1) for name in ids}
        pair = tuple(thresholds.values())
        if pair in seen_thresholds:
            raise ValueError('Unieke drempelparen vereist')
        item = {'id': row['id'], 'thresholds': thresholds, 'weighted_cost': _th_number(row['weighted_cost'], 0, 25600), 'error_count': _th_int(row['error_count']), 'row_count': _th_int(row['row_count'])}
        if not 1 <= item['row_count'] <= 256 or item['error_count'] > item['row_count']:
            raise ValueError('Geldige aantallen rijen en fouten vereist')
        if count is None:
            count = item['row_count']
        if item['row_count'] != count:
            raise ValueError('Dezelfde validatierijen voor alle kandidaten vereist')
        for key in ['selection_gap', 'tpr_gap', 'fpr_gap', 'equalized_odds_gap']:
            item[key] = None if row[key] is None else _th_number(row[key], 0, 1)
        expected = None if item['tpr_gap'] is None or item['fpr_gap'] is None else max(item['tpr_gap'], item['fpr_gap'])
        if item['equalized_odds_gap'] != expected:
            raise ValueError('Equalized-odds-gap volgt uit beide conditionele gaps')
        cleaned.append(item)
        seen_ids.add(item['id'])
        seen_thresholds.add(pair)
    return cleaned

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