A: Yes! v3.1.0 is fully backward compatible. Your existing code will work without any changes. New features are opt-in.
A: No. Core features work without ML dependencies. Install them only if you want to use ML strategies:
- TensorFlow: For LSTM strategies
- PyTorch: For deep learning
- Transformers: For transformer models
- Gymnasium + Stable-Baselines3: For RL strategies
- Optuna: For hyperparameter optimization
- DEAP: For genetic algorithms
A:
LSTM_Strategy- Requires TensorFlowTransformer_Strategy- Requires TransformersRL_Strategy- Requires Gymnasium and Stable-Baselines3SVM_Strategy,Ensemble_ML_Strategy- Only require scikit-learn (already in requirements)
A:
from forexsmartbot.strategies import list_strategies, STRATEGIES
# List all available strategies
print(list_strategies())
# Check specific strategy
if 'LSTM_Strategy' in STRATEGIES:
print("LSTM Strategy is available")A:
- LSTM/Transformer: 200+ samples minimum
- SVM/Ensemble: 100+ samples minimum
- RL: 500+ samples minimum
- Traditional strategies: 20-50 samples
A: ML strategies need training data. They will return 0 (hold) until they have enough historical data to train. Check:
- Sufficient data:
len(df) >= min_samples - Training completed: Check strategy's
_is_trainedflag - Data quality: Ensure no NaN values
A: Yes, but consider:
- ML strategies are computationally intensive
- They require sufficient data for training
- Consider using simpler strategies for real-time trading
- Use ML strategies for analysis and optimization
A: Ensemble combines multiple models (Random Forest + Gradient Boosting) for more robust predictions. It's generally more stable but slower than individual models.
A: Depends on:
- Genetic Algorithm: 5-30 minutes (population_size × generations)
- Optuna: 10-60 minutes (n_trials)
- Walk-Forward: 15-60 minutes (number of periods)
- Monte Carlo: 1-5 minutes (n_simulations)
A: Yes! Both Genetic Optimizer and Hyperparameter Optimizer support multiple parameters:
param_bounds = {
'fast_period': (10, 30),
'slow_period': (40, 80),
'atr_period': (10, 20)
}A:
- Genetic Algorithm: Population-based, good for continuous parameters
- Optuna: Tree-structured Parzen Estimator, better for mixed parameter types (int, float, categorical)
A:
- High sensitivity score: Parameter has large impact on performance
- Low sensitivity score: Parameter has minimal impact
- Optimal value: Best parameter value found
- Impact range: Min/max performance variation
A: Recommended but not required. Monitoring helps:
- Detect strategy failures early
- Track performance metrics
- Identify execution issues
- Monitor strategy health
A: Minimal (<1ms per signal). Monitoring is lightweight and designed for production use.
A:
- Healthy: Strategy working normally
- Warning: Some issues detected (moderate errors, slow execution)
- Critical: Serious issues (high error count)
- Unknown: No recent activity
A: Yes! The code generator creates Python code that you can save to a file and import:
generator = CodeGenerator(builder)
code = generator.generate_code()
# Save to file
with open('my_strategy.py', 'w') as f:
f.write(code)A: Yes! You can modify templates or create new ones by extending StrategyTemplate.
A: Yes! The builder is a Python API. The UI is a future enhancement.
A: By default, in a local marketplace/ directory as JSON files. You can extend this to use a database.
A: Currently, marketplace uses local storage. For private sharing, you'd need to implement authentication/authorization.
A: Simple average of all ratings. Future versions may include weighted averages or Bayesian ratings.
A: Possible reasons:
- ML strategies require training
- Large datasets
- Complex optimization
- Multiple timeframes
Solutions:
- Use simpler strategies for quick tests
- Reduce dataset size
- Use parallel processing (
EnhancedBacktestService) - Cache indicator calculations
A: Yes! Use EnhancedBacktestService with use_parallel=True:
service = EnhancedBacktestService(data_provider, use_parallel=True, max_workers=4)A:
- LSTM: ~100-500 MB (depends on model size)
- Transformer: ~200-1000 MB (depends on model)
- RL: ~50-200 MB
- SVM/Ensemble: ~10-50 MB
A: Install TensorFlow: pip install tensorflow. This is optional unless using LSTM strategies.
A: Check:
- Strategy name is correct (case-sensitive)
- Strategy is in registry:
'StrategyName' in STRATEGIES - Dependencies are installed (for ML strategies)
A: Possible causes:
- Parameter bounds too narrow
- Fitness function not sensitive to parameters
- Not enough generations/trials
- Local optimum
Solutions:
- Widen parameter bounds
- Check fitness function
- Increase generations/trials
- Try different optimization method
A: Check:
- Sufficient training data
- Strategy is trained:
strategy._is_trained == True - Data quality (no NaN, sufficient history)
- Prediction threshold not too high
A: This might indicate:
- Strategy overfitting to training data
- Market regime changes
- Insufficient training data
- Strategy not robust
Solutions:
- Use simpler strategies
- Increase training period
- Add regularization
- Try different time periods
A:
- Start with simple strategies
- Optimize parameters
- Run sensitivity analysis
- Validate with walk-forward
- Assess risk with Monte Carlo
- Monitor in production
A:
- Development: Optimize frequently
- Production: Re-optimize monthly/quarterly or when market conditions change
- Real-time: Use fixed parameters, optimize separately
A: Consider:
- ML strategies need retraining periodically
- They're computationally intensive
- Simpler strategies may be more reliable
- Use ML for analysis, simpler strategies for execution
A: Yes! Create a custom strategy that combines signals:
class CombinedStrategy(IStrategy):
def signal(self, df):
signal1 = strategy1.signal(df)
signal2 = strategy2.signal(df)
# Combine logic
return combined_signalA: Extend the strategy's indicators() method:
def indicators(self, df):
df = super().indicators(df)
df['MyIndicator'] = calculate_my_indicator(df)
return dfA: Yes! Implement IDataProvider interface:
class MyDataProvider(IDataProvider):
def get_data(self, symbol, start, end, interval):
# Your implementation
return dfA:
- Check documentation:
docs/ - Review examples:
examples/ - Run validation:
python scripts/validate_installation.py - Check GitHub issues
- Review code docstrings
A:
- Run validation script to verify installation
- Check if it's a known issue
- Create GitHub issue with:
- Error message
- Steps to reproduce
- Environment details
- Validation script output
Last Updated: January 2026
Version: 3.1.0