Find Your Perfect

def weighted_available(
    values: Mapping[str, float | None],
    weights: Mapping[str, float],
) -> tuple[float | None, float]:
    available = [
        (key, values.get(key))
        for key in weights
        if values.get(key) is not None
    ]
    if not available:
        return None, 0.0

    available_weight = sum(
        weights[key] for key, _ in available
    )
    score = sum(
        weights[key] * float(value)
        for key, value in available
    ) / available_weight
    confidence = available_weight / sum(weights.values())
    return clamp01(score), clamp01(confidence)

prediction = preference_score(
    safe, weights, swipes=prior_swipes
)
learning_rate = (
    BASE_LEARNING_RATE
    / math.sqrt(1.0 + prior_swipes / 20.0)
)

for spec in FEATURE_SPECS:
    if not spec.learnable or (
        not spec.public
        and prior_swipes < HIDDEN_ACTIVATION_SWIPES
    ):
        continue

    x = centred_feature(safe[spec.feature_id])
    if x == 0.0:
        continue

    regularization = (
        HIDDEN_L2 if not spec.public else PUBLIC_L2
    )
    current = weights[spec.feature_id]
    gradient = (
        training_weight * (label - prediction) * x
        - regularization * current
    )
    weights[spec.feature_id] = max(
        -spec.max_abs_weight,
        min(
            spec.max_abs_weight,
            current + learning_rate * gradient,
        ),
    )

exploration_slots = (
    max(1, round(limit * EPSILON))
    if limit >= 5 and len(scored) > limit
    else 0
)

def diversity(item):
    values = []
    for key, value in item["_feature_snapshot"].items():
        if key in {"deprivation_context", "crime_context"}:
            continue
        other = anchor.get(key)
        if value is not None and other is not None:
            values.append((float(value) - float(other)) ** 2)

    categorical_difference = sum(
        1.0
        for affinity in item["_affinity_snapshot"]
        if (affinity["category"], affinity["key"])
        not in anchor_affinities
    )
    return sum(values) + 0.25 * categorical_difference

chosen = max(remaining, key=diversity)