chore: update scoring function with option to regulate the influence of CO2 savings

Author: Boolean-true

TheGreenEpochWeb/src/data/store.tsx

@@ -34,7 +34,7 @@ interface AppStore {
   addScenario: (s: Scenario) => void;
   updateScenario: (id: string, s: Scenario) => void;
   deleteScenario: (id: string) => void;
-  runAllScenarios: (onProgress?: (done: number, total: number) => void) => Promise<SimResult[]>;
+  runAllScenarios: (onProgress?: (done: number, total: number) => void, alpha?: number) => Promise<SimResult[]>;
   allScenarios: () => Scenario[];
   addResult: (r: SimResult) => void;
   clearResults: () => void;
@@ -90,7 +90,7 @@ export function AppProvider(props: { children: JSX.Element }) {
       return [...builtin, ...user];
     },
 
-    async runAllScenarios(onProgress?: (done: number, total: number) => void) {
+    async runAllScenarios(onProgress?: (done: number, total: number) => void, alpha: number = 1) {
       setState("batchResults", []);
 
       const scenarios = store.allScenarios();
@@ -116,6 +116,7 @@ export function AppProvider(props: { children: JSX.Element }) {
           }
           onProgress?.(done, total);
         },
+        alpha,
       );
 
       return state.batchResults;

TheGreenEpochWeb/src/domain/result.ts

@@ -20,8 +20,15 @@ export function computeSavingsPct(
     : 0;
 }
 
-export function computeScore(savingsPct: number, overheadPct: number): number {
-  return savingsPct / Math.max(overheadPct, 0.001);
+export function computeScore(
+  savingsPct: number,
+  overheadPct: number,
+  budgetPct: number,
+  alpha: number = 1,
+): number {
+  const savingsNorm = savingsPct / 100;
+  const overheadNorm = overheadPct / Math.max(budgetPct, 0.001);
+  return alpha * savingsNorm - (1 - alpha) * overheadNorm;
 }
 
 export function computeIsOk(
@@ -53,14 +60,15 @@ export function buildSimResult(
     emissionsSeries: number[];
     tokensRemainingSeries: number[];
   },
+  alpha: number = 1,
 ): SimResult {
   const tps = tokensPerSecond(profile.gpuCount) || 1;
   const overheadS = lastProgress.pausedS + lastProgress.checkpointS;
   const actualOverheadPct = computeOverheadPct(lastProgress.pausedS, lastProgress.checkpointS, lastProgress.tokensTotal, tps);
   const totalEm = lastProgress.totalEmissionsG / 1000;
   const baselineEm = baselineProgress.totalEmissionsG / 1000;
   const co2SavingsPct = computeSavingsPct(totalEm, baselineEm);
-  const score = computeScore(co2SavingsPct, actualOverheadPct);
+  const score = computeScore(co2SavingsPct, actualOverheadPct, simConfig.overheadBudgetPct, alpha);
   const tokensProcessed = lastProgress.tokensTotal - lastProgress.tokensRemaining;
   const pausedTimeH = lastProgress.pausedS / 3600;
   const checkpointOverheadH = lastProgress.checkpointS / 3600;

TheGreenEpochWeb/src/engine/runall-entry.ts

@@ -9,6 +9,7 @@ interface StartMessage {
   profiles: Record<string, TrainingProfile>;
   co2Cache: Record<string, CO2Timeline>;
   scenarios: Scenario[];
+  alpha: number;
 }
 
 function fullProfile(profile: TrainingProfile, c: Constants): FullProfile {
@@ -33,6 +34,7 @@ function runOnce(
   thetaPause: number,
   thetaResume: number,
   scenario: Scenario,
+  alpha: number = 1,
 ): SimResult {
   const baseline: import("../domain/types").SimProgress[] = [];
   for (const p of simulateStepwise(profile, neverPausePolicy(), timeline, config)) {
@@ -67,12 +69,12 @@ function runOnce(
     stateSeries,
     emissionsSeries,
     tokensRemainingSeries,
-  });
+  }, alpha);
 }
 
 self.onmessage = (e: MessageEvent<StartMessage>) => {
   if (e.data.type !== "start") return;
-  const { constants, profiles, co2Cache, scenarios } = e.data;
+  const { constants, profiles, co2Cache, scenarios, alpha } = e.data;
 
   const totalRuns = scenarios.reduce((s, sc) => s + sc.thresholds.length * sc.startTimes.length, 0);
   let done = 0;
@@ -99,7 +101,7 @@ self.onmessage = (e: MessageEvent<StartMessage>) => {
         const thetaResume = scenario.hysteresis[ti];
         const config = simConfig(scenario, startTime, scenario.overheadBudgetPct);
 
-        const result = runOnce(fp, timeline, config, thetaPause, thetaResume, scenario);
+        const result = runOnce(fp, timeline, config, thetaPause, thetaResume, scenario, alpha);
         done++;
 
         (self as any).postMessage({ type: "result", result, done, total: totalRuns });

TheGreenEpochWeb/src/engine/runall.ts

@@ -10,6 +10,7 @@ export function runAllInWorker(
   co2Cache: Record<string, CO2Timeline>,
   scenarios: Scenario[],
   onResult: (result: SimResult, done: number, total: number) => void,
+  alpha: number = 1,
 ): Promise<void> {
   return new Promise((resolve, reject) => {
     const worker = new Worker(new URL("./runall-entry", import.meta.url), { type: "module" });
@@ -37,6 +38,7 @@ export function runAllInWorker(
       profiles: stripProxies(profiles),
       co2Cache: stripProxies(co2Cache),
       scenarios: stripProxies(scenarios),
+      alpha,
     });
   });
 }

TheGreenEpochWeb/src/engine/worker-entry.ts

@@ -16,6 +16,7 @@ interface StartMessage {
     maxIterations: number;
     minStep: number;
     shrinkFactor: number;
+    alpha: number;
   };
   startTimeIdx: number;
 }
@@ -62,12 +63,14 @@ self.onmessage = (e: MessageEvent<StartMessage>) => {
       const baselineEm = baselineLast.totalEmissionsG / 1000;
       const co2SavingsPct = baselineEm > 0 ? (baselineEm - totalEm) / baselineEm * 100 : 0;
 
+      const savingsNorm = co2SavingsPct / 100;
+      const overheadNorm = actualOverheadPct / Math.max(options.overheadBudgetPct, 0.001);
       iterPoints.push({
         thetaPause: pt.thetaPause,
         thetaResume: pt.thetaResume,
         actualOverheadPct,
         co2SavingsPct,
-        score: co2SavingsPct / Math.max(actualOverheadPct, 0.001),
+        score: options.alpha * savingsNorm - (1 - options.alpha) * overheadNorm,
         numPauses: last.numPauses,
         totalEmissionsKgco2: totalEm,
         baselineEmissionsKgco2: baselineEm,

TheGreenEpochWeb/src/engine/worker.ts

@@ -7,6 +7,7 @@ export interface AdaptiveOptions {
   maxIterations: number;
   minStep: number;
   shrinkFactor: number;
+  alpha: number;
 }
 
 /**

TheGreenEpochWeb/src/pages/LiveSimPage.tsx

@@ -35,6 +35,7 @@ export function LiveSimPage() {
   const [scrollMode, setScrollMode] = createSignal(true);
   const [windowSize, setWindowSize] = createSignal(300);
   const [simResult, setSimResult] = createSignal<SimResult | null>(null);
+  const [alpha, setAlpha] = createSignal(1);
 
   let cancelFlag = false;
 
@@ -134,7 +135,7 @@ export function LiveSimPage() {
           setTokensRemainingSeries(tokensRemainingArr.slice());
           setRunning(false);
           setFinished(true);
-          const result = saveResult(lastProgress, labels, co2PointsArr, stateArr, emissionsArr, tokensRemainingArr, full, sc, thresholdIdx(), startIdx(), tl, app);
+          const result = saveResult(lastProgress, labels, co2PointsArr, stateArr, emissionsArr, tokensRemainingArr, full, sc, thresholdIdx(), startIdx(), tl, app, alpha());
           if (result) setSimResult(result);
         }
       };
@@ -206,6 +207,16 @@ export function LiveSimPage() {
             <span class="text-xs text-fg-muted w-8 tabular-nums">{windowSize()}</span>
           </Show>
 
+          <div class="flex items-center gap-1.5">
+            <label class="text-xs text-fg-muted whitespace-nowrap">{"\u03B1"} (CO₂ weight):</label>
+            <input
+              type="number" value={alpha()}
+              onInput={e => setAlpha(+e.currentTarget.value || 0)}
+              step="0.1" min="0" max="1"
+              class="w-16 bg-surface-2 border border-border-default/50 rounded px-2 py-1.5 text-sm text-fg-body tabular-nums focus:outline-none focus:border-accent"
+            />
+          </div>
+
           <button
             onClick={runSim}
             disabled={running()}
@@ -384,6 +395,7 @@ function saveResult(
   lastP: SimProgress, allLabels: string[], allCo2: number[], allStates: string[], allEmissions: number[], allTokensRemaining: number[],
   full: FullProfile, sc: Scenario, ti: number, si: number, tl: CO2Timeline,
   app: ReturnType<typeof useApp>,
+  alpha: number = 1,
 ): SimResult | null {
   try {
     const simConfig: SimConfig = {
@@ -409,7 +421,7 @@ function saveResult(
       stateSeries: allStates,
       emissionsSeries: allEmissions,
       tokensRemainingSeries: allTokensRemaining,
-    });
+    }, alpha);
     app.addResult(result);
     return result;
   } catch (e) {

TheGreenEpochWeb/src/pages/OptimizePage.tsx

@@ -90,6 +90,7 @@ export function OptimizePage() {
   const [tpMax, setTpMax] = createSignal(500);
   const [resolution, setResolution] = createSignal(10);
   const [budget, setBudget] = createSignal(200);
+  const [alpha, setAlpha] = createSignal(1);
   const [running, setRunning] = createSignal(false);
   const [iterMsg, setIterMsg] = createSignal("");
   const [points, setPoints] = createSignal<SweepPoint[]>([]);
@@ -201,6 +202,7 @@ export function OptimizePage() {
           maxIterations: 6,
           minStep: 3,
           shrinkFactor: 0.45,
+          alpha: alpha(),
         },
         0,
         (iter, iterPts, best) => {
@@ -346,6 +348,16 @@ export function OptimizePage() {
               class="w-full bg-surface-3 border border-border-default/50 rounded px-3 py-2 text-sm text-fg-body focus:outline-none focus:border-accent"
             />
           </div>
+
+          <div>
+            <label class="block text-xs font-medium text-fg-muted mb-1">{"\u03B1"} (CO₂ weight)</label>
+            <input
+              type="number" value={alpha()}
+              onInput={e => setAlpha(+e.currentTarget.value || 0)}
+              step="0.1" min="0" max="1"
+              class="w-full bg-surface-3 border border-border-default/50 rounded px-3 py-2 text-sm text-fg-body focus:outline-none focus:border-accent"
+            />
+          </div>
         </div>
 
         <div class="flex items-center gap-3">