Dutch Algotrading

Can you earn 3.9 Million dollar too with this linear Regression Candles & UT Bot Indicator strategy? (Patreon)

Published:

2023-09-23 18:28:49

Imported:

2026-06

Tags:

backtes files

haven't archived this post yet. have a subscription? use the importer!

Downloads

58.MillionSpot.7z
58.MillionFutures.7z

Missing 2 files, as this post has not yet been imported.

Content

Introduction

In this post I am testing a trading strategy with a suggested 99.8 % win rate and that made someone 3.9 million us dollar.
Let's find out if what he says is probable on my setup too.

Where I got this strategy from

The strategy that I am about to show you, was initially inspired by the following Youtube video: The Trading Strategy He Says Made Him $3.9 Million with 99.8% Win Rate! Testing For 100 Trades

And brought me to this video where that other one was inspired from: Best Indicator 99.8% win rate That Earned me a Staggering $3.9 Million!

The strategy itself is based on two indicators that are available on Tradingview. And let me show you these now:

The first indicator is the UT bot alerts by QuantNomad, which is derived from UT bot. The settings of this indicator are "Key value: 2", "ATR period: 1".
And the second indicator used is the Linear regression candles by Ugurvu In this indicator the signal smoothing is set to 7

Interestingly enough, when I was searching the internet for more information on these indicators, I stumbled on yet two other Youtube video's that described almost exactly the same strategy.

The first video was posted around 9 months ago.

This video is called 'UT bot Alerts & Humble LinReg Candles indicator strategy! high accuracy strategy'.

Three months after that, there was another video posted called "Secret Linear Regression Candles Strategy TradingView in 2023 [EASY Money Maker]".

So apparently, a trading algorithm that uses a combination of these two indicators is very popular.

And if there are already four video's with this same trading strategy presented on Youtube, then why don't I quickly jump on the same bandwagon also. Just to find out if this has a high probability to make us some money in the Crypto market as well.

So let's do a real man's test and use about 50 crypto pairs, multiple timeframes and the longest backtest daterange for crypto assets possible.

Buy and sell signals

I already showed you the used indicators here, but have not told you how to use these and what the trading rules are.

These rules are already extensively eplained in the other video's. And between these videos are only some minor differences on how to interpret the signals, when to buy and sell and how to set your stop loss and take profit.

But because I am programming this strategy into an algorithm to autmatically test - I'll quickly explain my rules here as well. Just to keep you on the same page as I am.

Long signal

The buy signal for this strategy is when the linear regression line is inclining and the 'UT bot alerts' gives a buy signal. There is nothing said about candles being above or below the regression line or so.

Just buy when the line goes upwards and the UT bot gives a buy signal.

Long trade

First condition: regression line has an inclined angle (upward moving)
Second condition: UT bot gives buy signal

Stop loss:

Bullish UT Bot trailing stop line

Exit long:

When the sell signal of the UT bot goes off

Short signal

The Short signal is the opposite of the buy signal. If the regression line should decline and the UT bot gives a sell signal. If this happens, then to do a short trade.

Short trade

First condition: the regression line declines
Second condition: when the sell signal of the UT bot goes off

Stop loss:

Bearish UT Bot trailing stop line

Exit short:

When the buy signal of the UT bot goes off

Stop loss / Take profit

Concerning the stop loss and take profit...

In some videos there is advised to set the stop loss below the last swing low of this trade. In these cases the regression candles were used to determine the last swing low. But I found that these regression candles do not really show the actual real world lowest low of the true candles. These real candles lows are actually lower and might cause the trade to unnecessary stop out. In my case I think that using the UT Bot alerts indicator is a better way to determine the stop loss level. And I show you why in a moment.

The explanation of the take profit point is also explained differently in different videos. Sometimes the trade exit point is when the regression line moves down and there is an sell signal by the UT bot in long trades.

Another exit point that is explained is to exit if the first regresson candle is red in a long trade.

