Bewaar bekende scenario’s en kies binnen een expliciete grens

import math
import re
import numpy as np

# Jouw functies

def scenario_profile(utility, harm, actions, weights=None):
    utility, harm = _safe_tables(utility, harm)
    actions = _safe_actions(actions, len(utility), utility.shape[1])
    weights = _safe_weights(weights, len(utility))
    rows = np.arange(len(utility))
    selected_utility = utility[rows, actions].copy()
    selected_harm = harm[rows, actions].copy()
    worst = float(np.max(selected_harm))
    return {'utility': selected_utility, 'harm': selected_harm, 'weights': weights.copy(), 'mean_utility': _safe_mean(selected_utility, weights), 'mean_harm': _safe_mean(selected_harm, weights), 'worst_harm': worst, 'worst_contexts': [int(index) for index, value in enumerate(selected_harm) if value == worst]}

def compare_candidates(utility, harm, policies, weights=None):
    utility, harm = _safe_tables(utility, harm)
    policies = _safe_actions(policies, len(utility), utility.shape[1], True)
    weights = _safe_weights(weights, len(utility))
    rows = np.arange(len(utility))
    result = []
    for index, actions in enumerate(policies):
        chosen_utility = utility[rows, actions]
        chosen_harm = harm[rows, actions]
        worst = float(np.max(chosen_harm))
        result.append({'id': 'p' + str(index), 'actions': actions.copy(), 'mean_utility': _safe_mean(chosen_utility, weights), 'mean_harm': _safe_mean(chosen_harm, weights), 'worst_harm': worst, 'worst_contexts': [int(row) for row, value in enumerate(chosen_harm) if value == worst]})
    return result

def choose_guarded(candidate_rows, max_harm=0.2):
    rows = _safe_candidates(candidate_rows)
    limit = _safe_number(max_harm)
    eligible = [row for row in rows if row['worst_harm'] <= limit]
    chosen = min(eligible, key=lambda row: (-row['mean_utility'], row['worst_harm'], row['mean_harm'], row['id'])) if eligible else None
    return {'max_harm': limit, 'chosen_id': None if chosen is None else chosen['id'], 'eligible_ids': [row['id'] for row in eligible], 'rejected': {row['id']: 'above-limit' for row in rows if row['worst_harm'] > limit}}

# Gegeven helpers

def _safe_tables(utility, harm):
    result = []
    for value in [utility, harm]:
        raw = np.asarray(value)
        if raw.ndim != 2 or not 1 <= raw.shape[0] <= 64 or (not 2 <= raw.shape[1] <= 8) or (raw.dtype.kind not in 'iuf') or (not np.isfinite(raw).all()):
            raise ValueError('Kleine eindige numerieke scenariotabellen vereist')
        with np.errstate(over='ignore', invalid='ignore'):
            values = raw.astype(float, copy=True)
        if not np.isfinite(values).all() or np.any(values < 0) or np.any(values > 1):
            raise ValueError('Geconverteerde nut- en schadewaarden binnen 0–1 vereist')
        result.append(values)
    if result[0].shape != result[1].shape:
        raise ValueError('Gelijke tabelvormen vereist')
    return result

def _safe_actions(value, rows, options, matrix=False):
    raw = np.asarray(value)
    valid = raw.ndim == 2 and 1 <= raw.shape[0] <= 16 and (raw.shape[1] == rows) if matrix else raw.ndim == 1 and len(raw) == rows
    if not valid or raw.dtype.kind not in 'iu' or np.any(raw < 0) or np.any(raw >= options):
        raise ValueError('Geldige gehele acties per scenario vereist')
    return raw.astype(np.int64, copy=True)

def _safe_weights(value, rows):
    if value is None:
        return np.ones(rows, dtype=float) / rows
    raw = np.asarray(value)
    if raw.ndim != 1 or len(raw) != rows or raw.dtype.kind not in 'iuf' or (not np.isfinite(raw).all()):
        raise ValueError('Een eindig numeriek gewicht per scenario vereist')
    with np.errstate(over='ignore', invalid='ignore'):
        weights = raw.astype(float, copy=True)
    if not np.isfinite(weights).all() or np.any(weights < 0) or np.any(weights > 1) or (float(np.sum(weights)) <= 0):
        raise ValueError('Geconverteerde gewichten binnen 0–1 met positieve som vereist')
    return weights / np.sum(weights)

def _safe_mean(values, weights):
    return float(np.clip(weights @ values, float(np.min(values)), float(np.max(values))))

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

def _safe_candidates(candidate_rows):
    if type(candidate_rows) not in (list, tuple) or not 1 <= len(candidate_rows) <= 16:
        raise ValueError('Een tot zestien kandidaatrapporten vereist')
    result = []
    seen = set()
    count = None
    for row in candidate_rows:
        if type(row) is not dict or set(row) != {'id', 'actions', 'mean_utility', 'mean_harm', 'worst_harm', 'worst_contexts'}:
            raise ValueError('Precies de gedeclareerde kandidaatvelden vereist')
        name = row['id']
        if type(name) is not str or not re.fullmatch('p(?:[0-9]|1[0-5])', name) or name in seen:
            raise ValueError('Unieke id p0 tot p15 vereist')
        seen.add(name)
        raw = np.asarray(row['actions'])
        if raw.ndim != 1 or not 1 <= len(raw) <= 64:
            raise ValueError('Een tot 64 scenarioacties vereist')
        actions = _safe_actions(raw, len(raw), 8)
        if count is not None and len(actions) != count:
            raise ValueError('Iedere kandidaat heeft evenveel scenarioacties')
        count = len(actions)
        utility = _safe_number(row['mean_utility'])
        harm = _safe_number(row['mean_harm'])
        worst = _safe_number(row['worst_harm'])
        contexts = np.asarray(row['worst_contexts'])
        if contexts.ndim != 1 or not 1 <= len(contexts) <= count or contexts.dtype.kind not in 'iu' or np.any(contexts < 0) or np.any(contexts >= count):
            raise ValueError('Geldige slechtste scenario-indices vereist')
        contexts = contexts.astype(np.int64, copy=True)
        if np.any(np.diff(contexts) <= 0) or harm > worst:
            raise ValueError('Geordende unieke indices en gemiddelde schade hoogstens het maximum vereist')
        result.append({'id': name, 'actions': actions, 'mean_utility': utility, 'mean_harm': harm, 'worst_harm': worst, 'worst_contexts': [int(index) for index in contexts]})
    return result

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