Multiple targets

[GogeiD]

Hi there! I am new to vectorbt (and python for that matter), so I am trying to start from the very basic to try to wrap my head around this awesome library. This is what I am trying to do: simulate an entry accompanied by four taking profit targets (taking 25% percent of size each time for simplicity), and an initial Stop Loss. The SL would adjust as the targets are hit: first (when TP1 is reached) SL would go to breakeven (entry) price then, when TP2 is hit SL would go to TP1 price, etc.

This is what I have managed to do so far:

• I have successfully created a dataframe containing all my entries as bool.
• I have successfully created a dataframe with the same shape as my entries containing ONE take profit target as float for each True entry index.
• I have successfully created a dataframe with the same shape as my entries, containing the stop loss as float for each entry.
• I have put all this together using vbt.Portfolio.from_signals with sl_stop and tp_stop and apparently it works as intended.

I am stuck now trying to add more than one target. I have tried to pass a list of floats instead of a single float to tp_stop, but I get a "source elided" kind of error. Then, I tried to pass a dictionary, but honestly didn't know what arguments or keys should I add, so the code keeps blowing.

Needless to say, I haven't been able to test the SL adjust part. I suspect I should use adjust_sl_func_nb but so far I am clueless about how to reference each stop, so the function can update the SL.

I have been through the examples, but maybe I am losing something. So if anyone can point me in the right direction, I'd greatly appreciate it.

Thanks a lot, and sorry for the newbie question.

[polakowo]

Hi and welcome @GogeiD,

you can work with only one SL/TP target per entry - you can't have multiple TP stops for a single entry signal. This also can't be properly represented using an array since this array must have a maximum of two dimensions, both of which are reserved for time and assets respectively. I will think of how to enable this.

But for now, you can construct your signals array to account for multiple TP signals. For example, you can call this function (using entries.vbt.signals.generate_ohlc_stop_exits(...)) to generate exits for 15% above the entry price, then do the same for 30%, 45%, etc. and combine all of them into a single exits array (exits = exits1.vbt | exits2.vbt | ...). Next, you need to create a size DataFrame, where elements at entry timestamps are 100 shares and at exit timestamps are say -25. Finally, you would need to pass accumulate=False (or make it an array where the value depends upon entry or exit) to from_signals such that your exit signals reduce the current position and not close it entirely. You then don't need to provide any tp_stop to from_signals since it's already incorporated into your exits. This way you can build complex signal logic.

Or, you can dynamically generate signals by defining your own signal_func_nb that returns signals for each timestamp depending upon some conditions. But you would need to read entry signals from your array, keep track of the entry price, etc.

[GogeiD]

OK @polakowo, thanks a lot for your help. So far, apparently I have managed to make the TP behave as I want them. Now I am up to the second part of my original post: the SL adjust.

Basically what I want is that when a take profit order is completed, the stop loss will be updated to the previous take profit setting. If it was the first take profit, then it is updated to the entry point of the position. For example, I have these settings:

stop-loss -10%
take profit 1: +10%
take profit 2: +20%
take profit 3: +30%
take profit 4: +40%

When the first take profit is completed, the stop loss is moved to the entry price. When the second take profit is completed, then the stop loss is moved to the first take profit target example: +10% from the original price; when 3rd TP is hit, the SL would be +20% from the original price (or approximately -10% from current price), and so on until the position is closed.

I didn't include the SL to entries.vbt.signals.generate_ohlc_stop_exits(...) in order to manage them through adjust_sl_func_nb. I think that the best option to know that a take profit order has been completed, is to track the current position as a percentage of the original position. So if this ratio drops to 75%, I know that the first TP has been reached, and I can update the SL to breakeven.

I couldn't find a way to reference the original position. So I thought of constructing a new DataFrame containing the position at each point. Then referencing would be easier. This is what I tried:

@njit
def adjust_sl_func_nb(c: AdjustSLContext):
    positions = pd.DataFrame().reindex_like(entries)
    positions.iloc[c.i, c.col] = c.position_now
    if c.position_now / positions.iloc[0, c.col] == 0.75:
        return signals.loc[c.curr_i, "T1"], False
    elif c.position_now / positions.iloc[0, c.col] == 0.5:
        return signals.loc[c.curr_i, "T2"] - signals.loc[c.curr_i, "T1"], False
    elif c.position_now / positions.iloc[0, c.col] == 0.25:
        return signals.loc[c.curr_i, "T3"] - signals.loc[c.curr_i, "T2"], False
    return c.curr_stop, c.curr_trail