But again, these regression candles do not represent the actual true candle values at that time. So the actual exit value can be totally different in the trade.

SInce there is no real agreement on these exit points I will just use the UT Bot indicator as an initial stop and also trailing stop loss.

Time frames

And concerning the timeframe of this strategy. In all video's only the 5 and 15 minute timeframes are used. But as you already know from my videos, this will not stop me from testing a strategy on other timeframes as well.

In this video I will try to create a strategy that tries to resembe the 3.9 million dollar strategy as closely as possible.

But for that I need to program the suggested indicators first.

Creating the indicators for use with the backtesting engine

As far as I could find, the current TA libraries for Python do not have the UT Bot and Regression candles indicators.

Searching on the Internet also did not provide me with good examples or code to create these in a dataframe. So it was up to me to create these indicators so that I could use them for use with the tradingbot.

Fortunately the indicators used on Tradingview gave access to the Pinescript code. So I took this code and rewrote all these into separate Python function.

That's when I also discovered that the UT Bot alerts indicator was actually an adjusted copy of the UT Bot indicator. Which is almost similar to the supertrend indicator. And even better, I also stumbled on the Chandelier exit indicator of which I think the UT Bot indicator is an exact copy of.

FOr example: Here you see the UT Bot, Chandelier exit and the supertrend indicators on your screen. Each with the exact same ATR lenght and multiplier. And they all look pretty much the same to me here. Just look at all the values at a certain point. They are all the same. There are some minor exceptions on the chart plotting format here and there... But I assume that this will not interfere with the buy and sell signals.

And after seeing this I hope that you now know why I decided to use the UT Bot trailing stop as my initial stop loss level here. It's a pretty decent indicator to use for an initial and trailing stop loss.

Now, I could make it myself easy and go for the Supertrend indicator, but instead decided to still make the UT Bot trailing stop indicator. Just to resemble the original strategy closely.

I also did research if the regression candle indicator was available in a TA library. But in the end I also had to build this indicator by scratch.

And each of these indicators were inspired by their Tradingview Pinescripts. Just so you know.

The code below will not be shown in the video's anymore. This will only available for my Patrons.

# Import modules
import pandas as pd
from pandas import DataFrame
import numpy as np
import pandas_ta as pta

# Create a dataframe, based on 5 minute candles
df = pd.read_json("./BTC_USDT-1d.json")

# Change column names, datetime and show the first 5 dataframe rows
df.columns=['date','open','high','low','close','volume']
df['date']=(pd.to_datetime(df['date'],unit='ms'))
df.head()

df.columns=========Index(['date', 'open', 'high', 'low', 'close', 'volume'], dtype='object')

# This is the UT Bot trailing stop indicator
def ut_bot_trailing_stop(df, length=11, multiplier=3):
    df['xATR'] = (df['high'] - df['low']).ewm(span=length).mean() # Calculating the atr in this function
    # df['xATR'] = df['atr'].rolling(window=length).mean() # Using an atr column if available
    df['nLoss'] = multiplier * df['xATR']

    xATRTrailingStop = 0.0
    trailing_stops = []

    for i in range(len(df)):
        src = df['close'].iloc[i]
        
        if i == 0:
            xATRTrailingStop = src
        else:
            if src > xATRTrailingStop and df['close'].iloc[i - 1] > xATRTrailingStop:
                xATRTrailingStop = max(xATRTrailingStop, src - df['nLoss'].iloc[i])
            elif src < xATRTrailingStop and df['close'].iloc[i - 1] < xATRTrailingStop:
                xATRTrailingStop = min(xATRTrailingStop, src + df['nLoss'].iloc[i])
            else:
                if src > xATRTrailingStop:
                    xATRTrailingStop = src - df['nLoss'].iloc[i]
                else:
                    xATRTrailingStop = src + df['nLoss'].iloc[i]
        
        trailing_stops.append(xATRTrailingStop)

    df['trailing_stop'] = trailing_stops
    return df

