popov/gogo2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ui state, models toggle

Browse Source
This commit is contained in:
Dobromir Popov
2025-07-28 23:49:47 +03:00
parent a341fade80
commit 548c0d5e0f
3 changed files with 411 additions and 231 deletions
Download Patch File Download Diff File Expand all files Collapse all files

205
web/clean_dashboard.py
View File

@ -1137,6 +1137,19 @@ class CleanTradingDashboard:
[Input('slow-interval-component', 'n_intervals')] # OPTIMIZED: Move to 10s interval
)
def update_training_metrics(n):
# Get toggle states from orchestrator
toggle_states = {}
if self.orchestrator:
for model_name in ["dqn", "cnn", "cob_rl", "decision_fusion"]:
toggle_states[model_name] = self.orchestrator.get_model_toggle_state(model_name)
else:
# Fallback to dashboard state
toggle_states = {
"dqn": {"inference_enabled": self.dqn_inference_enabled, "training_enabled": self.dqn_training_enabled},
"cnn": {"inference_enabled": self.cnn_inference_enabled, "training_enabled": self.cnn_training_enabled},
"cob_rl": {"inference_enabled": True, "training_enabled": True},
"decision_fusion": {"inference_enabled": True, "training_enabled": True}
}
"""Update training metrics"""
try:
# Now using slow-interval-component (10s) - no batching needed
@ -1295,6 +1308,93 @@ class CleanTradingDashboard:
[Input('cold-start-switch', 'value')]
)
def update_cold_start(switch_value):
if switch_value:
self.cold_start_enabled = True
return "Cold Start: ON", "badge bg-success"
else:
self.cold_start_enabled = False
return "Cold Start: OFF", "badge bg-secondary"
# Model toggle callbacks
@self.app.callback(
Output('dqn-inference-toggle', 'value'),
[Input('dqn-inference-toggle', 'value')],
prevent_initial_call=True
)
def update_dqn_inference_toggle(value):
if self.orchestrator:
self.orchestrator.set_model_toggle_state("dqn", inference_enabled=value)
return value
@self.app.callback(
Output('dqn-training-toggle', 'value'),
[Input('dqn-training-toggle', 'value')],
prevent_initial_call=True
)
def update_dqn_training_toggle(value):
if self.orchestrator:
self.orchestrator.set_model_toggle_state("dqn", training_enabled=value)
return value
@self.app.callback(
Output('cnn-inference-toggle', 'value'),
[Input('cnn-inference-toggle', 'value')],
prevent_initial_call=True
)
def update_cnn_inference_toggle(value):
if self.orchestrator:
self.orchestrator.set_model_toggle_state("cnn", inference_enabled=value)
return value
@self.app.callback(
Output('cnn-training-toggle', 'value'),
[Input('cnn-training-toggle', 'value')],
prevent_initial_call=True
)
def update_cnn_training_toggle(value):
if self.orchestrator:
self.orchestrator.set_model_toggle_state("cnn", training_enabled=value)
return value
@self.app.callback(
Output('cob-rl-inference-toggle', 'value'),
[Input('cob-rl-inference-toggle', 'value')],
prevent_initial_call=True
)
def update_cob_rl_inference_toggle(value):
if self.orchestrator:
self.orchestrator.set_model_toggle_state("cob_rl", inference_enabled=value)
return value
@self.app.callback(
Output('cob-rl-training-toggle', 'value'),
[Input('cob-rl-training-toggle', 'value')],
prevent_initial_call=True
)
def update_cob_rl_training_toggle(value):
if self.orchestrator:
self.orchestrator.set_model_toggle_state("cob_rl", training_enabled=value)
return value
@self.app.callback(
Output('decision-fusion-inference-toggle', 'value'),
[Input('decision-fusion-inference-toggle', 'value')],
prevent_initial_call=True
)
def update_decision_fusion_inference_toggle(value):
if self.orchestrator:
self.orchestrator.set_model_toggle_state("decision_fusion", inference_enabled=value)
return value
@self.app.callback(
Output('decision-fusion-training-toggle', 'value'),
[Input('decision-fusion-training-toggle', 'value')],
prevent_initial_call=True
)
def update_decision_fusion_training_toggle(value):
if self.orchestrator:
self.orchestrator.set_model_toggle_state("decision_fusion", training_enabled=value)
return value
"""Update cold start training mode"""
logger.debug(f"Cold start callback triggered with value: {switch_value}")
try:
@ -3285,8 +3385,9 @@ class CleanTradingDashboard:
dqn_timing = get_model_timing_info('DQN')
# SEPARATE TOGGLES: Inference and Training can be controlled independently
dqn_inference_enabled = getattr(self, 'dqn_inference_enabled', True) # Default: enabled
dqn_training_enabled = getattr(self, 'dqn_training_enabled', True) # Default: enabled
dqn_toggle_state = toggle_states.get('dqn', {"inference_enabled": True, "training_enabled": True})
dqn_inference_enabled = dqn_toggle_state.get("inference_enabled", True)
dqn_training_enabled = dqn_toggle_state.get("training_enabled", True)
dqn_checkpoint_loaded = dqn_state.get('checkpoint_loaded', False)
# DQN is active if checkpoint is loaded AND inference is enabled AND orchestrator has the model
@ -3366,7 +3467,16 @@ class CleanTradingDashboard:
'average_training_time_ms': f"{dqn_timing.get('average_training_time_ms', 0):.1f}"
},
# NEW: Performance metrics for split-second decisions
'performance': self.get_model_performance_metrics().get('dqn', {})
'performance': self.get_model_performance_metrics().get('dqn', {}),
# ENHANCED: Add toggle state information
'inference_enabled': dqn_inference_enabled,
'training_enabled': dqn_training_enabled,
'status_details': {
'checkpoint_loaded': dqn_checkpoint_loaded,
'inference_enabled': dqn_inference_enabled,
'training_enabled': dqn_training_enabled,
'is_training': dqn_training_status['is_training']
}
}
loaded_models['dqn'] = dqn_model_info
@ -3392,6 +3502,11 @@ class CleanTradingDashboard:
except:
cnn_predicted_price = 0
# Get CNN toggle states
cnn_toggle_state = toggle_states.get('cnn', {"inference_enabled": True, "training_enabled": True})
cnn_inference_enabled = cnn_toggle_state.get("inference_enabled", True)
cnn_training_enabled = cnn_toggle_state.get("training_enabled", True)
cnn_model_info = {
'active': cnn_active,
'parameters': 50000000, # ~50M params
@ -3443,7 +3558,16 @@ class CleanTradingDashboard:
'average_training_time_ms': f"{cnn_timing.get('average_training_time_ms', 0):.1f}"
},
# NEW: Performance metrics for split-second decisions
'performance': self.get_model_performance_metrics().get('cnn', {})
'performance': self.get_model_performance_metrics().get('cnn', {}),
# ENHANCED: Add toggle state information
'inference_enabled': cnn_inference_enabled,
'training_enabled': cnn_training_enabled,
'status_details': {
'checkpoint_loaded': cnn_state.get('checkpoint_loaded', False),
'inference_enabled': cnn_inference_enabled,
'training_enabled': cnn_training_enabled,
'is_training': cnn_panel_data.get('is_training', False)
}
}
loaded_models['cnn'] = cnn_model_info
@ -3566,6 +3690,11 @@ class CleanTradingDashboard:
cob_active = True
cob_predictions_count = len(self.recent_decisions) * 2
# Get COB RL toggle states
cob_toggle_state = toggle_states.get('cob_rl', {"inference_enabled": True, "training_enabled": True})
cob_inference_enabled = cob_toggle_state.get("inference_enabled", True)
cob_training_enabled = cob_toggle_state.get("training_enabled", True)
cob_model_info = {
'active': cob_active,
'parameters': 400000000, # 400M optimized
@ -3594,7 +3723,16 @@ class CleanTradingDashboard:
'predictions_24h': cob_timing['prediction_count_24h']
},
# NEW: Performance metrics for split-second decisions
'performance': self.get_model_performance_metrics().get('cob_rl', {})
'performance': self.get_model_performance_metrics().get('cob_rl', {}),
# ENHANCED: Add toggle state information
'inference_enabled': cob_inference_enabled,
'training_enabled': cob_training_enabled,
'status_details': {
'checkpoint_loaded': cob_state.get('checkpoint_loaded', False),
'inference_enabled': cob_inference_enabled,
'training_enabled': cob_training_enabled,
'is_training': False # COB RL training status
}
}
loaded_models['cob_rl'] = cob_model_info
@ -3603,21 +3741,42 @@ class CleanTradingDashboard:
decision_timing = get_model_timing_info('DECISION')
decision_active = signal_generation_active
# Get Decision Fusion toggle states
decision_toggle_state = toggle_states.get('decision_fusion', {"inference_enabled": True, "training_enabled": True})
decision_inference_enabled = decision_toggle_state.get("inference_enabled", True)
decision_training_enabled = decision_toggle_state.get("training_enabled", True)
# Get real decision fusion statistics from orchestrator
decision_stats = None
if self.orchestrator and hasattr(self.orchestrator, 'model_statistics'):
decision_stats = self.orchestrator.model_statistics.get('decision_fusion')
# Get real last prediction
last_prediction = 'HOLD'
last_confidence = 0.0
last_timestamp = datetime.now().strftime('%H:%M:%S')
if decision_stats and decision_stats.last_prediction:
last_prediction = decision_stats.last_prediction
last_confidence = decision_stats.last_confidence or 0.0
if decision_stats.last_inference_time:
last_timestamp = decision_stats.last_inference_time.strftime('%H:%M:%S')
decision_model_info = {
'active': decision_active,
'parameters': 10000000, # ~10M params for decision model
'last_prediction': {
'timestamp': datetime.now().strftime('%H:%M:%S'),
'action': 'DECISION_MAKING',
'confidence': 0.78
'timestamp': last_timestamp,
'action': last_prediction,
'confidence': last_confidence
},
'loss_5ma': decision_state.get('current_loss', 0.0089),
'initial_loss': decision_state.get('initial_loss'),
'best_loss': decision_state.get('best_loss', 0.0065),
'loss_5ma': decision_stats.current_loss if decision_stats else 0.0,
'initial_loss': decision_stats.best_loss if decision_stats else 0.0,
'best_loss': decision_stats.best_loss if decision_stats else 0.0,
'improvement': safe_improvement_calc(
decision_state.get('initial_loss'),
decision_state.get('current_loss', 0.0089),
97.0 # Default improvement percentage
decision_stats.best_loss if decision_stats else 0.0,
decision_stats.current_loss if decision_stats else 0.0,
0.0 # Calculate real improvement
),
'checkpoint_loaded': decision_state.get('checkpoint_loaded', False),
'model_type': 'DECISION',
@ -3637,7 +3796,16 @@ class CleanTradingDashboard:
'predictions_24h': decision_timing['prediction_count_24h']
},
# NEW: Performance metrics for split-second decisions
'performance': self.get_model_performance_metrics().get('decision', {})
'performance': self.get_model_performance_metrics().get('decision', {}),
# ENHANCED: Add toggle state information
'inference_enabled': decision_inference_enabled,
'training_enabled': decision_training_enabled,
'status_details': {
'checkpoint_loaded': decision_state.get('checkpoint_loaded', False),
'inference_enabled': decision_inference_enabled,
'training_enabled': decision_training_enabled,
'is_training': False # Decision fusion training status
}
}
loaded_models['decision'] = decision_model_info
@ -7972,9 +8140,12 @@ class CleanTradingDashboard:
else:
direction = 'HOLD'
agressiveness_threshold = self.agressiveness_enter if direction == 'ENTER' else self.agressiveness_exit
# Calculate aggressiveness threshold: higher aggressiveness = lower threshold (more trades)
aggressiveness = self.orchestrator.entry_aggressiveness if direction == 'ENTER' else self.orchestrator.exit_aggressiveness
# Map aggressiveness (0.0-1.0) to threshold (0.8-0.2): more aggressive = lower threshold
aggressiveness_threshold = 0.8 - (0.6 * aggressiveness)
# compare confidence with current aggressiveness
if self.trading_executor and confidence > agressiveness_threshold:
if self.trading_executor and confidence > aggressiveness_threshold:
try:
logger.info(f"[ORCHESTRATOR EXECUTION] Attempting to execute {action} for {symbol} via trading executor...")
success = self.trading_executor.execute_signal(