Where signals is a DataFrame containing the targets for each entry. I put T2 - T1 because I understand that the returned tuple is a percentage under the current price; not up from the original price. Am I interpreting the updated SL correctly? I know this is not exactly what I want, but is as close as I can get given the variables from AdjustSLContext.

Anyway, this throws the following error:

def adjust_sl_func_nb(c: AdjustSLContext):
        positions = pd.DataFrame().reindex_like(entries)
        ^

During: resolving callee type: type(CPUDispatcher(<function adjust_sl_func_nb at 0x0000016AAA72ADC0>))
During: typing of call at D:\Coding\Envs\TradingEnv\lib\site-packages\vectorbt\portfolio\nb.py (2006)

During: resolving callee type: type(CPUDispatcher(<function adjust_sl_func_nb at 0x0000016AAA72ADC0>))
During: typing of call at D:\Coding\Envs\TradingEnv\lib\site-packages\vectorbt\portfolio\nb.py (2006)

During: resolving callee type: type(CPUDispatcher(<function adjust_sl_func_nb at 0x0000016AAA72ADC0>))
During: typing of call at D:\Coding\Envs\TradingEnv\lib\site-packages\vectorbt\portfolio\nb.py (2006)

During: resolving callee type: type(CPUDispatcher(<function adjust_sl_func_nb at 0x0000016AAA72ADC0>))
During: typing of call at D:\Coding\Envs\TradingEnv\lib\site-packages\vectorbt\portfolio\nb.py (2006)

During: resolving callee type: type(CPUDispatcher(<function adjust_sl_func_nb at 0x0000016AAA72ADC0>))
During: typing of call at D:\Coding\Envs\TradingEnv\lib\site-packages\vectorbt\portfolio\nb.py (2006)


File "..\..\..\..\Envs\TradingEnv\lib\site-packages\vectorbt\portfolio\nb.py", line 2006:
def simulate_from_signal_func_nb(target_shape: tp.Shape,
    <source elided>
                    )
                    sl_curr_stop[col], sl_curr_trail[col] = adjust_sl_func_nb(adjust_sl_ctx, *adjust_sl_args)
                    ^

I am guessing that the numba function doesn't like to work with DataFrames. So, what would be the most efficient way to reference the initial position of the trade?

Thanks for any insight on this. I am closer to understand how this works, but sometimes I hit a wall.

[polakowo]