# Example usage:
# Replace 'your_df' with your actual DataFrame, 'atr_period' with the ATR period, and 'key_value' with the key value.
# df = ut_bot_trailing_stop(your_df, length=11, multiplier=3)

df = ut_bot_trailing_stop(df, length=1, multiplier=2)

# This is the Linear regression candles indicator
import pandas as pd
import numpy as np

def calculate_linreg_candles(df, signal_length=11, sma_signal=True, lin_reg=True, linreg_length=11):
    # Create a copy of the original DataFrame to avoid modifying the input DataFrame
    df_copy = df.copy()
    
    # Calculate linear regression coefficients for open, high, low, and close
    if lin_reg:
        df_copy['bopen'] = df_copy['open'].rolling(window=linreg_length).apply(
            lambda x: np.polyfit(np.arange(len(x)), x, 1)[1] + np.polyfit(np.arange(len(x)), x, 1)[0] * (len(x) - 1)
        )
        
        df_copy['bhigh'] = df_copy['high'].rolling(window=linreg_length).apply(
            lambda x: np.polyfit(np.arange(len(x)), x, 1)[1] + np.polyfit(np.arange(len(x)), x, 1)[0] * (len(x) - 1)
        )
        
        df_copy['blow'] = df_copy['low'].rolling(window=linreg_length).apply(
            lambda x: np.polyfit(np.arange(len(x)), x, 1)[1] + np.polyfit(np.arange(len(x)), x, 1)[0] * (len(x) - 1)
        )
        
        df_copy['bclose'] = df_copy['close'].rolling(window=linreg_length).apply(
            lambda x: np.polyfit(np.arange(len(x)), x, 1)[1] + np.polyfit(np.arange(len(x)), x, 1)[0] * (len(x) - 1)
        )
    else:
        df_copy['bopen'] = df_copy['open']
        df_copy['bhigh'] = df_copy['high']
        df_copy['blow'] = df_copy['low']
        df_copy['bclose'] = df_copy['close']
    
    # Determine whether to plot a green or red candle
    df_copy['r'] = df_copy['bopen'] < df_copy['bclose']
    
    # Calculate the signal line using SMA or EMA
    if sma_signal:
        df_copy['regression_line'] = df_copy['bclose'].rolling(window=signal_length).mean()
    else:
        df_copy['regression_line'] = df_copy['bclose'].ewm(span=signal_length, adjust=False).mean()
    
    return df_copy

# Example usage:
# Assuming 'df' is your Pandas DataFrame with the specified columns
# You can call the function like this:
# result_df = calculate_linreg_candles(df)

# Add the indicator to the dataframe with the proposed values
df = calculate_linreg_candles(df, signal_length=7, sma_signal=True, lin_reg=True, linreg_length=11)

Print the dataframe with the custom build indicators

After building the functions for the indicators and adding them to the dataframe, I can show them with a plotly graph to visually check if everything looks as on the tradingview chart.

The next plot showst the graph with the regression candles.

import numpy as np
import pandas as pd
import plotly.graph_objects as go

# Define the time range you want to plot
start_date = '2022-8-26'
end_date = '2023-01-09'

# Filter the DataFrame based on the time range
df_filtered = df[(df['date'] >= start_date) & (df['date'] <= end_date)]

# Create the Plotly figure
fig = go.Figure()

# Add candlestick trace
# fig.add_trace(go.Candlestick(x=df_filtered['date'],
#                              open=df_filtered['open'],
#                              high=df_filtered['high'],
#                              low=df_filtered['low'],
#                              close=df_filtered['close'],
#                              name='Candlesticks'))

# Add reg candlestick trace
fig.add_trace(go.Candlestick(x=df_filtered['date'],
                             open=df_filtered['bopen'],
                             high=df_filtered['bhigh'],
                             low=df_filtered['blow'],
                             close=df_filtered['bclose'],
                             name='Reg Candlesticks'))

