show dummy references
This commit is contained in:
Dobromir Popov
@@ -143,7 +143,7 @@ class EnhancedCNNModel(nn.Module):
|
||||
def __init__(self,
|
||||
input_size: int = 60,
|
||||
feature_dim: int = 50,
|
||||
output_size: int = 2, # BUY/SELL for 2-action system
|
||||
output_size: int = 5, # OHLCV prediction (Open, High, Low, Close, Volume)
|
||||
base_channels: int = 256, # Increased from 128 to 256
|
||||
num_blocks: int = 12, # Increased from 6 to 12
|
||||
num_attention_heads: int = 16, # Increased from 8 to 16
|
||||
@@ -416,39 +416,40 @@ class EnhancedCNNModel(nn.Module):
|
||||
volatility_pred = self._memory_barrier(self.volatility_predictor(processed_features))
|
||||
confidence = self._memory_barrier(self.confidence_head(processed_features))
|
||||
|
||||
# Combine all features for final decision (8 regime classes + 1 volatility)
|
||||
# Combine all features for OHLCV prediction
|
||||
# Create completely independent tensors for concatenation
|
||||
vol_pred_flat = self._memory_barrier(volatility_pred.reshape(volatility_pred.shape[0], -1)) # Flatten instead of squeeze
|
||||
combined_features = torch.cat([processed_features, regime_probs, vol_pred_flat], dim=1)
|
||||
combined_features = self._memory_barrier(combined_features)
|
||||
|
||||
trading_logits = self._memory_barrier(self.decision_head(combined_features))
|
||||
|
||||
# Apply temperature scaling for better calibration - create new tensor
|
||||
temperature = 1.5
|
||||
scaled_logits = trading_logits / temperature
|
||||
trading_probs = self._memory_barrier(F.softmax(scaled_logits, dim=1))
|
||||
|
||||
# Flatten confidence to ensure consistent shape
|
||||
|
||||
# OHLCV prediction (Open, High, Low, Close, Volume)
|
||||
ohlcv_pred = self._memory_barrier(self.decision_head(combined_features))
|
||||
|
||||
# Generate confidence based on prediction stability
|
||||
confidence_flat = self._memory_barrier(confidence.reshape(confidence.shape[0], -1))
|
||||
volatility_flat = self._memory_barrier(volatility_pred.reshape(volatility_pred.shape[0], -1))
|
||||
|
||||
|
||||
# Calculate prediction confidence based on volatility and regime stability
|
||||
regime_stability = torch.std(regime_probs, dim=1, keepdim=True)
|
||||
prediction_confidence = 1.0 / (1.0 + regime_stability + volatility_flat * 0.1)
|
||||
prediction_confidence = self._memory_barrier(prediction_confidence.squeeze(-1))
|
||||
|
||||
return {
|
||||
'logits': self._memory_barrier(trading_logits),
|
||||
'probabilities': self._memory_barrier(trading_probs),
|
||||
'confidence': confidence_flat[:, 0] if confidence_flat.shape[1] > 0 else confidence_flat.reshape(-1)[0],
|
||||
'ohlcv': self._memory_barrier(ohlcv_pred), # [batch_size, 5] - OHLCV predictions
|
||||
'confidence': prediction_confidence,
|
||||
'regime': self._memory_barrier(regime_probs),
|
||||
'volatility': volatility_flat[:, 0] if volatility_flat.shape[1] > 0 else volatility_flat.reshape(-1)[0],
|
||||
'features': self._memory_barrier(processed_features)
|
||||
'features': self._memory_barrier(processed_features),
|
||||
'regime_stability': self._memory_barrier(regime_stability.squeeze(-1))
|
||||
}
|
||||
|
||||
def predict(self, feature_matrix) -> Dict[str, Any]:
|
||||
"""
|
||||
Make predictions on feature matrix
|
||||
Make OHLCV predictions on feature matrix
|
||||
Args:
|
||||
feature_matrix: tensor or numpy array of shape [sequence_length, features]
|
||||
Returns:
|
||||
Dictionary with prediction results
|
||||
Dictionary with OHLCV prediction results and trading signals
|
||||
"""
|
||||
self.eval()
|
||||
|
||||
@@ -468,17 +469,13 @@ class EnhancedCNNModel(nn.Module):
|
||||
# Forward pass
|
||||
outputs = self.forward(x)
|
||||
|
||||
# Extract results with proper shape handling
|
||||
if HAS_NUMPY:
|
||||
probs = outputs['probabilities'].cpu().numpy()[0]
|
||||
confidence_tensor = outputs['confidence'].cpu().numpy()
|
||||
regime = outputs['regime'].cpu().numpy()[0]
|
||||
volatility = outputs['volatility'].cpu().numpy()
|
||||
else:
|
||||
probs = outputs['probabilities'].cpu().tolist()[0]
|
||||
confidence_tensor = outputs['confidence'].cpu().tolist()
|
||||
regime = outputs['regime'].cpu().tolist()[0]
|
||||
volatility = outputs['volatility'].cpu().tolist()
|
||||
# Extract OHLCV predictions
|
||||
ohlcv_pred = outputs['ohlcv'].cpu().numpy()[0] if HAS_NUMPY else outputs['ohlcv'].cpu().tolist()[0]
|
||||
|
||||
# Extract other outputs
|
||||
confidence_tensor = outputs['confidence'].cpu().numpy() if HAS_NUMPY else outputs['confidence'].cpu().tolist()
|
||||
regime = outputs['regime'].cpu().numpy()[0] if HAS_NUMPY else outputs['regime'].cpu().tolist()[0]
|
||||
volatility = outputs['volatility'].cpu().numpy() if HAS_NUMPY else outputs['volatility'].cpu().tolist()
|
||||
|
||||
# Handle confidence shape properly
|
||||
if HAS_NUMPY and isinstance(confidence_tensor, np.ndarray):
|
||||
@@ -490,7 +487,7 @@ class EnhancedCNNModel(nn.Module):
|
||||
confidence = float(confidence_tensor[0] if len(confidence_tensor) > 0 else 0.7)
|
||||
else:
|
||||
confidence = float(confidence_tensor)
|
||||
|
||||
|
||||
# Handle volatility shape properly
|
||||
if HAS_NUMPY and isinstance(volatility, np.ndarray):
|
||||
if volatility.ndim == 0:
|
||||
@@ -502,28 +499,68 @@ class EnhancedCNNModel(nn.Module):
|
||||
else:
|
||||
volatility = float(volatility)
|
||||
|
||||
# Determine action (0=BUY, 1=SELL for 2-action system)
|
||||
if HAS_NUMPY:
|
||||
action = int(np.argmax(probs))
|
||||
else:
|
||||
action = int(torch.argmax(torch.tensor(probs)).item())
|
||||
action_confidence = float(probs[action])
|
||||
# Extract OHLCV values
|
||||
open_price, high_price, low_price, close_price, volume = ohlcv_pred
|
||||
|
||||
# Convert logits to list
|
||||
if HAS_NUMPY:
|
||||
raw_logits = outputs['logits'].cpu().numpy()[0].tolist()
|
||||
else:
|
||||
raw_logits = outputs['logits'].cpu().tolist()[0]
|
||||
# Calculate price movement and direction
|
||||
price_change = close_price - open_price
|
||||
price_change_pct = (price_change / open_price) * 100 if open_price != 0 else 0
|
||||
|
||||
# Calculate candle characteristics
|
||||
body_size = abs(close_price - open_price)
|
||||
upper_wick = high_price - max(open_price, close_price)
|
||||
lower_wick = min(open_price, close_price) - low_price
|
||||
total_range = high_price - low_price
|
||||
|
||||
# Determine trading action based on predicted candle
|
||||
if price_change_pct > 0.1: # Bullish candle (>0.1% gain)
|
||||
action = 0 # BUY
|
||||
action_name = 'BUY'
|
||||
action_confidence = min(0.95, confidence * (1 + abs(price_change_pct) * 10))
|
||||
elif price_change_pct < -0.1: # Bearish candle (<-0.1% loss)
|
||||
action = 1 # SELL
|
||||
action_name = 'SELL'
|
||||
action_confidence = min(0.95, confidence * (1 + abs(price_change_pct) * 10))
|
||||
else: # Sideways/neutral candle
|
||||
# Use body vs wick analysis for weak signals
|
||||
if body_size / total_range > 0.7: # Strong directional body
|
||||
action = 0 if price_change > 0 else 1
|
||||
action_name = 'BUY' if action == 0 else 'SELL'
|
||||
action_confidence = confidence * 0.6 # Reduce confidence for weak signals
|
||||
else:
|
||||
action = 2 # HOLD
|
||||
action_name = 'HOLD'
|
||||
action_confidence = confidence * 0.3 # Very low confidence
|
||||
|
||||
# Adjust confidence based on volatility
|
||||
if volatility > 0.5: # High volatility
|
||||
action_confidence *= 0.8 # Reduce confidence in volatile conditions
|
||||
elif volatility < 0.2: # Low volatility
|
||||
action_confidence *= 1.2 # Increase confidence in stable conditions
|
||||
action_confidence = min(0.95, action_confidence) # Cap at 95%
|
||||
|
||||
return {
|
||||
'action': action,
|
||||
'action_name': 'BUY' if action == 0 else 'SELL',
|
||||
'action_name': action_name,
|
||||
'confidence': float(confidence),
|
||||
'action_confidence': action_confidence,
|
||||
'probabilities': probs if isinstance(probs, list) else probs.tolist(),
|
||||
'ohlcv_prediction': {
|
||||
'open': float(open_price),
|
||||
'high': float(high_price),
|
||||
'low': float(low_price),
|
||||
'close': float(close_price),
|
||||
'volume': float(volume)
|
||||
},
|
||||
'price_change_pct': price_change_pct,
|
||||
'candle_characteristics': {
|
||||
'body_size': body_size,
|
||||
'upper_wick': upper_wick,
|
||||
'lower_wick': lower_wick,
|
||||
'total_range': total_range
|
||||
},
|
||||
'regime_probabilities': regime if isinstance(regime, list) else regime.tolist(),
|
||||
'volatility_prediction': float(volatility),
|
||||
'raw_logits': raw_logits
|
||||
'prediction_quality': 'high' if action_confidence > 0.8 else 'medium' if action_confidence > 0.6 else 'low'
|
||||
}
|
||||
|
||||
def get_memory_usage(self) -> Dict[str, Any]:
|
||||
|
||||
@@ -111,16 +111,18 @@ class MultiTimeframePredictor:
|
||||
adjusted_input_size = min(sequence_length, 300) # Cap at 300 to avoid memory issues
|
||||
|
||||
# Create new model instance with horizon-specific parameters
|
||||
horizon_model = model_class(
|
||||
input_size=adjusted_input_size,
|
||||
feature_dim=getattr(base_model, 'feature_dim', 50),
|
||||
output_size=getattr(base_model, 'output_size', 2),
|
||||
base_channels=getattr(base_model, 'base_channels', 256),
|
||||
num_blocks=getattr(base_model, 'num_blocks', 12),
|
||||
num_attention_heads=getattr(base_model, 'num_attention_heads', 16),
|
||||
dropout_rate=getattr(base_model, 'dropout_rate', 0.2),
|
||||
prediction_horizon=horizon.value
|
||||
)
|
||||
# Use only the parameters that the model actually accepts
|
||||
try:
|
||||
horizon_model = model_class(
|
||||
input_size=adjusted_input_size,
|
||||
feature_dim=getattr(base_model, 'feature_dim', 50),
|
||||
output_size=5, # Always use 5 for OHLCV predictions
|
||||
prediction_horizon=horizon.value
|
||||
)
|
||||
except TypeError:
|
||||
# If the model doesn't accept these parameters, just create with defaults
|
||||
logger.warning(f"Model {model_class.__name__} doesn't accept expected parameters, using defaults")
|
||||
horizon_model = model_class()
|
||||
|
||||
# Try to load pre-trained weights if available
|
||||
try:
|
||||
@@ -179,48 +181,33 @@ class MultiTimeframePredictor:
|
||||
def _generate_single_horizon_prediction(self, symbol: str, current_price: float,
|
||||
horizon: PredictionHorizon, config: Dict,
|
||||
market_conditions: Dict) -> Optional[Dict[str, Any]]:
|
||||
"""Generate prediction for single timeframe"""
|
||||
"""Generate prediction for single timeframe using iterative candle prediction"""
|
||||
try:
|
||||
# Get appropriate data for this horizon
|
||||
sequence_data = self._get_sequence_data_for_horizon(symbol, config['sequence_length'])
|
||||
# Get base historical data (use shorter sequence for iterative prediction)
|
||||
base_sequence_length = min(60, config['sequence_length'] // 2) # Use half for base data
|
||||
base_data = self._get_sequence_data_for_horizon(symbol, base_sequence_length)
|
||||
|
||||
if not sequence_data:
|
||||
if not base_data:
|
||||
return None
|
||||
|
||||
# Generate predictions from available models
|
||||
model_predictions = []
|
||||
# Generate iterative predictions for this horizon
|
||||
iterative_predictions = self._generate_iterative_predictions(
|
||||
symbol, base_data, horizon.value, market_conditions
|
||||
)
|
||||
|
||||
# CNN prediction
|
||||
cnn_key = f'cnn_{horizon.value}min'
|
||||
if cnn_key in self.models:
|
||||
cnn_pred = self._get_cnn_prediction(
|
||||
self.models[cnn_key], sequence_data, config
|
||||
)
|
||||
if cnn_pred:
|
||||
model_predictions.append(cnn_pred)
|
||||
|
||||
# COB RL prediction
|
||||
cob_key = f'cob_rl_{horizon.value}min'
|
||||
if cob_key in self.models:
|
||||
cob_pred = self._get_cob_rl_prediction(
|
||||
self.models[cob_key], sequence_data, config
|
||||
)
|
||||
if cob_pred:
|
||||
model_predictions.append(cob_pred)
|
||||
|
||||
if not model_predictions:
|
||||
if not iterative_predictions:
|
||||
return None
|
||||
|
||||
# Ensemble predictions
|
||||
ensemble_prediction = self._ensemble_predictions(
|
||||
model_predictions, config, market_conditions
|
||||
# Analyze the predicted price movement over the horizon
|
||||
horizon_prediction = self._analyze_horizon_prediction(
|
||||
iterative_predictions, config, market_conditions
|
||||
)
|
||||
|
||||
# Apply confidence threshold
|
||||
if ensemble_prediction['confidence'] < config['confidence_threshold']:
|
||||
if horizon_prediction['confidence'] < config['confidence_threshold']:
|
||||
return None # Not confident enough for this horizon
|
||||
|
||||
return ensemble_prediction
|
||||
return horizon_prediction
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error generating {horizon.value}-minute prediction: {e}")
|
||||
@@ -239,16 +226,26 @@ class MultiTimeframePredictor:
|
||||
|
||||
if data is not None and len(data) >= sequence_length // 10: # At least 10% of required data
|
||||
# Convert to tensor format expected by models
|
||||
return self._convert_data_to_tensor(data)
|
||||
tensor_data = self._convert_data_to_tensor(data)
|
||||
if tensor_data is not None:
|
||||
logger.debug(f"✅ Converted {len(data)} data points to tensor shape: {tensor_data.shape}")
|
||||
return tensor_data
|
||||
else:
|
||||
logger.warning("Failed to convert data to tensor")
|
||||
return None
|
||||
else:
|
||||
logger.warning(f"Insufficient data for {sequence_length}-point prediction")
|
||||
logger.warning(f"Insufficient data for {sequence_length}-point prediction: {len(data) if data is not None else 'None'}")
|
||||
return None
|
||||
|
||||
return None
|
||||
# Fallback: create mock data if no data provider available
|
||||
logger.warning("No data provider available - creating mock sequence data")
|
||||
return self._create_mock_sequence_data(sequence_length)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error getting sequence data: {e}")
|
||||
return None
|
||||
# Fallback: create mock data on error
|
||||
logger.warning("Creating mock sequence data due to error")
|
||||
return self._create_mock_sequence_data(sequence_length)
|
||||
|
||||
def _convert_data_to_tensor(self, data) -> torch.Tensor:
|
||||
"""Convert market data to tensor format"""
|
||||
@@ -261,12 +258,22 @@ class MultiTimeframePredictor:
|
||||
|
||||
for feature in features:
|
||||
if feature in data.columns:
|
||||
values = data[feature].fillna(method='ffill').fillna(0).values
|
||||
values = data[feature].ffill().fillna(0).values
|
||||
feature_data.append(values)
|
||||
|
||||
if feature_data:
|
||||
# Ensure all feature arrays have the same length
|
||||
min_length = min(len(arr) for arr in feature_data)
|
||||
feature_data = [arr[:min_length] for arr in feature_data]
|
||||
|
||||
# Stack features
|
||||
tensor_data = torch.tensor(feature_data, dtype=torch.float32).transpose(0, 1)
|
||||
|
||||
# Validate tensor data
|
||||
if torch.any(torch.isnan(tensor_data)) or torch.any(torch.isinf(tensor_data)):
|
||||
logger.warning("Found NaN or Inf values in tensor data, replacing with zeros")
|
||||
tensor_data = torch.nan_to_num(tensor_data, nan=0.0, posinf=0.0, neginf=0.0)
|
||||
|
||||
return tensor_data.unsqueeze(0) # Add batch dimension
|
||||
|
||||
return None
|
||||
@@ -276,25 +283,58 @@ class MultiTimeframePredictor:
|
||||
return None
|
||||
|
||||
def _get_cnn_prediction(self, model, sequence_data: torch.Tensor, config: Dict) -> Optional[Dict]:
|
||||
"""Get CNN model prediction"""
|
||||
"""Get CNN model prediction using OHLCV prediction"""
|
||||
try:
|
||||
# Use the predict method which now handles OHLCV predictions
|
||||
if hasattr(model, 'predict'):
|
||||
if sequence_data.dim() == 3: # [batch, seq, features]
|
||||
sequence_data_flat = sequence_data.squeeze(0) # Remove batch dim
|
||||
else:
|
||||
sequence_data_flat = sequence_data
|
||||
|
||||
prediction = model.predict(sequence_data_flat)
|
||||
|
||||
if prediction and 'action_name' in prediction:
|
||||
return {
|
||||
'action': prediction['action_name'],
|
||||
'confidence': prediction.get('action_confidence', 0.5),
|
||||
'model': 'cnn',
|
||||
'horizon': config.get('max_hold_time', 60),
|
||||
'ohlcv_prediction': prediction.get('ohlcv_prediction'),
|
||||
'price_change_pct': prediction.get('price_change_pct', 0)
|
||||
}
|
||||
|
||||
# Fallback to direct forward pass if predict method not available
|
||||
with torch.no_grad():
|
||||
outputs = model(sequence_data)
|
||||
if isinstance(outputs, tuple):
|
||||
predictions, confidence = outputs
|
||||
else:
|
||||
predictions = outputs
|
||||
confidence = torch.softmax(predictions, dim=-1).max().item()
|
||||
if isinstance(outputs, dict) and 'ohlcv' in outputs:
|
||||
ohlcv = outputs['ohlcv'].cpu().numpy()[0]
|
||||
confidence = outputs['confidence'].cpu().numpy()[0] if hasattr(outputs['confidence'], 'cpu') else outputs['confidence']
|
||||
|
||||
action_idx = predictions.argmax().item()
|
||||
actions = ['SELL', 'BUY'] # Adjust based on your model's output format
|
||||
# Determine action from OHLCV
|
||||
price_change_pct = ((ohlcv[3] - ohlcv[0]) / ohlcv[0]) * 100 if ohlcv[0] != 0 else 0
|
||||
|
||||
return {
|
||||
'action': actions[action_idx] if action_idx < len(actions) else 'HOLD',
|
||||
'confidence': confidence,
|
||||
'model': 'cnn',
|
||||
'horizon': config.get('max_hold_time', 60)
|
||||
}
|
||||
if price_change_pct > 0.1:
|
||||
action = 'BUY'
|
||||
elif price_change_pct < -0.1:
|
||||
action = 'SELL'
|
||||
else:
|
||||
action = 'HOLD'
|
||||
|
||||
return {
|
||||
'action': action,
|
||||
'confidence': float(confidence),
|
||||
'model': 'cnn',
|
||||
'horizon': config.get('max_hold_time', 60),
|
||||
'ohlcv_prediction': {
|
||||
'open': float(ohlcv[0]),
|
||||
'high': float(ohlcv[1]),
|
||||
'low': float(ohlcv[2]),
|
||||
'close': float(ohlcv[3]),
|
||||
'volume': float(ohlcv[4])
|
||||
},
|
||||
'price_change_pct': price_change_pct
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error getting CNN prediction: {e}")
|
||||
@@ -320,27 +360,58 @@ class MultiTimeframePredictor:
|
||||
|
||||
def _ensemble_predictions(self, predictions: List[Dict], config: Dict,
|
||||
market_conditions: Dict) -> Dict[str, Any]:
|
||||
"""Ensemble multiple model predictions"""
|
||||
"""Ensemble multiple model predictions using OHLCV data"""
|
||||
try:
|
||||
if not predictions:
|
||||
return None
|
||||
|
||||
# Simple voting ensemble
|
||||
# Enhanced ensemble considering both action and price movement
|
||||
action_votes = {}
|
||||
confidence_sum = 0
|
||||
price_change_indicators = []
|
||||
|
||||
for pred in predictions:
|
||||
action = pred['action']
|
||||
confidence = pred['confidence']
|
||||
|
||||
# Weight by confidence
|
||||
if action not in action_votes:
|
||||
action_votes[action] = 0
|
||||
action_votes[action] += confidence
|
||||
confidence_sum += confidence
|
||||
|
||||
# Collect price change indicators for ensemble analysis
|
||||
if 'price_change_pct' in pred:
|
||||
price_change_indicators.append(pred['price_change_pct'])
|
||||
|
||||
# Get winning action
|
||||
best_action = max(action_votes, key=action_votes.get)
|
||||
ensemble_confidence = action_votes[best_action] / len(predictions)
|
||||
if action_votes:
|
||||
best_action = max(action_votes, key=action_votes.get)
|
||||
ensemble_confidence = action_votes[best_action] / len(predictions)
|
||||
else:
|
||||
best_action = 'HOLD'
|
||||
ensemble_confidence = 0.1
|
||||
|
||||
# Analyze price movement consensus
|
||||
if price_change_indicators:
|
||||
avg_price_change = sum(price_change_indicators) / len(price_change_indicators)
|
||||
price_consensus = abs(avg_price_change) / 0.1 # Normalize around 0.1% threshold
|
||||
|
||||
# Boost confidence if price movements are consistent
|
||||
if len(price_change_indicators) > 1:
|
||||
price_std = torch.std(torch.tensor(price_change_indicators)).item()
|
||||
if price_std < 0.05: # Low variability in predictions
|
||||
ensemble_confidence *= 1.2
|
||||
elif price_std > 0.15: # High variability
|
||||
ensemble_confidence *= 0.8
|
||||
|
||||
# Override action based on strong price consensus
|
||||
if abs(avg_price_change) > 0.2: # Strong price movement
|
||||
if avg_price_change > 0:
|
||||
best_action = 'BUY'
|
||||
else:
|
||||
best_action = 'SELL'
|
||||
ensemble_confidence = min(ensemble_confidence * 1.3, 0.9)
|
||||
|
||||
# Adjust confidence based on market conditions
|
||||
market_confidence_multiplier = market_conditions.get('confidence_multiplier', 1.0)
|
||||
@@ -352,7 +423,9 @@ class MultiTimeframePredictor:
|
||||
'horizon_minutes': config['max_hold_time'] // 60,
|
||||
'risk_multiplier': config['risk_multiplier'],
|
||||
'models_used': len(predictions),
|
||||
'market_conditions': market_conditions
|
||||
'market_conditions': market_conditions,
|
||||
'price_change_indicators': price_change_indicators,
|
||||
'avg_price_change_pct': sum(price_change_indicators) / len(price_change_indicators) if price_change_indicators else 0
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
@@ -444,3 +517,264 @@ class MultiTimeframePredictor:
|
||||
except Exception as e:
|
||||
logger.error(f"Error determining hold time: {e}")
|
||||
return 60
|
||||
|
||||
def _generate_iterative_predictions(self, symbol: str, base_data: torch.Tensor,
|
||||
num_steps: int, market_conditions: Dict) -> Optional[List[Dict]]:
|
||||
"""Generate iterative candle predictions for the specified number of steps"""
|
||||
try:
|
||||
predictions = []
|
||||
current_data = base_data.clone() # Start with base historical data
|
||||
|
||||
# Get the CNN model for iterative prediction
|
||||
cnn_model = None
|
||||
for model_key, model in self.models.items():
|
||||
if model_key.startswith('cnn_'):
|
||||
cnn_model = model
|
||||
break
|
||||
|
||||
if not cnn_model:
|
||||
logger.warning("No CNN model available for iterative prediction")
|
||||
return None
|
||||
|
||||
# Check if CNN model has predict method
|
||||
if not hasattr(cnn_model, 'predict'):
|
||||
logger.warning("CNN model does not have predict method - trying alternative approach")
|
||||
# Try to use the orchestrator's CNN model directly
|
||||
if hasattr(self.orchestrator, 'cnn_model') and self.orchestrator.cnn_model:
|
||||
cnn_model = self.orchestrator.cnn_model
|
||||
logger.info("Using orchestrator's CNN model for predictions")
|
||||
|
||||
# Check if orchestrator's CNN model also lacks predict method
|
||||
if not hasattr(cnn_model, 'predict'):
|
||||
logger.error("Orchestrator's CNN model also lacks predict method - creating mock predictions")
|
||||
return self._create_mock_predictions(num_steps)
|
||||
else:
|
||||
logger.error("No CNN model with predict method available - creating mock predictions")
|
||||
# Create mock predictions for testing
|
||||
return self._create_mock_predictions(num_steps)
|
||||
|
||||
for step in range(num_steps):
|
||||
# Use CNN model to predict next candle
|
||||
try:
|
||||
with torch.no_grad():
|
||||
# Prepare data for CNN prediction
|
||||
# Convert tensor to format expected by predict method
|
||||
if current_data.dim() == 3: # [batch, seq, features]
|
||||
current_data_flat = current_data.squeeze(0) # Remove batch dim
|
||||
else:
|
||||
current_data_flat = current_data
|
||||
|
||||
prediction = cnn_model.predict(current_data_flat)
|
||||
|
||||
if prediction and 'ohlcv_prediction' in prediction:
|
||||
# Add timestamp to the prediction
|
||||
prediction_time = datetime.now() + timedelta(minutes=step + 1)
|
||||
prediction['timestamp'] = prediction_time
|
||||
predictions.append(prediction)
|
||||
logger.debug(f"📊 Step {step}: Added prediction for {prediction_time}, close: {prediction['ohlcv_prediction']['close']:.2f}")
|
||||
|
||||
# Extract predicted OHLCV values
|
||||
ohlcv = prediction['ohlcv_prediction']
|
||||
new_candle = torch.tensor([
|
||||
ohlcv['open'],
|
||||
ohlcv['high'],
|
||||
ohlcv['low'],
|
||||
ohlcv['close'],
|
||||
ohlcv['volume']
|
||||
], dtype=current_data.dtype)
|
||||
|
||||
# Add the predicted candle to our data sequence
|
||||
# Remove oldest candle and add new prediction
|
||||
if current_data.dim() == 3:
|
||||
current_data = torch.cat([
|
||||
current_data[:, 1:, :], # Remove oldest candle
|
||||
new_candle.unsqueeze(0).unsqueeze(0) # Add new prediction
|
||||
], dim=1)
|
||||
else:
|
||||
current_data = torch.cat([
|
||||
current_data[1:, :], # Remove oldest candle
|
||||
new_candle.unsqueeze(0) # Add new prediction
|
||||
], dim=0)
|
||||
else:
|
||||
logger.warning(f"❌ Step {step}: Invalid prediction format")
|
||||
break
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error in iterative prediction step {step}: {e}")
|
||||
break
|
||||
|
||||
return predictions if predictions else None
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error in iterative predictions: {e}")
|
||||
return None
|
||||
|
||||
def _create_mock_predictions(self, num_steps: int) -> List[Dict]:
|
||||
"""Create mock predictions for testing when CNN model is not available"""
|
||||
try:
|
||||
logger.info(f"Creating {num_steps} mock predictions for testing")
|
||||
predictions = []
|
||||
current_time = datetime.now()
|
||||
base_price = 4300.0 # Mock base price
|
||||
|
||||
for step in range(num_steps):
|
||||
prediction_time = current_time + timedelta(minutes=step + 1)
|
||||
price_change = (step - num_steps // 2) * 2.0 # Mock price movement
|
||||
predicted_price = base_price + price_change
|
||||
|
||||
mock_prediction = {
|
||||
'timestamp': prediction_time,
|
||||
'ohlcv_prediction': {
|
||||
'open': predicted_price,
|
||||
'high': predicted_price + 1.0,
|
||||
'low': predicted_price - 1.0,
|
||||
'close': predicted_price + 0.5,
|
||||
'volume': 1000
|
||||
},
|
||||
'confidence': max(0.3, 0.8 - step * 0.05), # Decreasing confidence
|
||||
'action': 0 if price_change > 0 else 1,
|
||||
'action_name': 'BUY' if price_change > 0 else 'SELL'
|
||||
}
|
||||
predictions.append(mock_prediction)
|
||||
|
||||
logger.info(f"✅ Created {len(predictions)} mock predictions")
|
||||
return predictions
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error creating mock predictions: {e}")
|
||||
return []
|
||||
|
||||
def _create_mock_sequence_data(self, sequence_length: int) -> torch.Tensor:
|
||||
"""Create mock sequence data for testing when real data is not available"""
|
||||
try:
|
||||
logger.info(f"Creating mock sequence data with {sequence_length} points")
|
||||
|
||||
# Create mock OHLCV data
|
||||
base_price = 4300.0
|
||||
mock_data = []
|
||||
|
||||
for i in range(sequence_length):
|
||||
# Simulate price movement
|
||||
price_change = (i - sequence_length // 2) * 0.5
|
||||
price = base_price + price_change
|
||||
|
||||
# Create OHLCV candle
|
||||
candle = [
|
||||
price, # open
|
||||
price + 1.0, # high
|
||||
price - 1.0, # low
|
||||
price + 0.5, # close
|
||||
1000.0 # volume
|
||||
]
|
||||
mock_data.append(candle)
|
||||
|
||||
# Convert to tensor
|
||||
tensor_data = torch.tensor(mock_data, dtype=torch.float32)
|
||||
tensor_data = tensor_data.unsqueeze(0) # Add batch dimension
|
||||
|
||||
logger.debug(f"✅ Created mock sequence data shape: {tensor_data.shape}")
|
||||
return tensor_data
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error creating mock sequence data: {e}")
|
||||
# Return minimal valid tensor
|
||||
return torch.zeros((1, 10, 5), dtype=torch.float32)
|
||||
|
||||
def _analyze_horizon_prediction(self, iterative_predictions: List[Dict],
|
||||
config: Dict, market_conditions: Dict) -> Optional[Dict[str, Any]]:
|
||||
"""Analyze the series of iterative predictions to determine overall horizon movement"""
|
||||
try:
|
||||
if not iterative_predictions:
|
||||
return None
|
||||
|
||||
# Extract price data from predictions
|
||||
predicted_prices = []
|
||||
confidences = []
|
||||
actions = []
|
||||
|
||||
for pred in iterative_predictions:
|
||||
if 'ohlcv_prediction' in pred:
|
||||
close_price = pred['ohlcv_prediction']['close']
|
||||
predicted_prices.append(close_price)
|
||||
|
||||
confidence = pred.get('action_confidence', 0.5)
|
||||
confidences.append(confidence)
|
||||
|
||||
action = pred.get('action', 2) # Default to HOLD
|
||||
actions.append(action)
|
||||
|
||||
if not predicted_prices:
|
||||
return None
|
||||
|
||||
# Calculate overall price movement
|
||||
start_price = predicted_prices[0]
|
||||
end_price = predicted_prices[-1]
|
||||
total_change = end_price - start_price
|
||||
total_change_pct = (total_change / start_price) * 100 if start_price != 0 else 0
|
||||
|
||||
# Calculate volatility and trend strength
|
||||
price_volatility = torch.std(torch.tensor(predicted_prices)).item()
|
||||
avg_confidence = sum(confidences) / len(confidences)
|
||||
|
||||
# Determine overall action based on price movement and confidence
|
||||
if total_change_pct > 0.5: # Overall bullish movement
|
||||
action = 0 # BUY
|
||||
action_name = 'BUY'
|
||||
confidence_multiplier = 1.2
|
||||
elif total_change_pct < -0.5: # Overall bearish movement
|
||||
action = 1 # SELL
|
||||
action_name = 'SELL'
|
||||
confidence_multiplier = 1.2
|
||||
else: # Sideways movement
|
||||
# Use majority vote from individual predictions
|
||||
buy_count = sum(1 for a in actions if a == 0)
|
||||
sell_count = sum(1 for a in actions if a == 1)
|
||||
|
||||
if buy_count > sell_count:
|
||||
action = 0
|
||||
action_name = 'BUY'
|
||||
confidence_multiplier = 0.8 # Reduce confidence for mixed signals
|
||||
elif sell_count > buy_count:
|
||||
action = 1
|
||||
action_name = 'SELL'
|
||||
confidence_multiplier = 0.8
|
||||
else:
|
||||
action = 2 # HOLD
|
||||
action_name = 'HOLD'
|
||||
confidence_multiplier = 0.5
|
||||
|
||||
# Calculate final confidence
|
||||
final_confidence = avg_confidence * confidence_multiplier
|
||||
|
||||
# Adjust for market conditions
|
||||
market_multiplier = market_conditions.get('confidence_multiplier', 1.0)
|
||||
final_confidence *= market_multiplier
|
||||
|
||||
# Cap confidence at reasonable levels
|
||||
final_confidence = min(0.95, max(0.1, final_confidence))
|
||||
|
||||
# Adjust for volatility
|
||||
if price_volatility > 0.02: # High volatility in predictions
|
||||
final_confidence *= 0.9
|
||||
|
||||
return {
|
||||
'action': action,
|
||||
'action_name': action_name,
|
||||
'confidence': final_confidence,
|
||||
'horizon_minutes': config['max_hold_time'] // 60,
|
||||
'total_price_change_pct': total_change_pct,
|
||||
'price_volatility': price_volatility,
|
||||
'avg_prediction_confidence': avg_confidence,
|
||||
'num_predictions': len(iterative_predictions),
|
||||
'risk_multiplier': config['risk_multiplier'],
|
||||
'market_conditions': market_conditions,
|
||||
'prediction_series': {
|
||||
'prices': predicted_prices,
|
||||
'confidences': confidences,
|
||||
'actions': actions
|
||||
}
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error analyzing horizon prediction: {e}")
|
||||
return None
|
||||
|
||||
@@ -42,8 +42,26 @@ from dataclasses import asdict
|
||||
import math
|
||||
import subprocess
|
||||
|
||||
# Conditional imports for optional dependencies
|
||||
try:
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
HAS_TORCH = True
|
||||
except ImportError:
|
||||
torch = None
|
||||
nn = None
|
||||
HAS_TORCH = False
|
||||
|
||||
try:
|
||||
import numpy as np
|
||||
HAS_NUMPY = True
|
||||
except ImportError:
|
||||
np = None
|
||||
HAS_NUMPY = False
|
||||
|
||||
# Setup logger
|
||||
logger = logging.getLogger(__name__)
|
||||
logger.setLevel(logging.INFO) # Ensure we can see INFO messages for predictions
|
||||
|
||||
# Reduce Werkzeug/Dash logging noise
|
||||
logging.getLogger('werkzeug').setLevel(logging.WARNING)
|
||||
@@ -117,6 +135,9 @@ class CleanTradingDashboard:
|
||||
# Initialize multi-timeframe prediction system
|
||||
self.multi_timeframe_predictor = None
|
||||
self._initialize_multi_timeframe_predictor()
|
||||
|
||||
# Initialize 10-minute prediction storage
|
||||
self.current_10min_prediction = None
|
||||
|
||||
# Initialize layout and component managers
|
||||
self.layout_manager = DashboardLayoutManager(
|
||||
@@ -1911,11 +1932,155 @@ class CleanTradingDashboard:
|
||||
self._add_dqn_predictions_to_chart(fig, symbol, df_main, row)
|
||||
self._add_cnn_predictions_to_chart(fig, symbol, df_main, row)
|
||||
self._add_cob_rl_predictions_to_chart(fig, symbol, df_main, row)
|
||||
self._add_iterative_predictions_to_chart(fig, symbol, df_main, row)
|
||||
self._add_prediction_accuracy_feedback(fig, symbol, df_main, row)
|
||||
|
||||
except Exception as e:
|
||||
logger.warning(f"Error adding model predictions to chart: {e}")
|
||||
|
||||
def _add_iterative_predictions_to_chart(self, fig: go.Figure, symbol: str, df_main: pd.DataFrame, row: int = 1):
|
||||
"""Add 10-minute iterative predictions to the main chart with fading opacity"""
|
||||
try:
|
||||
if not hasattr(self, 'multi_timeframe_predictor') or not self.multi_timeframe_predictor:
|
||||
logger.debug("❌ Multi-timeframe predictor not available")
|
||||
return
|
||||
|
||||
# Run iterative prediction every minute
|
||||
current_time = datetime.now()
|
||||
if not hasattr(self, '_last_prediction_time') or \
|
||||
(current_time - self._last_prediction_time).total_seconds() >= 60:
|
||||
|
||||
try:
|
||||
prediction_result = self.run_iterative_prediction_10min(symbol)
|
||||
if prediction_result:
|
||||
self._last_prediction_time = current_time
|
||||
logger.info("✅ 10-minute iterative prediction completed")
|
||||
else:
|
||||
logger.warning("❌ 10-minute iterative prediction returned None")
|
||||
except Exception as e:
|
||||
logger.error(f"Error running iterative prediction: {e}")
|
||||
|
||||
# Get current predictions from stored result
|
||||
if hasattr(self, 'current_10min_prediction') and self.current_10min_prediction:
|
||||
predictions = self.current_10min_prediction.get('predictions', [])
|
||||
logger.debug(f"🔍 Found {len(predictions)} predictions in current_10min_prediction")
|
||||
|
||||
if predictions:
|
||||
logger.info(f"📊 Processing {len(predictions)} predictions for chart display")
|
||||
# Group predictions by age for fading effect
|
||||
prediction_groups = {}
|
||||
current_time = datetime.now()
|
||||
|
||||
for pred in predictions[-50:]: # Last 50 predictions
|
||||
prediction_time = pred.get('timestamp')
|
||||
if not prediction_time:
|
||||
logger.debug(f"❌ Prediction missing timestamp: {pred}")
|
||||
continue
|
||||
|
||||
if isinstance(prediction_time, str):
|
||||
try:
|
||||
prediction_time = pd.to_datetime(prediction_time)
|
||||
except Exception as e:
|
||||
logger.debug(f"❌ Could not parse timestamp '{prediction_time}': {e}")
|
||||
continue
|
||||
|
||||
# Calculate age in minutes (how long ago this prediction was made)
|
||||
# For future predictions, use a small positive age to show them as current
|
||||
if prediction_time > current_time:
|
||||
age_minutes = 0.1 # Future predictions treated as very recent
|
||||
else:
|
||||
age_minutes = (current_time - prediction_time).total_seconds() / 60
|
||||
|
||||
logger.debug(f"🔍 Prediction age: {age_minutes:.2f} min, timestamp: {prediction_time}, current: {current_time}")
|
||||
|
||||
# Group by age ranges for fading
|
||||
if age_minutes <= 1:
|
||||
group = 'current' # Very recent, high opacity
|
||||
elif age_minutes <= 3:
|
||||
group = 'recent' # Recent, medium opacity
|
||||
elif age_minutes <= 5:
|
||||
group = 'old' # Older, low opacity
|
||||
else:
|
||||
continue # Too old, skip
|
||||
|
||||
if group not in prediction_groups:
|
||||
prediction_groups[group] = []
|
||||
|
||||
prediction_groups[group].append({
|
||||
'x': prediction_time,
|
||||
'y': pred.get('close', 0),
|
||||
'high': pred.get('high', 0),
|
||||
'low': pred.get('low', 0),
|
||||
'confidence': pred.get('confidence', 0),
|
||||
'age': age_minutes
|
||||
})
|
||||
|
||||
# Add predictions with fading opacity
|
||||
opacity_levels = {
|
||||
'current': 0.8, # Bright for very recent
|
||||
'recent': 0.5, # Medium for recent
|
||||
'old': 0.3 # Dim for older
|
||||
}
|
||||
|
||||
logger.info(f"📊 Adding {len(prediction_groups)} prediction groups to chart")
|
||||
|
||||
for group, preds in prediction_groups.items():
|
||||
if not preds:
|
||||
continue
|
||||
|
||||
opacity = opacity_levels[group]
|
||||
logger.info(f"📈 Adding {group} predictions: {len(preds)} points, opacity: {opacity}")
|
||||
|
||||
# Add prediction line
|
||||
fig.add_trace(
|
||||
go.Scatter(
|
||||
x=[p['x'] for p in preds],
|
||||
y=[p['y'] for p in preds],
|
||||
mode='lines+markers',
|
||||
line=dict(
|
||||
color=f'rgba(255, 215, 0, {opacity})', # Gold color
|
||||
width=2,
|
||||
dash='dash'
|
||||
),
|
||||
marker=dict(
|
||||
symbol='diamond',
|
||||
size=6,
|
||||
color=f'rgba(255, 215, 0, {opacity})',
|
||||
line=dict(width=1, color='rgba(255, 140, 0, 0.8)')
|
||||
),
|
||||
name=f'🔮 10min Pred ({group})',
|
||||
showlegend=True,
|
||||
hovertemplate="<b>🔮 10-Minute Prediction</b><br>" +
|
||||
"Predicted Close: $%{y:.2f}<br>" +
|
||||
"Time: %{x}<br>" +
|
||||
"Age: %{customdata:.1f} min<br>" +
|
||||
"Confidence: %{text:.1%}<extra></extra>",
|
||||
customdata=[p['age'] for p in preds],
|
||||
text=[p['confidence'] for p in preds]
|
||||
),
|
||||
row=row, col=1
|
||||
)
|
||||
|
||||
# Add confidence bands (high/low range)
|
||||
if len(preds) > 1:
|
||||
fig.add_trace(
|
||||
go.Scatter(
|
||||
x=[p['x'] for p in preds] + [p['x'] for p in reversed(preds)],
|
||||
y=[p['high'] for p in preds] + [p['low'] for p in reversed(preds)],
|
||||
fill='toself',
|
||||
fillcolor=f'rgba(255, 215, 0, {opacity * 0.2})',
|
||||
line=dict(width=0),
|
||||
mode='lines',
|
||||
name=f'Prediction Range ({group})',
|
||||
showlegend=False,
|
||||
hoverinfo='skip'
|
||||
),
|
||||
row=row, col=1
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
logger.debug(f"Error adding iterative predictions to chart: {e}")
|
||||
|
||||
def _add_dqn_predictions_to_chart(self, fig: go.Figure, symbol: str, df_main: pd.DataFrame, row: int = 1):
|
||||
"""Add DQN action predictions as directional arrows"""
|
||||
try:
|
||||
@@ -5133,6 +5298,268 @@ class CleanTradingDashboard:
|
||||
filename = f"trades_export_{timestamp}.csv"
|
||||
return self.export_trade_history_csv(filename)
|
||||
|
||||
def run_iterative_prediction_10min(self, symbol: str = "ETH/USDT") -> Optional[Dict]:
|
||||
"""Run 10-minute iterative prediction using the multi-timeframe predictor"""
|
||||
try:
|
||||
if not self.multi_timeframe_predictor:
|
||||
logger.warning("Multi-timeframe predictor not available")
|
||||
return None
|
||||
|
||||
logger.info(f"🔮 Running 10-minute iterative prediction for {symbol}")
|
||||
|
||||
# Get current price and market conditions
|
||||
current_price = self._get_current_price(symbol)
|
||||
if not current_price:
|
||||
logger.warning(f"Could not get current price for {symbol}")
|
||||
return None
|
||||
|
||||
# Run iterative prediction for 10 minutes
|
||||
iterative_predictions = self.multi_timeframe_predictor._generate_iterative_predictions(
|
||||
symbol=symbol,
|
||||
base_data=self.multi_timeframe_predictor._get_sequence_data_for_horizon(
|
||||
symbol, self.multi_timeframe_predictor.horizons[PredictionHorizon.TEN_MINUTES]['sequence_length']
|
||||
),
|
||||
num_steps=10, # 10 steps for 10-minute prediction
|
||||
market_conditions={'confidence_multiplier': 1.0}
|
||||
)
|
||||
|
||||
if iterative_predictions:
|
||||
# Analyze the 10-minute prediction
|
||||
config = self.multi_timeframe_predictor.horizons[PredictionHorizon.TEN_MINUTES]
|
||||
market_conditions = self.multi_timeframe_predictor._assess_market_conditions(symbol)
|
||||
|
||||
horizon_prediction = self.multi_timeframe_predictor._analyze_horizon_prediction(
|
||||
iterative_predictions, config, market_conditions
|
||||
)
|
||||
|
||||
if horizon_prediction:
|
||||
# Store the prediction for dashboard display
|
||||
self.current_10min_prediction = {
|
||||
'symbol': symbol,
|
||||
'timestamp': datetime.now(),
|
||||
'predictions': iterative_predictions,
|
||||
'horizon_analysis': horizon_prediction,
|
||||
'current_price': current_price
|
||||
}
|
||||
|
||||
logger.info(f"✅ 10-minute iterative prediction completed for {symbol}")
|
||||
logger.info(f"📊 Generated {len(iterative_predictions)} candle predictions")
|
||||
|
||||
return self.current_10min_prediction
|
||||
|
||||
logger.warning("Failed to generate 10-minute iterative prediction")
|
||||
return None
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error running 10-minute iterative prediction: {e}")
|
||||
return None
|
||||
|
||||
def create_10min_prediction_chart(self, opacity: float = 0.4) -> Dict[str, Any]:
|
||||
"""DEPRECATED: Create a chart visualizing the 10-minute iterative predictions with opacity
|
||||
Note: Predictions are now integrated directly into the main 1-minute chart"""
|
||||
try:
|
||||
if not self.current_10min_prediction or not self.current_10min_prediction.get('predictions'):
|
||||
# Return empty chart if no predictions available
|
||||
return {
|
||||
'data': [],
|
||||
'layout': {
|
||||
'title': '10-Minute Iterative Predictions - No Data Available',
|
||||
'template': 'plotly_dark',
|
||||
'height': 400,
|
||||
'annotations': [{
|
||||
'text': 'Run iterative prediction to see forecast',
|
||||
'xref': 'paper', 'yref': 'paper',
|
||||
'x': 0.5, 'y': 0.5,
|
||||
'showarrow': False,
|
||||
'font': {'size': 16, 'color': 'gray'}
|
||||
}]
|
||||
}
|
||||
}
|
||||
|
||||
predictions = self.current_10min_prediction['predictions']
|
||||
current_price = self.current_10min_prediction['current_price']
|
||||
horizon_analysis = self.current_10min_prediction['horizon_analysis']
|
||||
|
||||
# Create time points for the next 10 minutes
|
||||
base_time = self.current_10min_prediction['timestamp']
|
||||
time_points = [base_time + timedelta(minutes=i) for i in range(11)] # 0 to 10 minutes
|
||||
|
||||
# Extract predicted prices
|
||||
predicted_prices = [current_price] # Start with current price
|
||||
confidence_levels = [1.0] # Current price has full confidence
|
||||
|
||||
for i, pred in enumerate(predictions[:10]): # Limit to 10 predictions
|
||||
if 'ohlcv_prediction' in pred:
|
||||
close_price = pred['ohlcv_prediction']['close']
|
||||
predicted_prices.append(close_price)
|
||||
|
||||
# Get confidence for this prediction
|
||||
confidence = pred.get('action_confidence', 0.5)
|
||||
confidence_levels.append(confidence)
|
||||
|
||||
# Create the main prediction line
|
||||
prediction_trace = go.Scatter(
|
||||
x=time_points[:len(predicted_prices)],
|
||||
y=predicted_prices,
|
||||
mode='lines+markers',
|
||||
name='Predicted Price',
|
||||
line=dict(color='cyan', width=3),
|
||||
marker=dict(size=6, color='cyan'),
|
||||
opacity=opacity
|
||||
)
|
||||
|
||||
# Create confidence bands
|
||||
upper_bound = []
|
||||
lower_bound = []
|
||||
|
||||
for i, price in enumerate(predicted_prices):
|
||||
if i == 0: # Current price has no uncertainty
|
||||
upper_bound.append(price)
|
||||
lower_bound.append(price)
|
||||
else:
|
||||
# Create confidence bands based on prediction confidence
|
||||
confidence = confidence_levels[i]
|
||||
uncertainty = (1 - confidence) * price * 0.02 # 2% max uncertainty
|
||||
upper_bound.append(price + uncertainty)
|
||||
lower_bound.append(price - uncertainty)
|
||||
|
||||
# Confidence band fill
|
||||
confidence_fill = go.Scatter(
|
||||
x=time_points[:len(predicted_prices)] + time_points[:len(predicted_prices)][::-1],
|
||||
y=upper_bound + lower_bound[::-1],
|
||||
fill='toself',
|
||||
fillcolor=f'rgba(0, 255, 255, {opacity * 0.3})', # Cyan with reduced opacity
|
||||
line=dict(color='rgba(255,255,255,0)'),
|
||||
name='Confidence Band',
|
||||
showlegend=True
|
||||
)
|
||||
|
||||
# Individual candle predictions as scatter points
|
||||
candle_traces = []
|
||||
for i, pred in enumerate(predictions[:10]):
|
||||
if 'ohlcv_prediction' in pred:
|
||||
ohlcv = pred['ohlcv_prediction']
|
||||
pred_time = base_time + timedelta(minutes=i+1)
|
||||
confidence = pred.get('action_confidence', 0.5)
|
||||
|
||||
# Color based on price movement
|
||||
if ohlcv['close'] > ohlcv['open']:
|
||||
color = f'rgba(0, 255, 0, {opacity})' # Green for bullish
|
||||
else:
|
||||
color = f'rgba(255, 0, 0, {opacity})' # Red for bearish
|
||||
|
||||
candle_trace = go.Scatter(
|
||||
x=[pred_time],
|
||||
y=[ohlcv['close']],
|
||||
mode='markers',
|
||||
marker=dict(
|
||||
size=max(8, int(confidence * 20)), # Size based on confidence
|
||||
color=color,
|
||||
symbol='diamond',
|
||||
line=dict(width=2, color='white')
|
||||
),
|
||||
name=f'Candle {i+1}',
|
||||
showlegend=False,
|
||||
hovertemplate=f'Candle {i+1}<br>Time: {pred_time.strftime("%H:%M")}<br>Close: ${ohlcv["close"]:.2f}<br>Confidence: {confidence:.2f}<extra></extra>'
|
||||
)
|
||||
candle_traces.append(candle_trace)
|
||||
|
||||
# Current price marker
|
||||
current_price_trace = go.Scatter(
|
||||
x=[base_time],
|
||||
y=[current_price],
|
||||
mode='markers',
|
||||
marker=dict(
|
||||
size=12,
|
||||
color='yellow',
|
||||
symbol='star',
|
||||
line=dict(width=2, color='white')
|
||||
),
|
||||
name='Current Price',
|
||||
hovertemplate=f'Current Price<br>${current_price:.2f}<extra></extra>'
|
||||
)
|
||||
|
||||
# Create the figure
|
||||
fig = go.Figure()
|
||||
|
||||
# Add traces in order (confidence band first, then prediction line, then candles)
|
||||
fig.add_trace(confidence_fill)
|
||||
fig.add_trace(prediction_trace)
|
||||
fig.add_trace(current_price_trace)
|
||||
|
||||
# Add individual candle traces
|
||||
for trace in candle_traces:
|
||||
fig.add_trace(trace)
|
||||
|
||||
# Calculate overall trend
|
||||
if len(predicted_prices) > 1:
|
||||
start_price = predicted_prices[0]
|
||||
end_price = predicted_prices[-1]
|
||||
total_change_pct = ((end_price - start_price) / start_price) * 100
|
||||
|
||||
trend_color = 'green' if total_change_pct > 0 else 'red'
|
||||
trend_text = f"Overall Trend: {'↗️ BULLISH' if total_change_pct > 0 else '↘️ BEARISH'} {abs(total_change_pct):.2f}%"
|
||||
else:
|
||||
trend_text = "No trend data available"
|
||||
trend_color = 'gray'
|
||||
|
||||
# Update layout
|
||||
fig.update_layout(
|
||||
title={
|
||||
'text': f'🔮 10-Minute Iterative Price Prediction - {trend_text}',
|
||||
'y': 0.95,
|
||||
'x': 0.5,
|
||||
'xanchor': 'center',
|
||||
'yanchor': 'top',
|
||||
'font': dict(size=16, color=trend_color)
|
||||
},
|
||||
template='plotly_dark',
|
||||
height=500,
|
||||
xaxis=dict(
|
||||
title='Time',
|
||||
tickformat='%H:%M',
|
||||
showgrid=True,
|
||||
gridcolor='rgba(128,128,128,0.2)'
|
||||
),
|
||||
yaxis=dict(
|
||||
title='Price ($)',
|
||||
tickformat='.2f',
|
||||
showgrid=True,
|
||||
gridcolor='rgba(128,128,128,0.2)'
|
||||
),
|
||||
hovermode='x unified',
|
||||
legend=dict(
|
||||
yanchor="top",
|
||||
y=0.99,
|
||||
xanchor="left",
|
||||
x=0.01
|
||||
),
|
||||
annotations=[
|
||||
dict(
|
||||
text="💡 Predictions are iterative - each candle builds on the previous prediction",
|
||||
x=0.5,
|
||||
y=-0.15,
|
||||
xref="paper",
|
||||
yref="paper",
|
||||
showarrow=False,
|
||||
font=dict(size=10, color='gray')
|
||||
)
|
||||
]
|
||||
)
|
||||
|
||||
return fig
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error creating 10-minute prediction chart: {e}")
|
||||
return {
|
||||
'data': [],
|
||||
'layout': {
|
||||
'title': f'Error creating prediction chart: {str(e)[:50]}...',
|
||||
'template': 'plotly_dark',
|
||||
'height': 400
|
||||
}
|
||||
}
|
||||
|
||||
def _train_dqn_on_signal(self, signal: Dict, trade_outcome: Dict):
|
||||
"""Train DQN agent on executed signal with trade outcome"""
|
||||
try:
|
||||
@@ -7771,6 +8198,7 @@ class CleanTradingDashboard:
|
||||
elif hasattr(network_output, 'dim'):
|
||||
# Single tensor output - assume it's action logits
|
||||
action_logits = network_output
|
||||
device = action_logits.device if hasattr(action_logits, 'device') else torch.device('cpu')
|
||||
predicted_confidence = torch.tensor(0.5, device=device) # Default confidence
|
||||
else:
|
||||
logger.debug(f"Unexpected network output format: {type(network_output)}")
|
||||
@@ -7779,6 +8207,7 @@ class CleanTradingDashboard:
|
||||
# Ensure predicted_confidence is a tensor with proper dimensions
|
||||
if not hasattr(predicted_confidence, 'dim'):
|
||||
# If it's not a tensor, convert it
|
||||
device = predicted_confidence.device if hasattr(predicted_confidence, 'device') else torch.device('cpu')
|
||||
predicted_confidence = torch.tensor(float(predicted_confidence), device=device)
|
||||
|
||||
if predicted_confidence.dim() == 0:
|
||||
@@ -8415,13 +8844,15 @@ class CleanTradingDashboard:
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
def create_clean_dashboard(data_provider: Optional[DataProvider] = None, orchestrator: Optional[TradingOrchestrator] = None, trading_executor: Optional[TradingExecutor] = None):
|
||||
"""Factory function to create a CleanTradingDashboard instance"""
|
||||
return CleanTradingDashboard(
|
||||
data_provider=data_provider,
|
||||
orchestrator=orchestrator,
|
||||
trading_executor=trading_executor
|
||||
)
|
||||
|
||||
|
||||
# test edit
|
||||
)
|
||||
|
||||
|
||||
# test edit
|
||||
@@ -455,5 +455,6 @@ class DashboardLayoutManager:
|
||||
], className="card-body p-2")
|
||||
], className="card", style={"width": "30%", "marginLeft": "2%"})
|
||||
], className="d-flex")
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user