Spaces:
Running
Running
File size: 2,677 Bytes
e59bd9d | 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 | """Execution policy: PERFORMANCE | BALANCED | EFFICIENCY.
A policy is a set of decision thresholds, not marketing words. Every knob
below has a consumer in the scheduler/monitor and changes real behavior:
- probe_iterations: how many real micro-benchmark iterations run when
choosing a strategy / precision.
- strategy aggressiveness: PERFORMANCE may test model_parallel for large
models; EFFICIENCY never leaves single-GPU unless VRAM forces it.
- monitoring frequency: PERFORMANCE samples GPU state less often during
training (less overhead); EFFICIENCY idles at the slowest safe rate.
"""
from __future__ import annotations
from dataclasses import dataclass
from enum import Enum
from typing import Dict
class PerformanceMode(str, Enum):
PERFORMANCE = "performance"
BALANCED = "balanced"
EFFICIENCY = "efficiency"
@dataclass(frozen=True)
class Policy:
mode: PerformanceMode
probe_iterations: int
model_parallel_min_param_mb: float # below this, model split is refused
allow_strategy_probe: bool # measure DP vs single at startup
monitor_active_seconds: float
monitor_idle_seconds: float
min_dp_batch_per_gpu: int # DP pointless below this per-GPU batch
allow_ddp_auto: bool # DDP may win a probe and be selected
POLICIES: Dict[PerformanceMode, Policy] = {
PerformanceMode.PERFORMANCE: Policy(
mode=PerformanceMode.PERFORMANCE,
probe_iterations=12,
model_parallel_min_param_mb=200.0,
allow_strategy_probe=True,
monitor_active_seconds=1.0,
monitor_idle_seconds=5.0,
min_dp_batch_per_gpu=2,
allow_ddp_auto=False, # Windows gloo reliability: opt-in only, always
),
PerformanceMode.BALANCED: Policy(
mode=PerformanceMode.BALANCED,
probe_iterations=6,
model_parallel_min_param_mb=400.0,
allow_strategy_probe=True,
monitor_active_seconds=2.0,
monitor_idle_seconds=10.0,
min_dp_batch_per_gpu=4,
allow_ddp_auto=False,
),
PerformanceMode.EFFICIENCY: Policy(
mode=PerformanceMode.EFFICIENCY,
probe_iterations=0, # no probing overhead at all
model_parallel_min_param_mb=1e9,
allow_strategy_probe=False,
monitor_active_seconds=5.0,
monitor_idle_seconds=30.0,
min_dp_batch_per_gpu=8,
allow_ddp_auto=False,
),
}
def get_policy(mode: str) -> Policy:
try:
return POLICIES[PerformanceMode(str(mode).lower())]
except KeyError:
raise ValueError(
f"unknown performance mode {mode!r}; valid: {[m.value for m in PerformanceMode]}"
)
|