# Add Reg signal
fig.add_trace(go.Scatter(x=df_filtered['date'],
                         y=df_filtered['regression_line'],
                         mode='lines',
                         name='Reg Signal'))

# Add ut trailingstop
fig.add_trace(go.Scatter(x=df_filtered['date'],
                         y=df_filtered['trailing_stop'],
                         mode='lines',
                         name='ut trailing_stop'))


# Disable the x-axis range slider
fig.update_layout(xaxis_rangeslider_visible=False)

fig.show()

And this plot follows the original Tradingview chart with the regression candles pretty closely.

Now what about a chart that uses the true candles...

import numpy as np
import pandas as pd
import plotly.graph_objects as go

# Define the time range you want to plot
start_date = '2022-8-26'
end_date = '2023-01-09'

# Filter the DataFrame based on the time range
df_filtered = df[(df['date'] >= start_date) & (df['date'] <= end_date)]

# Create the Plotly figure
fig = go.Figure()

# Add candlestick trace
fig.add_trace(go.Candlestick(x=df_filtered['date'],
                             open=df_filtered['open'],
                             high=df_filtered['high'],
                             low=df_filtered['low'],
                             close=df_filtered['close'],
                             name='Candlesticks'))

# # Add reg candlestick trace
# fig.add_trace(go.Candlestick(x=df_filtered['date'],
#                              open=df_filtered['bopen'],
#                              high=df_filtered['bhigh'],
#                              low=df_filtered['blow'],
#                              close=df_filtered['bclose'],
#                              name='Reg Candlesticks'))

# Add Reg signal
fig.add_trace(go.Scatter(x=df_filtered['date'],
                         y=df_filtered['regression_line'],
                         mode='lines',
                         name='Reg Signal'))

# Add ut trailingstop
fig.add_trace(go.Scatter(x=df_filtered['date'],
                         y=df_filtered['trailing_stop'],
                         mode='lines',
                         name='ut trailing_stop'))


# Disable the x-axis range slider
fig.update_layout(xaxis_rangeslider_visible=False)

fig.show()

As you can see, this plot looks also looks quite nice and very similar to the plot you can find on the Tradingview chart.

So I think I am on the correct path here.

However, there are still some things to do. Like determining the trend direction of the signal line of the regression candles, the UT Bot indicator signals and finally ofcourse the signals to do a long or short trade.

Now, for these I have created other functions that add this information to the dataframe.

# Determine the direction of the trend
def trend_detection(df, column):
    """
    Add a 'trend' column to a DataFrame based on the line trend.

    Parameters:
    df (pd.DataFrame): The DataFrame containing the 'date' and the existing column to check.
    column (str): The name of the existing column containing the values to check.

    Returns:
    pd.DataFrame: The input DataFrame with an additional 'trend' column.
    """
    if df.empty or column not in df.columns:
        return df  # Return the original DataFrame if it's empty or the SMA column does not exist

    # Initialize the 'trend' column with 'Steady'
    df['trend'] = 'Indecisive'

    # Find where SMA is rising or falling and update the 'trend' column accordingly
    rising_mask = df[column] > df[column].shift(1)
    falling_mask = df[column] < df[column].shift(1)

    df.loc[rising_mask, 'trend'] = 'Rising'
    df.loc[falling_mask, 'trend'] = 'Falling'

    return df

# Example usage:
# Assuming you have a DataFrame 'df' with an existing 'sma' column:
# df_with_trend = trend_detection(df, 'sma')
# print(df_with_trend)

df = trend_detection(df, 'regression_line')
df

============

import pandas as pd

def trade_signals(df):
    # Create a new column 'trade_signal' filled with empty strings
    df['trade_signal'] = ''

    # Iterate through the DataFrame and apply the conditions
    for index, row in df.iterrows():
        # In this example there are three fields used to determine the long/short signal.
        # A string (trend), an integer (ut_direction) and a boolean (ut_bot_signal).
        if row['trend'] == 'Rising' and row['ut_direction'] == 1 and row['ut_bot_signal']:
            df.at[index, 'trade_signal'] = 'Go_long'
        elif row['trend'] == 'Falling' and row['ut_direction'] == 0 and row['ut_bot_signal']:
            df.at[index, 'trade_signal'] = 'Go_short'
        else:
            df.at[index, 'trade_signal'] = 'Do_nothing'

    return df

