File size: 4,953 Bytes
5f4e9ea | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 | """Group-level dynamic sampling diagnostics for GRPO v1.1 / v1.2.
Filters on *total* reward when process scoring is on, otherwise on outcome.
Does not change group size, advantage math, KL, or clip ranges.
"""
from __future__ import annotations
import math
from dataclasses import dataclass, field
from typing import Sequence
SILENT = "silent"
OUTCOME_VARIATION = "outcome_variation"
PROCESS_ONLY = "process_only_variation"
ALL_MAX = "all_max"
def _finite_std(values: Sequence[float]) -> float:
nums = [float(v) for v in values]
if len(nums) < 2:
return 0.0
mean = sum(nums) / len(nums)
var = sum((v - mean) ** 2 for v in nums) / len(nums)
return math.sqrt(var)
def _all_close(values: Sequence[float], target: float | None = None, eps: float = 1e-8) -> bool:
nums = [float(v) for v in values]
if not nums:
return True
ref = nums[0] if target is None else float(target)
return all(abs(v - ref) <= eps for v in nums)
def classify_group(
total_rewards: Sequence[float],
*,
outcome_rewards: Sequence[float] | None = None,
process_rewards: Sequence[float] | None = None,
max_total: float,
use_process: bool = True,
eps: float = 1e-8,
) -> str:
totals = [float(v) for v in total_rewards]
if not totals:
return SILENT
if _all_close(totals, max_total, eps=eps):
return ALL_MAX
if _finite_std(totals) <= eps:
return SILENT
outcomes = list(outcome_rewards) if outcome_rewards is not None else totals
if _finite_std(outcomes) > eps:
return OUTCOME_VARIATION
processes = list(process_rewards or [])
if use_process and processes and _finite_std(processes) > eps:
return PROCESS_ONLY
return OUTCOME_VARIATION if _finite_std(totals) > eps else SILENT
def keep_group(label: str) -> bool:
return label in {OUTCOME_VARIATION, PROCESS_ONLY}
@dataclass
class FilterResult:
keep_indices: list[int]
labels: list[str]
resample: bool
cap_exhausted: bool
counts: dict[str, int] = field(default_factory=dict)
def apply_dynamic_sampling(
groups: Sequence[Sequence[float]],
*,
outcome_groups: Sequence[Sequence[float]] | None = None,
process_groups: Sequence[Sequence[float]] | None = None,
max_total: float,
use_process: bool = True,
resample_attempt: int = 0,
resample_cap: int = 3,
eps: float = 1e-8,
) -> FilterResult:
"""Keep groups with nonzero total-reward std. Request resample if none remain."""
labels: list[str] = []
keep: list[int] = []
counts = {SILENT: 0, OUTCOME_VARIATION: 0, PROCESS_ONLY: 0, ALL_MAX: 0}
for i, totals in enumerate(groups):
outcomes = outcome_groups[i] if outcome_groups is not None else None
processes = process_groups[i] if process_groups is not None else None
if not use_process:
processes = None
# v1.1: filter on outcome only
label = classify_group(
totals if outcomes is None else outcomes,
outcome_rewards=outcomes if outcomes is not None else totals,
process_rewards=None,
max_total=max_total,
use_process=False,
eps=eps,
)
else:
label = classify_group(
totals,
outcome_rewards=outcomes,
process_rewards=processes,
max_total=max_total,
use_process=True,
eps=eps,
)
labels.append(label)
counts[label] = counts.get(label, 0) + 1
if keep_group(label):
keep.append(i)
if keep:
return FilterResult(keep_indices=keep, labels=labels, resample=False, cap_exhausted=False, counts=counts)
if resample_attempt < resample_cap:
return FilterResult(keep_indices=[], labels=labels, resample=True, cap_exhausted=False, counts=counts)
return FilterResult(keep_indices=[], labels=labels, resample=False, cap_exhausted=True, counts=counts)
def chunk_rewards(rewards: Sequence[float], group_size: int) -> list[list[float]]:
if group_size <= 0:
raise ValueError("group_size must be positive")
values = list(rewards)
groups = [values[i : i + group_size] for i in range(0, len(values), group_size)]
return groups
def summarize_filter(result: FilterResult) -> dict[str, float]:
n = max(len(result.labels), 1)
return {
"dyn/n_groups": float(len(result.labels)),
"dyn/n_kept": float(len(result.keep_indices)),
"dyn/frac_silent": result.counts.get(SILENT, 0) / n,
"dyn/frac_outcome_variation": result.counts.get(OUTCOME_VARIATION, 0) / n,
"dyn/frac_process_only": result.counts.get(PROCESS_ONLY, 0) / n,
"dyn/frac_all_max": result.counts.get(ALL_MAX, 0) / n,
"dyn/resample": float(result.resample),
"dyn/cap_exhausted": float(result.cap_exhausted),
}
|