Overall Performance

The strategy executed a total of 15,015 trades, generating a total profit of 47,683.24 points before slippage. However, after accounting for slippage, the net profit dropped significantly to 11,647.24 points, reflecting a substantial slippage impact of 36,036 points (75.57%).

The average PnL per trade also saw a dramatic reduction due to slippage, falling from 3.18 points (before slippage) to just 0.78 points (after slippage). Despite this, the profit factor remains strong at 1.85, indicating that profitable trades still outweigh losing trades in magnitude. The win rate stands at 48.44%, while the loss rate is 51.56%, highlighting a balanced risk-reward approach. However, the maximum drawdown increased to 145.57 points, suggesting deeper losses during unfavorable periods.

Risk & Drawdown Analysis:

• Largest Profit in a Single Trade: 18.53 points
• Largest Loss in a Single Trade: -9.27 points
• Average Profit per Winning Trade: 14.25 points
• Average Loss per Losing Trade: -7.22 points

The average profit per winning trade is nearly twice the average loss per losing trade, which contributes to the positive profit factor. However, the high drawdown and slippage impact indicate execution inefficiencies that should be addressed.

Slippage Impact Summary:

The strategy suffered a severe slippage impact of 36,036 points, reducing overall profitability by 75.57%. This suggests that the execution environment, order book liquidity, or bid-ask spreads may be significantly affecting realized gains. Optimizing order execution methods or exploring lower-slippage trading instruments could help mitigate these losses.

Best & Worst Performing Trades:

• Top 5 Most Profitable Trades: (Before Slippage: 18.53 points, After Slippage: 16.13 points)
• Top 5 Worst Loss Trades: (Before Slippage: -9.27 points, After Slippage: -11.67 points)

Interestingly, even the best trades suffered a 2.4-point reduction due to slippage, while the worst losses deepened by around 2.4 points each. This highlights that slippage is consistently eating into both profitable and losing trades, impacting overall performance.

Key Takeaways & Recommendations:

• Slippage is a major concern, eroding a substantial portion of profits.
• Addressing execution methods, improving liquidity selection, or optimizing order types (e.g., limit vs. market) could improve net profitability.
• Despite slippage, the strategy is structurally profitable, with a strong profit factor of 1.85 and an average winning trade nearly double the average losing trade.
• High drawdown (145.57 points) needs mitigation, possibly through dynamic position sizing or better stop-loss adjustments.
• Short-term execution strategies should be optimized as slippage disproportionately affects short-duration trades.

1. Slippage Impact Per Trade Category

Insights

• Slippage reduces profitable trades by 16.86% on average, meaning even the best trades lose a significant portion of their potential.
• The impact on losing trades is even worse, deepening losses by 33.2%, making risk management more challenging.
• The worst trades suffer nearly double the slippage impact compared to the best trades, indicating that slippage exacerbates bad executions more than good ones.

2. Slippage Impact by Holding Time

Insights

• Shorter trades (< 5 min) suffer the most, losing ~73.8% of profits due to slippage.
• Trades held between 5-10 minutes perform better but still lose 42.6% of their gains.
• Longer holding periods (> 10 min) have the least impact (~18.7%), suggesting that avoiding ultra-short scalping trades could improve net performance.

We will add additional hurdle now !! Drawdown !!

During our testing, we observed that drawdown does not scale linearly with the number of programs executed. For example, when hedging with one point and one program, the maximum drawdown recorded was 84 points. If the drawdown increased proportionally, then with one point and two programs, it should have been 168 points, but our tests show otherwise.

When we increased the number of programs to four for the same one-point hedging, the maximum drawdown remained below 150 points, whereas technically, it should have been 336 points. This non-linear drawdown behavior suggests that increasing the number of programs and points can effectively reduce overall drawdowns. This finding is crucial for risk management and portfolio optimization.

Key Insight: By infusing more programs and distributing points effectively, we can strategically bring down drawdowns, making the system more robust.

About Slippage

Similarly, when incorporating more programs, we noticed an improved handling of slippage. In a hedging scenario, if we lose some points due to stop-loss execution, open positions in other programs provide an opportunity to recover or even profit from these movements.

Key Insight: This ensures that larger slippages can be mitigated more efficiently, as positions in other programs counteract losses, leading to a more balanced risk-reward strategy.

Manual Validation & System Optimization

The backtesting system has been carefully designed to avoid both overfitting and underfitting, ensuring consistency across different market conditions. To validate this, we manually tested and verified each day's trades, checking execution details, performance, and drawdown calculations.

It's not over here and we are not comprimised hence we ran through manual testing of each and every day for the number of trades taken and calculated and verified .

Finaly , We also took help from the technology back to fine tue the entry and exits with the our finest results and we will place this strategy as the fourth statergy to maximize the profit out of other 3 three programs concetrate on the minimizing the drawdowns and this will always will look for the evolvement as the market evolves.