# Example usage:
# Assuming you have a DataFrame named 'df' with the specified columns
# Call the function to add trade signals
# df = trade_signals(df)

# Access the 'trade_signal' column and its values
# trade_signals = df['trade_signal']

# Now, df_with_signals contains the updated DataFrame with the 'trade_signal' column.
# trade_signals contains the values in the 'trade_signal' column.

df = trade_signals(df)=========

import pandas as pd

def exit_signals(df):
    # Create a new column 'trade_signal' filled with empty strings
    df['exit_signal'] = ''

    # Iterate through the DataFrame and apply the conditions
    for index, row in df.iterrows():
        if row['ut_direction'] == 0 and row['ut_bot_signal']:
            df.at[index, 'exit_signal'] = 'Exit_long'
        elif row['ut_direction'] == 1 and row['ut_bot_signal']:
            df.at[index, 'exit_signal'] = 'Exit_short'
        else:
            df.at[index, 'exit_signal'] = 'Do_nothing'

    return df

# Example usage:
# Assuming you have a DataFrame named 'df' with the specified columns
# Call the function to add exit signals
# df = exit_signals(df)

# Access the 'exit_signal' column and its values
# trade_signals = df['exit_signal']

# Now, df contains the updated DataFrame with the 'exit_signal' column.
# exit_signals contains the values in the 'exit_signal' column.

df = exit_signals(df)
df.tail(55)

==========

Here you see an extract of the dataframe where there are long and short signals. These signals are based on the direction of the regression candles trend and the UT Bot signals.

You can check these signals by yourself on Tradingview, just to check for yourself if my calculations are correct.

# Here the entry signals
df[['date', 'close', 'regression_line','trend', 'ut_direction', 'ut_bot_signal', 'trade_signal']][(df['trade_signal'] == 'Go_long') | (df['trade_signal'] == 'Go_short')].tail(20)

===========

Let me show you all these signals in a plot one more time here.

import numpy as np
import pandas as pd
import plotly.graph_objects as go

# Define the time range you want to plot
start_date = '2022-06-26'
end_date = '2023-01-09'

# Filter the DataFrame based on the time range
df_filtered = df[(df['date'] >= start_date) & (df['date'] <= end_date)]

# Create the Plotly figure
fig = go.Figure()

# Set the layout to a larger size
fig.update_layout(
    width=1000,  # Set the width to 1200 pixels
    height=800,  # Set the height to 800 pixels
)

# Add candlestick trace
fig.add_trace(go.Candlestick(x=df_filtered['date'],
                             open=df_filtered['open'],
                             high=df_filtered['high'],
                             low=df_filtered['low'],
                             close=df_filtered['close'],
                             name='Candlesticks'))

# Add Reg signal
fig.add_trace(go.Scatter(x=df_filtered['date'],
                         y=df_filtered['regression_line'],
                         mode='lines',
                         name='Reg Signal'))

# Add ut trailingstop
fig.add_trace(go.Scatter(x=df_filtered['date'],
                         y=df_filtered['trailing_stop'],
                         mode='lines',
                         name='ut trailing_stop'))

# Calculate a vertical position for the Go_long and Go_short signals
above_chart = df_filtered['high'].max() * 1.10

# Define a vertical offset for Go signals
offset = 0.06 * (df_filtered['high'].max() - df_filtered['high'].min())