Create a 2-dim array (with NumPy, not with pandas) for positions outside of adjust_sl_func_nb and pass it to this function using adjust_sl_args. The original position can be accessed at c.init_i and c.col (see all fields in https://vectorbt.dev/docs/portfolio/enums.html#vectorbt.portfolio.enums.AdjustSLContext).

[egrafeuille]

Hi GogeiD, I'm just looking for the same feature (multiple TPs), could you share with me your solution? Thanks a lot!

[GogeiD]

Hi @egrafeuille. Well, I pretty much followed the instructions made by Oleg. From my Dataframe containing the exit signals at different price targets, I generated a dictionary with arrays of boolean values that indicate a which timestamp the target was reached. For those exit signals, I used entries.vbt.signals.generate_ohlc_stop_exits. Then, I combined those arrays in one using the | operator.

To get the sizes for each exit, created an array that look for a True value and assign a predefined % amount, depending on which target it was referencing. Finally, I passed those arrays to vbt.Portfolio.from_signals.

I am going to past the code snippet below but, frankly, it won't make much sense to you since you don't know how the signals are structured, and honestly I am still pretty much new to Python, so I am sure there is a better way to do it. Also, bear in mind that I haven't updated vbt since I posted this, so I don't know how it's going to work with the current version. Anyway, I hope this helps a little!

for i in range(1, 5):
        out_dict = {}
        exit_data["tp_pct" + str(i)] = pd.pivot_table(
            signals, index=signals.index, columns=fields, values="T" + str(i)
        )
        exit_data["tp_pct" + str(i)] = exit_data["tp_pct" + str(i)].reindex(
            index=close.index
        )
        exit_data["exit_tp" + str(i)] = entries.vbt.signals.generate_ohlc_stop_exits(
            open=open,
            high=high,
            low=low,
            close=close,
            tp_stop=exit_data["tp_pct" + str(i)],
            until_next=False,
            skip_until_exit=True,
            out_dict=out_dict,
        )

        target_price[i - 1] = out_dict["stop_price"].fillna(method="ffill").to_numpy()

    exits = (
        exit_data["exit_tp1"]
        | exit_data["exit_tp2"]
        | exit_data["exit_tp3"]
        | exit_data["exit_tp4"]
    )

    size = (
        (entries * size_targets[1])
        + (exit_data["exit_tp1"] * size_targets[2])
        + (exit_data["exit_tp2"] * size_targets[3])
        + (exit_data["exit_tp3"] * size_targets[4])
        + (exit_data["exit_tp4"] * size_targets[5])
    )

[aurelien65]

Hello,
Thank you @GogeiD and @polakowo for the discussion.
However, I have questions about this implementation.

1. With this kind of exits for TP, the exit price is not the stop price but the close price. Is it possible to use the stop price as exit price with the implementation described above ?

2. When using the size type set to "Percent", it's based on the available resources and not on the amount of asset. How the size type can be modified to set a percentage of the amount of asset ?

Thanks for your help.
Regards,

Aurélien

[egrafeuille]

Thanks a lot GogeiD. El mar., 18 de octubre de 2022 4:14 p. m., GogeiD ***@***.***> escribió:

…

Hi @egrafeuille <https://github.com/egrafeuille>. Well, I pretty much followed the instructions made by Oleg. From my Dataframe containing the exit signals at different price targets, I generated a dictionary with arrays of boolean values that indicate a which timestamp the target was reached. For those exit signals, I used entries.vbt.signals.generate_ohlc_stop_exits. Then, I combined those arrays in one using the | operator. To get the sizes for each exit, created an array that look for a True value and assign a predefined % amount, depending on which target it was referencing. Finally, I passed those arrays to vbt.Portfolio.from_signals. I am going to past the code snippet below but, frankly, it won't make much sense to you since you don't know how the signals are structured, and honestly I am still pretty much new to Python, so I am sure there is a better way to do it. Also, bear in mind that I haven't updated vbt since I posted this, so I don't know how it's going to work with the current version. Anyway, I hope this helps a little! for i in range(1, 5): out_dict = {} exit_data["tp_pct" + str(i)] = pd.pivot_table( signals, index=signals.index, columns=fields, values="T" + str(i) ) exit_data["tp_pct" + str(i)] = exit_data["tp_pct" + str(i)].reindex( index=close.index ) exit_data["exit_tp" + str(i)] = entries.vbt.signals.generate_ohlc_stop_exits( open=open, high=high, low=low, close=close, tp_stop=exit_data["tp_pct" + str(i)], until_next=False, skip_until_exit=True, out_dict=out_dict, ) target_price[i - 1] = out_dict["stop_price"].fillna(method="ffill").to_numpy() exits = ( exit_data["exit_tp1"] | exit_data["exit_tp2"] | exit_data["exit_tp3"] | exit_data["exit_tp4"] ) size = ( (entries * size_targets[1]) + (exit_data["exit_tp1"] * size_targets[2]) + (exit_data["exit_tp2"] * size_targets[3]) + (exit_data["exit_tp3"] * size_targets[4]) + (exit_data["exit_tp4"] * size_targets[5]) ) — Reply to this email directly, view it on GitHub <#230 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AAYH7KQXQNDFL4FKWWRFM5DWD3ZK3ANCNFSM5DS2O4OQ> . You are receiving this because you were mentioned.Message ID: ***@***.***>

[eromoe]

@polakowo Hi, I wonder if vectorbt.pro support this feature now or it's on planing?
It is very inconvenient to craft such dynamic stoploss with vectorbt.

[polakowo]

You can already create arbitrary ladders dynamically, static ladder support comes with the next release.