Example:

            
            import numpy as np
            import pandas as pd
            import tensorflow as tf
            from tensorflow.keras.models import Model
            from tensorflow.keras.layers import Input, Dense, Dropout, LayerNormalization, MultiHeadAttention, BatchNormalization
            from tensorflow.keras.callbacks import EarlyStopping
            from tensorflow.keras.regularizers import l2
            from sklearn.preprocessing import MinMaxScaler
            from sqlalchemy import create_engine
            import os
            import joblib
            import optuna
            import logging
            import json
            
            logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
            
            DB_PARAMS = {
              "dbname": "your_database_name",
              "user": "your_username",
              "password": "your_password",
              "host": "your_host_address",
              "port": "your_port_number",
          }          
            
            DB_URL = f"postgresql://{DB_PARAMS['user']}:{DB_PARAMS['password']}@{DB_PARAMS['host']}:{DB_PARAMS['port']}/{DB_PARAMS['dbname']}"
            engine = create_engine(DB_URL)
            
            def fetch_data(instrument_id):
                try:
                    query = f'''
                     SELECT date, open, high, low, close FROM general.historic_futures
                     WHERE instrumentidentifier = '{instrument_id}' ORDER BY date;
                    '''
                    df = pd.read_sql(query, engine)
                    logging.info(f"Fetched data for instrument: {instrument_id}")
                    return df
                except Exception as e:
                    logging.error(f"Error fetching data for {instrument_id}: {e}")
                    return pd.DataFrame()
            
            def prepare_data(df, sequence_length, scaler):
                df = df.drop(['date'], axis=1)
                scaled_data = scaler.transform(df[['open', 'high', 'low', 'close']])
                X, y = [], []
                for i in range(sequence_length, len(scaled_data)):
                    X.append(scaled_data[i - sequence_length:i])
                    y.append(scaled_data[i])
                return np.array(X), np.array(y)
            
            def tune_scaler_with_optuna(instrument_id, df):
                def objective(trial):
                    min_range = trial.suggest_float('min_range', 0, 0.5)
                    max_range = trial.suggest_float('max_range', 0.5, 1)
                    scaler = MinMaxScaler(feature_range=(min_range, max_range))
                    scaler.fit(df[['open', 'high', 'low', 'close']])
                    return 0
                study = optuna.create_study(direction="minimize")
                study.optimize(objective, n_trials=20)
                best_params = study.best_params
                best_scaler = MinMaxScaler(feature_range=(best_params['min_range'], best_params['max_range']))
                best_scaler.fit(df[['open', 'high', 'low', 'close']])
                scaler_filename = f"models/{instrument_id}_scaler.pkl"
                os.makedirs("models", exist_ok=True)
                joblib.dump(best_scaler, scaler_filename)
                logging.info(f"Tuned scaler saved for {instrument_id} with range: {best_params['min_range']} - {best_params['max_range']}")
                return best_scaler
            
            def create_transformer_model(input_shape, num_heads=2, key_dim=64, ff_dim=128, num_layers=4, l2_reg=0.01, dropout_rate=0.1, activation='relu'):
                inputs = Input(shape=input_shape)
                x = inputs
                for _ in range(num_layers):
                    x = transformer_encoder(x, num_heads=num_heads, key_dim=key_dim, ff_dim=ff_dim, l2_reg=l2_reg, dropout_rate=dropout_rate, activation=activation)
                outputs = Dense(4)(x[:, -1])  # Predicting 4 values (open, high, low, close)
                model = Model(inputs=inputs, outputs=outputs)
                return model
            
            def transformer_encoder(inputs, num_heads, key_dim, ff_dim, rate=0.1, l2_reg=0.01, dropout_rate=0.1, activation='relu'):
                attn_output = MultiHeadAttention(num_heads=num_heads, key_dim=key_dim)(inputs, inputs)
                attn_output = Dropout(dropout_rate)(attn_output)
                attn_output = BatchNormalization()(attn_output)
                out1 = LayerNormalization(epsilon=1e-6)(inputs + attn_output)
            
                ffn_output = Dense(ff_dim, activation=activation, kernel_regularizer=l2(l2_reg))(out1)
                ffn_output = Dense(inputs.shape[-1], kernel_regularizer=l2(l2_reg))(ffn_output)
                ffn_output = Dropout(dropout_rate)(ffn_output)
                ffn_output = BatchNormalization()(ffn_output)
                return LayerNormalization(epsilon=1e-6)(out1 + ffn_output)
            
            def save_model_and_hyperparameters(model, instrument_id, best_params):
                model_dir = f"models/{instrument_id}"
                os.makedirs(model_dir, exist_ok=True)