# Add green vertical lines for "Go_long" trade signals above the chart
go_long_indices = df_filtered[df_filtered['trade_signal'] == 'Go_long'].index
fig.add_trace(go.Scatter(x=df_filtered.loc[go_long_indices]['date'],
                         y=np.full(len(go_long_indices), above_chart + offset),
                         mode='markers+text',
                         text='Go_long',
                         textposition='top left',
                         marker=dict(color='green'),
                         name='Go_long Signals'))

# Add red vertical lines for "Go_short" trade signals above the chart
go_short_indices = df_filtered[df_filtered['trade_signal'] == 'Go_short'].index
fig.add_trace(go.Scatter(x=df_filtered.loc[go_short_indices]['date'],
                         y=np.full(len(go_short_indices), above_chart + offset),
                         mode='markers+text',
                         text='Go_short',
                         textposition='top left',
                         marker=dict(color='red'),
                         name='Go_short Signals'))

# Calculate a vertical position for the Exit_long and Exit_short signals
below_chart = df_filtered['low'].min() * 0.90

# Add blue vertical lines for "Exit_long" exit signals below the chart
exit_long_indices = df_filtered[df_filtered['exit_signal'] == 'Exit_long'].index
fig.add_trace(go.Scatter(x=df_filtered.loc[exit_long_indices]['date'],
                         y=np.full(len(exit_long_indices), below_chart),
                         mode='markers+text',
                         text='Exit_long',
                         textposition='top left',
                         marker=dict(color='blue'),
                         name='Exit_long Signals'))

# Add yellow vertical lines for "Exit_short" exit signals below the chart
exit_short_indices = df_filtered[df_filtered['exit_signal'] == 'Exit_short'].index
fig.add_trace(go.Scatter(x=df_filtered.loc[exit_short_indices]['date'],
                         y=np.full(len(exit_short_indices), below_chart - offset),
                         mode='markers+text',
                         text='Exit_short',
                         textposition='top left',
                         marker=dict(color='yellow'),
                         name='Exit_short Signals'))

# Disable the x-axis range slider
fig.update_layout(xaxis_rangeslider_visible=False)

fig.show()

Putting it all together in code for the trading bot

So now that it looks like all entry and exit signals for long and short trades are correct. Let's code this into something that can be used by the trading and backtesting bot.

Just like always I will do this offscreen so I wont tire you with long hours of coding.

I will return with the backtest results of this strategy on futures and spot markets next. So don't move an inch. I'll be right back.

Initial backtest results

And here I am. Back with the results of the backtests on spot and futures markets.

And I assume that you are very curious about the results I got from testing this trading strategy. Is it really probable to attain at least a fraction of that 3.9 million dollars that was presented in that Youtube video..?

Futures trading

The initial backtest for this trading strategy has the following results (see picture below).

If you want to make a profit with this strategy, then according to my tests, you should stick to the higher timeframes. Because the 1 day timeframe has the best results.

I also think that, if you want to use this strategy to make your own millions by hand, you should stick to these higher timeframes as well. Since using this strategy on the 5 and 15 minute timeframe will likely keep you busy the whole time. My testengine has made over 50.000 trades with the 50 pairs on the 5 minute timeframe. That's 10.000 trades on average per pair.

And then having the probability to see your funds slip away through your fingers during the process, because these lower timeframes have a 96% drawdown on my case.

Even the 1 day timeframe has only a 37% win rate here in my case. This is a little bit below average for a swing trading strategy, which I think this is. A swing trading strategy.

At some point, which I believe is the top of the last bull cycle, this strategy is slowly but surely giving back its gains to the markets. It had around 15.000 dollars at it's peak. But this strategy is apparently not able to profit from both bull and bear markets. Otherwise the endbalance should be even higher in my opinion.

And speaking about trading in both directions. I have tested strategies in the past that had more action trading both sides of the market. But as you can see from the paralellism chart, there are periods where the bot simply does not do much and apparently did not have trading signals during these lackluster times.

But I still have a second opportunity here and that is with spot trading.

Let's hope that this trading type get's a little bit closer to at least a million here...

Spot trading

