peterstockings/workout
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Learn session forecasts from training blocks and clarify progress UI

Browse Source
This commit is contained in:
Peter Stockings
2026-09-06 16:20:15 +10:00
parent 499d859478
commit 86fade54f1
13 changed files with 1008 additions and 343 deletions
Download Patch File Download Diff File Expand all files Collapse all files
utils.py
+37 -138
View File
@@ -1,7 +1,8 @@
import colorsys
from datetime import datetime, date, timedelta
from flask import request
import numpy as np
import numpy as np
from forecasting import build_forecast
import math
@@ -16,7 +17,7 @@ def _format_kg(value):
numeric_value = float(value)
if numeric_value.is_integer():
return str(int(numeric_value))
return f"{numeric_value:.1f}".rstrip('0').rstrip('.')
return f"{numeric_value:.2f}".rstrip('0').rstrip('.')
def convert_str_to_date(date_str, format='%Y-%m-%d'):
try:
@@ -26,122 +27,6 @@ def convert_str_to_date(date_str, format='%Y-%m-%d'):
except TypeError:
return None
def build_forecast(values, dates, horizon_weeks=8, metric='E1RM'):
"""Build a conservative linear forecast from dated exercise observations."""
try:
horizon_weeks = max(4, min(int(horizon_weeks), 52))
except (TypeError, ValueError):
horizon_weeks = 8
observations = []
for value, point_date in zip(values, dates):
if value is None or point_date is None:
continue
try:
numeric_value = float(value)
except (TypeError, ValueError):
continue
if isinstance(point_date, datetime):
point_date = point_date.date()
observations.append((point_date, numeric_value))
# Multiple sets on one date should not make the forecast look more certain.
# Use the best observed value for that date, which matches the E1RM use case.
best_by_date = {}
for point_date, numeric_value in observations:
best_by_date[point_date] = max(best_by_date.get(point_date, numeric_value), numeric_value)
observations = sorted(best_by_date.items())
if len(observations) < 4:
return {
'available': False,
'reason': 'Add at least 4 sessions to generate a forecast.',
'metric': metric,
'horizon_weeks': horizon_weeks,
'observed_points': len(observations)
}
observed_dates = [point_date for point_date, _ in observations]
observed_values = np.array([value for _, value in observations], dtype=float)
first_date = observed_dates[0]
last_date = observed_dates[-1]
x = np.array([(point_date - first_date).days for point_date in observed_dates], dtype=float)
if len(np.unique(x)) < 3 or x[-1] <= 0:
return {
'available': False,
'reason': 'Use at least 3 different workout dates to generate a forecast.',
'metric': metric,
'horizon_weeks': horizon_weeks,
'observed_points': len(observations)
}
try:
slope, intercept = np.polyfit(x, observed_values, 1)
except (np.linalg.LinAlgError, ValueError, TypeError):
return {
'available': False,
'reason': 'There is not enough consistent data to generate a forecast.',
'metric': metric,
'horizon_weeks': horizon_weeks,
'observed_points': len(observations)
}
fitted = intercept + slope * x
residuals = observed_values - fitted
degrees_of_freedom = max(len(observed_values) - 2, 1)
residual_std = float(np.sqrt(np.sum(residuals ** 2) / degrees_of_freedom))
mean_x = float(np.mean(x))
sum_squared_x = float(np.sum((x - mean_x) ** 2)) or 1.0
horizon_days = horizon_weeks * 7
future_x = np.arange(0, horizon_days + 1, 7, dtype=float) + x[-1]
future_dates = [last_date + timedelta(days=int(day - x[-1])) for day in future_x]
# Anchor the projection to the most recent observed value. A pure
# regression line can sit noticeably above or below the latest workout,
# which makes the forecast appear to jump when it starts.
future_values = observed_values[-1] + slope * (future_x - x[-1])
# A restrained 90% prediction band, widened for points further from the
# observations so the uncertainty remains readable on the small chart.
prediction_error = 1.645 * residual_std * np.sqrt(
1 + (1 / len(observed_values)) + ((future_x - mean_x) ** 2 / sum_squared_x)
)
lower_values = np.maximum(future_values - prediction_error, 0)
upper_values = future_values + prediction_error
total_variation = float(np.sum((observed_values - np.mean(observed_values)) ** 2))
residual_variation = float(np.sum(residuals ** 2))
r_squared = None if total_variation == 0 else max(0.0, 1 - residual_variation / total_variation)
weekly_change = float(slope * 7)
confidence = 'High' if len(observed_values) >= 8 and (r_squared is None or r_squared >= 0.6) else 'Moderate'
if len(observed_values) < 6 or (r_squared is not None and r_squared < 0.25):
confidence = 'Low'
points = []
for point_date, predicted, lower, upper in zip(future_dates, future_values, lower_values, upper_values):
points.append({
'date': point_date,
'value': round(float(predicted), 1),
'lower': round(float(lower), 1),
'upper': round(float(upper), 1)
})
return {
'available': True,
'metric': metric,
'horizon_weeks': horizon_weeks,
'observed_points': len(observations),
'last_date': last_date,
'last_value': round(float(observed_values[-1]), 1),
'projected_value': round(float(future_values[-1]), 1),
'projected_change': round(float(future_values[-1] - observed_values[-1]), 1),
'weekly_change': round(weekly_change, 1),
'r_squared': None if r_squared is None else round(r_squared, 2),
'confidence': confidence,
'end_date': future_dates[-1],
'points': points
}
def infer_weight_increment(weights):
"""Infer a sensible display increment from the exercise's recorded weights."""
numeric_weights = sorted({round(float(weight), 4) for weight in weights if weight is not None})
@@ -180,7 +65,7 @@ def infer_rep_targets(repetitions, buffer=5):
observed_min = min(numeric_reps)
observed_max = max(numeric_reps)
target_min = max(1, observed_min - buffer)
target_min = min(20, max(1, observed_min - buffer))
target_max = min(20, observed_max + buffer)
target_reps = list(range(target_min, target_max + 1))
# Default to the latest recorded rep target so the first forecast comparison
@@ -225,7 +110,7 @@ def add_top_set_forecast(forecast, historical_weights, historical_repetitions, t
except (TypeError, ValueError):
selected_reps = centered_reps
selected_reps = max(target_reps_list[0], min(target_reps_list[-1], selected_reps))
increment = infer_weight_increment(historical_weights)
increment = forecast.get('profile', {}).get('increment') or infer_weight_increment(historical_weights)
for point in forecast['points']:
point['top_sets'] = _top_set_estimates(
point['value'], point['lower'], point['upper'], target_reps_list, increment
@@ -246,11 +131,17 @@ def add_top_set_forecast(forecast, historical_weights, historical_repetitions, t
return forecast
def get_exercise_graph_model(title, estimated_1rm, repetitions, weight, start_dates, messages, epoch, person_id, exercise_id, min_date=None, max_date=None, degree=1, forecast_enabled=False, forecast_weeks=8, forecast_target_reps=None):
def get_exercise_graph_model(title, estimated_1rm, repetitions, weight, start_dates, messages, epoch, person_id, exercise_id, min_date=None, max_date=None, degree=1, forecast_enabled=False, forecast_weeks=8, forecast_target_reps=None, forecast_training_rows=None):
# Precompute ranges. Forecast values are included so the projected line and
# confidence band have room inside the same SVG coordinate system.
observed_min_date, observed_max_date = min(start_dates), max(start_dates)
forecast = build_forecast(estimated_1rm, start_dates, forecast_weeks, metric='E1RM') if forecast_enabled else {'available': False}
if forecast_training_rows is None:
forecast_training_rows = [dict(start_date=d, weight=w, repetitions=r) for d, w, r in zip(start_dates, weight, repetitions)]
forecast = build_forecast(
[], [r['start_date'] for r in forecast_training_rows], forecast_weeks,
weights=[r['weight'] for r in forecast_training_rows],
repetitions=[r['repetitions'] for r in forecast_training_rows]
) if forecast_enabled else {'available': False}
forecast = add_top_set_forecast(forecast, weight, repetitions, forecast_target_reps)
forecast_horizons = [(4, '4w'), (8, '8w'), (12, '3m'), (26, '6m'), (52, '1y')]
chart_max_date = forecast.get('end_date', observed_max_date) if forecast.get('available') else observed_max_date
@@ -356,33 +247,28 @@ def get_exercise_graph_model(title, estimated_1rm, repetitions, weight, start_da
forecast_points.append((round(((point['value'] - min_e1rm) / e1rm_range) * vb_height, 1), position))
forecast_band_lower.append((round(((point['lower'] - min_e1rm) / e1rm_range) * vb_height, 1), position))
forecast_band_upper.append((round(((point['upper'] - min_e1rm) / e1rm_range) * vb_height, 1), position))
selected_top_set = next(
(top_set for top_set in point['top_sets'] if top_set['repetitions'] == forecast['selected_reps']),
None
)
selected_top_set = point
if point_index == 0:
top_set_message = f" · Recorded {_format_kg(weight[-1])}kg × {int(repetitions[-1])}"
top_set_message = f" · Recorded {point['set_display']}"
forecast_details.append({
'position': position,
'date': point['date'].strftime('%d %b %y'),
'kind': 'Current reading',
'e1rm': f"{_format_kg(forecast['last_value'])}kg",
'top_set': f"{_format_kg(weight[-1])}kg × {int(repetitions[-1])} reps",
'top_set': point['set_display'],
'range': 'Observed value'
})
elif selected_top_set:
top_set_message = (
f" · Est. {selected_top_set['weight_display']}kg × {selected_top_set['repetitions']} "
f"(range {selected_top_set['lower_weight_display']}–{selected_top_set['upper_weight_display']}kg)"
f" · Scenario {point['set_display']}"
)
forecast_details.append({
'position': position,
'date': point['date'].strftime('%d %b %y'),
'kind': 'Projected top set',
'kind': 'Workout scenario' if point['date'] < forecast['end_date'] else 'Horizon scenario',
'e1rm': f"{_format_kg(point['value'])}kg",
'top_set': f"{selected_top_set['weight_display']}kg × {selected_top_set['repetitions']} reps",
'range': f"{selected_top_set['lower_weight_display']}–{selected_top_set['upper_weight_display']}kg",
'confidence': forecast['confidence']
'top_set': point['set_display'],
'range': f"{_format_kg(point['lower'])}–{_format_kg(point['upper'])}kg E1RM",
})
forecast_labels.append((
position,
@@ -390,11 +276,22 @@ def get_exercise_graph_model(title, estimated_1rm, repetitions, weight, start_da
f"(range {point['lower']}–{point['upper']}kg){top_set_message}"
))
# Return exercise data with SVG dimensions and data points
# Non-overlapping nearest-date targets; no late forecast rectangle can
# cover an earlier date when a year is compressed into a small chart.
hover_by_position = {}
for detail in plot_details + forecast_details:
hover_by_position[detail['position']] = detail
hover_details = sorted(hover_by_position.values(), key=lambda d: d['position'])
for i, detail in enumerate(hover_details):
detail['hit_start'] = 0 if i == 0 else (hover_details[i-1]['position'] + detail['position']) / 2
detail['hit_end'] = 1 if i == len(hover_details)-1 else (hover_details[i+1]['position'] + detail['position']) / 2
# Return exercise data with SVG dimensions and data points
return {
'title': title,
'vb_width': vb_width,
'vb_height': vb_height,
'vb_height': vb_height,
'e1rm_scale': [_format_kg(round(max_e1rm, 1)), _format_kg(round((max_e1rm + min_e1rm) / 2, 1)), _format_kg(round(min_e1rm, 1))],
'plots': [repetitions_data, weight_data, estimated_1rm_data],
'best_fit_points': best_fit_points,
'best_fit_formula': best_fit_formula,
@@ -410,14 +307,16 @@ def get_exercise_graph_model(title, estimated_1rm, repetitions, weight, start_da
'forecast': forecast,
'forecast_enabled': forecast_enabled,
'forecast_weeks': forecast_weeks,
'forecast_target_reps': forecast.get('selected_reps', forecast_target_reps or 5),
'forecast_target_reps': forecast_target_reps,
'forecast_horizons': forecast_horizons,
'forecast_points': forecast_points,
'forecast_band_lower': forecast_band_lower,
'forecast_band_upper': forecast_band_upper,
'forecast_labels': forecast_labels,
'forecast_details': forecast_details,
'forecast_start_position': forecast_start_position
'forecast_start_position': forecast_start_position,
'hover_details': hover_details,
'default_detail': forecast_details[0] if forecast_details else plot_details[-1],
}
def get_distinct_colors(n):