optim

src/utils/metricAcwr.ts

@@ -11,8 +11,8 @@ function formatDateLocal(date: Date): string {
 }
 
 /**
- * Calculate optimal activity values for the next 7 days to reach and maintain target ACWR
- * Uses a greedy algorithm that optimizes each day to get closer to target ACWR
+ * Calculate optimal activity values for the next 7 days to minimize MSE between ACWR and target
+ * Uses optimization to find values that maintain ACWR close to target across all predicted days
  * @param allDates - Array of all historical dates
  * @param dailyValues - Map of date strings to activity values
  * @param targetACWR - Target ACWR to achieve
@@ -32,93 +32,197 @@ function calculateOptimalFutureDays(
     futureAverage28d: number[];
     futureAcwr: number[];
 } {
-    const futureDates: string[] = [];
-    const futureValues: number[] = [];
-    const futureAverage7d: number[] = [];
-    const futureAverage28d: number[] = [];
-    const futureAcwr: number[] = [];
+    // Variance weight parameter (0-1): controls trade-off between ACWR accuracy and value consistency
+    // Higher weight = more preference for consistent daily values
+    const varianceWeight = 0.5;
+
+    // Helper function to calculate variance of predicted values
+    const calculateVariance = (values: number[]): number => {
+        if (values.length === 0) return 0;
+        const mean = values.reduce((sum, v) => sum + v, 0) / values.length;
+        const variance = values.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / values.length;
+        return variance;
+    };
+
+    // Helper function to simulate predictions and calculate error (MSE + variance penalty)
+    const simulateAndCalculateError = (values: number[]): { error: number; acwrValues: number[]; variance: number } => {
+        const simulatedDailyValues = new Map(dailyValues);
+        const simulatedAllDates = [...allDates];
+        const lastDate = new Date(allDates[allDates.length - 1]);
+        const acwrValues: number[] = [];
+
+        for (let dayOffset = 0; dayOffset < numFutureDays; dayOffset++) {
+            const futureDate = new Date(lastDate);
+            futureDate.setDate(lastDate.getDate() + 1 + startOffset + dayOffset);
+            const futureDateStr = formatDateLocal(futureDate);
+
+            simulatedDailyValues.set(futureDateStr, values[dayOffset]);
+            simulatedAllDates.push(futureDate);
+
+            const currentIndex = simulatedAllDates.length - 1;
+
+            // Calculate 7-day average
+            let acuteSum = 0;
+            for (let i = Math.max(0, currentIndex - 6); i <= currentIndex; i++) {
+                const checkDateStr = formatDateLocal(simulatedAllDates[i]);
+                acuteSum += simulatedDailyValues.get(checkDateStr) || 0;
+            }
+            const acuteAvg = acuteSum / 7;
+
+            // Calculate 28-day average
+            let chronicSum = 0;
+            for (let i = Math.max(0, currentIndex - 27); i <= currentIndex; i++) {
+                const checkDateStr = formatDateLocal(simulatedAllDates[i]);
+                chronicSum += simulatedDailyValues.get(checkDateStr) || 0;
+            }
+            const chronicAvg = chronicSum / 28;
+
+            const acwr = chronicAvg > 0 ? acuteAvg / chronicAvg : 0;
+            acwrValues.push(acwr);
+        }
 
-    // Create a mutable copy of daily values to simulate future
+        // Calculate MSE for ACWR
+        let mse = 0;
+        for (const acwr of acwrValues) {
+            const diff = acwr - targetACWR;
+            mse += diff * diff;
+        }
+        mse /= numFutureDays;
+
+        // Calculate variance of predicted values
+        const variance = calculateVariance(values);
+
+        // Normalize variance by mean to make it scale-independent
+        const mean = values.reduce((sum, v) => sum + v, 0) / values.length;
+        const normalizedVariance = mean > 0 ? variance / (mean * mean) : 0;
+
+        // Combined error: MSE + weighted variance penalty
+        const error = mse + varianceWeight * normalizedVariance;
+
+        return { error, acwrValues, variance };
+    };
+
+    // Initialize with greedy solution as starting point
+    const initialValues: number[] = [];
     const simulatedDailyValues = new Map(dailyValues);
     const simulatedAllDates = [...allDates];
-
-    // Get the last date in the data
     const lastDate = new Date(allDates[allDates.length - 1]);
 
     for (let dayOffset = 0; dayOffset < numFutureDays; dayOffset++) {
         const futureDate = new Date(lastDate);
-        // Add 1 + startOffset + dayOffset to go beyond lastDate
-        // startOffset=0: start from day after lastDate (tomorrow if lastDate is today)
-        // startOffset=1: skip one day, start from 2 days after lastDate
         futureDate.setDate(lastDate.getDate() + 1 + startOffset + dayOffset);
         const futureDateStr = formatDateLocal(futureDate);
 
-        futureDates.push(futureDateStr);
         simulatedAllDates.push(futureDate);
-
         const currentIndex = simulatedAllDates.length - 1;
 
-        // Calculate what the 7-day sum would be (last 6 days + today)
+        // Calculate sums for greedy solution
         let acuteSum = 0;
         for (let i = Math.max(0, currentIndex - 6); i < currentIndex; i++) {
             const checkDateStr = formatDateLocal(simulatedAllDates[i]);
             acuteSum += simulatedDailyValues.get(checkDateStr) || 0;
         }
 
-        // Calculate what the 28-day sum would be (last 27 days + today)
         let chronicSum = 0;
         for (let i = Math.max(0, currentIndex - 27); i < currentIndex; i++) {
             const checkDateStr = formatDateLocal(simulatedAllDates[i]);
             chronicSum += simulatedDailyValues.get(checkDateStr) || 0;
         }
 
-        // Calculate optimal value for today using the formula:
-        // targetACWR = [(acuteSum + X) / 7] / [(chronicSum + X) / 28]
-        // Solving for X:
-        // X = (4 * acuteSum - targetACWR * chronicSum) / (targetACWR - 4)
-
+        // Greedy optimal value
         const numerator = 4 * acuteSum - targetACWR * chronicSum;
         const denominator = targetACWR - 4;
-
         let optimalValue = 0;
 
         if (Math.abs(denominator) > 0.001) {
             optimalValue = numerator / denominator;
-
-            // Ensure non-negative values (can't have negative activity)
-            if (optimalValue < 0) {
-                optimalValue = 0;
-            }
+            if (optimalValue < 0) optimalValue = 0;
         } else {
-            // Special case: when targetACWR ≈ 4, we need a different approach
-            // In this case, set to average of recent values to maintain stability
-            const recentSum = acuteSum;
-            optimalValue = recentSum / 7;
+            optimalValue = acuteSum / 7;
         }
 
-        // Store the optimal value for this future day
-        futureValues.push(optimalValue);
+        initialValues.push(optimalValue);
         simulatedDailyValues.set(futureDateStr, optimalValue);
+    }
 
-        // Calculate the resulting 7-day average (acute load)
+    // Iterative refinement to minimize error (MSE + variance penalty)
+    let bestValues = [...initialValues];
+    let bestError = simulateAndCalculateError(bestValues).error;
+
+    // Simple gradient descent-like optimization
+    const iterations = 50;
+    const learningRate = 0.3;
+
+    for (let iter = 0; iter < iterations; iter++) {
+        const currentResult = simulateAndCalculateError(bestValues);
+
+        // Try adjusting each day's value
+        for (let dayIdx = 0; dayIdx < numFutureDays; dayIdx++) {
+            const originalValue = bestValues[dayIdx];
+
+            // Calculate gradient by finite difference
+            const delta = Math.max(1, originalValue * 0.1);
+            const testValues = [...bestValues];
+            testValues[dayIdx] = originalValue + delta;
+            const upResult = simulateAndCalculateError(testValues);
+
+            const gradient = (upResult.error - currentResult.error) / delta;
+
+            // Update value using gradient
+            let newValue = originalValue - learningRate * gradient * originalValue;
+            newValue = Math.max(0, newValue); // Ensure non-negative
+
+            // Test if this improves error
+            testValues[dayIdx] = newValue;
+            const newResult = simulateAndCalculateError(testValues);
+
+            if (newResult.error < bestError) {
+                bestValues[dayIdx] = newValue;
+                bestError = newResult.error;
+            }
+        }
+    }
+
+    // Build final results with optimized values
+    const futureDates: string[] = [];
+    const futureValues: number[] = bestValues;
+    const futureAverage7d: number[] = [];
+    const futureAverage28d: number[] = [];
+    const futureAcwr: number[] = [];
+
+    const finalSimulatedDailyValues = new Map(dailyValues);
+    const finalSimulatedAllDates = [...allDates];
+
+    for (let dayOffset = 0; dayOffset < numFutureDays; dayOffset++) {
+        const futureDate = new Date(lastDate);
+        futureDate.setDate(lastDate.getDate() + 1 + startOffset + dayOffset);
+        const futureDateStr = formatDateLocal(futureDate);
+
+        futureDates.push(futureDateStr);
+        finalSimulatedDailyValues.set(futureDateStr, bestValues[dayOffset]);
+        finalSimulatedAllDates.push(futureDate);
+
+        const currentIndex = finalSimulatedAllDates.length - 1;
+
+        // Calculate 7-day average
         let newAcuteSum = 0;
         for (let i = Math.max(0, currentIndex - 6); i <= currentIndex; i++) {
-            const checkDateStr = formatDateLocal(simulatedAllDates[i]);
-            newAcuteSum += simulatedDailyValues.get(checkDateStr) || 0;
+            const checkDateStr = formatDateLocal(finalSimulatedAllDates[i]);
+            newAcuteSum += finalSimulatedDailyValues.get(checkDateStr) || 0;
         }
         const newAcuteAvg = newAcuteSum / 7;
         futureAverage7d.push(newAcuteAvg);
 
-        // Calculate the resulting 28-day average (chronic load)
+        // Calculate 28-day average
         let newChronicSum = 0;
         for (let i = Math.max(0, currentIndex - 27); i <= currentIndex; i++) {
-            const checkDateStr = formatDateLocal(simulatedAllDates[i]);
-            newChronicSum += simulatedDailyValues.get(checkDateStr) || 0;
+            const checkDateStr = formatDateLocal(finalSimulatedAllDates[i]);
+            newChronicSum += finalSimulatedDailyValues.get(checkDateStr) || 0;
         }
         const newChronicAvg = newChronicSum / 28;
         futureAverage28d.push(newChronicAvg);
 
-        // Calculate the resulting ACWR
+        // Calculate ACWR
         const newACWR = newChronicAvg > 0 ? newAcuteAvg / newChronicAvg : 0;
         futureAcwr.push(newACWR);
     }