Funny enough, spot trading also had the 1 day timeframe as it's best timeframe to make gains with this strategy. Add the interesting part here is that it had less trades, but actually more profits. Even thought the win percentage stayed almost the same.

Unfortunately, Spot trading has a slightly higher drawdown and some of the scoring ratio's do not score better than with futures trading. So this has higher probable gains, but also more risks involved.

The lower timeframes again prove to be the ones to be avoided since there are many trades made here. And I think they probably suffer a lot from false signals.

On the plot there is also shown that the major drawdown starts sometimes during the peak of the last bull cycle. It seems that this strategy is not capable of keeping the gains and the account slowly get's draines from its funds.

Just like in futures trading there are some pairs that pumped during the last cycle and this strategy managed to find these pumps in time. However if you traded this system by hand, then it's more luck then wisdom to find these opportunities.

The final thing I wanted to say here is that I forgot to mention in the beginning of this video that I had configured my ROI to take profit at 100% gains. I did not think trades were ever going to reach these gains so it was more a slight error in my thinking. But after seeing these exit reasons I was glad I made this mistake.

The exit signals based on the given strategy only has a small 30% win rate and is actually losing money. With an average negative profit of -2.76 percent. It's lucky that the ROI exit proves to be a much better predictor to exit a trade with profits.

And this made me optimistic on the next part of the process. Trying to figure out what the best ROI and Stop loss points are if I use the Bots build in percentage based exit mechanism.

Optimization

This time I optimized both the spot and futures trading version of this strategy since optimizing the daily timeframe does not take up a lot of time.

Both of these initial backtesting results were pretty close to each other and I wanted to find out of one of these could be optimized.

Now, you always can argue that only optimizing ROI and stop loss as exit points is not truly according to the strategy. But since the other videos are not really clear on how exits should actually do happen, I take the liberty here to add my own take on this. And sure, I could also try to optimize all the other parameters here, but I only do that if I initially find a real good performning strategy.

So here are the settings that the machine learnings optimization found for ROI and stop loss.

Again, optimizing theze parameters do not improve the strategies performance at all. Instead, these numbers are actually quite dissapointing. I always do Sharpe optimization but here it does not seem to be optimized at all. The Sortino ratio did. And also drawdown became a little bit less. But that's actually it.

Optimizing Futures trading is now my last resort to still get trust back in the system. And the optimization engine returned these proposed values as optimized.

But again, no improvement at all. Sortino has improved a lot and also the winrate and drawdown seem to give better percentages here. But I think it is still not enough to make millions with this strategy.

Interestingly enough both these optimized strategy versions have a score of 178.

If I look at the exit signals, ROI is stil the main reason that this algorithm makes money. But the much tighter stop loss and the proposed exit signal do stil drain a lot of capital back to the market. Something that still has to be improved with this strategy.

Conclusion and atrategy League

But I think this is enough for me now. I get a pretty good idea of the actual performance of this algo. Where in one of the video's it is said the maker earned 3.9 milion dollars with it.

Ofcourse my method is slightly different of that of the other videos and my way of working is to make a mechanical trading system that always trades on the same signals. The human factor, the correct pairs, point in time and a stroke of winning trades can be the cause that somebody actually can make millions with of this strategy. But the question is then if this is purely the result of somebody's professional trading habits or he or she is just insanely lucky.

Especially trading in the crypto markets...

But I will leave the answer up to you to decide what's the truth with these video's.

I have shown you my results and I know that I surely have gained something valuable and two additional indicators in my toolbox by testing this strategy.

You can always doublecheck my tests because I always upload all my results, files, strategy code, optimizatin settings and more to my Patreon site as a special addition for those who supports my work. With these files, you can also test this strategy on your own setup to see of this strategy will actually work for you.

And if you like what I do and want to show your small token of appreciation, then click the like button, subscribe and leave your opinion about this strategy in the comments section below. It is greatly appreciated and I Try to read and react to all your comments.

many thanks for watching this video and I see you in the next one.

Goodbye...