Fills and exits with a simple take profit strategy

[davejonh]

Hey! First of all, thank you for this awesome project!

I just started looking into vectorbt and trying to improve my understanding of how it works through a simple strategy example:

• Buy when the price is 1% below the moving average
• Sell as soon as you make 3% profit on a trade

I am having trouble with calculating the exits via vbt. I tried to implement the sell rule via tp_stop as I've seen in an example, but the results are drastically different when compared to a "manual" calculation of the exits. The code below illustrated the 2 approaches.

I did a bit of digging into the vbt trades and I feel I'm not understanding how tp_stop works. I observed the following behavior which I did not expect:

• The profit for trades varied a lot, often being significantly higher than 3%. It seems that the exit would not execute as soon as the price is above the 3% mark
• Some trades (before the end of the simulation) were closed at a loss even though I did not specify any stop loss

I have the following questions for you / the community and would greatly appreciate some help:

1. Could you please help me understand how the "manual" approach would be properly translated to vbt?
2. Could you please clarify how tp_stop is expected to work given the "unexpected" behavior above?
3. Could you please share how one might get finer control over execution prices (entry_price & exit_price in the snippet below)? Is there a way to specify a custom function for computing these price levels?

Thank you!

import vectorbt as vbt


binance_data = vbt.BinanceData.load("binance_data")
start_capital = 10000.0
fee = 0.001
ma_interval = 17
ma = vbt.MA.run(binance_data.get()["Close"], ma_interval)
# We buy if price is 1% below moving average
entry_perc = 0.01
entries = ma.ma_above(binance_data.get()["Close"] * 1/(1.0-entry_perc))
# We sell as soon as we've made 3% on the buy.
exit_perc = 0.03

# First we compute exits with vbt
vbt.settings.portfolio.fee = 0.001
exits = vbt.OHLCSTX.run(
    entries, binance_data.get('Open'),
    binance_data.get('High'),
    binance_data.get('Low'),
    binance_data.get('Close'),
    tp_stop=[exit_perc],
    stop_type=None, stop_price=None).exits
pf = vbt.Portfolio.from_signals(
    binance_data.get('Close'),
    entries, exits, init_cash=start_capital)

# Second we compute the exits manually
capital = start_capital
# At most one buy order at a time, filled when price is 1% below moving average
# and sold at 3% profit.
buy_order = None
trades = 0
for i in range(len(entries)):
    if entries[i] and not buy_order and i < len(entries) - 1:
        # Do the fill on the open of next candle.
        entry_price = binance_data.get()["Open"][i + 1]
        buy_order = dict(
            size=capital / entry_price * (1 - fee),
            price=entry_price)
        continue
    exit_price = binance_data.get()["Close"][i]
    if buy_order and (
            exit_price > (1.0 + exit_perc) * buy_order["price"] or
            # Always sell on last candle if there's a pending order.
            i == len(entries) - 1):
        capital = exit_price * buy_order["size"] * (1 - fee)
        trades += 1
        buy_order = None

print("\n\n\n--------------------------------------------------------------")
print(f"Starting capital = {start_capital}")
print(f"Manual final capital = {capital}, trades = {trades}")
print("VBT final capital: ", start_capital + pf.total_profit())
buy_and_hold_capital = (start_capital / binance_data.get()
                        ["Close"][0] * binance_data.get()["Close"][-1])
print("Buy and hold capital: ", buy_and_hold_capital)
vbt_benchmark = start_capital * (pf.total_benchmark_return() + 1)
print("VBT benchmark capital: ", vbt_benchmark)

Results:
Starting capital = 10000.0
VBT final capital: 9788.606023332377
Manual final capital = 41188.90919251269, trades = 56
VBT benchmark capital: 48377.1878072763
Buy and hold capital: 48377.1878072763

[polakowo]

Hi @davejonh, OHLCSTX searches for an exit between two entries. If there is no gap between two entries, there cannot be any exits in-between. Now, your entries contains a lot of True values that come one after another (= a sequence), and so the only entry OHLCSTX can find exits for is the last entry of each sequence. To mimic real behavior, you should either use OHLCSTCX (note the 'C' letter in the name), which generates an exit for the first True value out of each sequence, or manually select the first True value out of each sequence using entries = entries.vbt.signals.clean(). Then OHLCSTX will work as expected.

If you want to get a finer control, you can use SL/TP built into Portfolio.from_signals.

[davejonh]

Thank you for the very informative answer, @polakowo! It did help a lot and after spending some quality time with the code I understand a bit better how things work. Wanted to share my findings in case they are useful for anyone else.

I initially tried signals.clean() but it did not seem to produce the desired result when there are a lot of entries still. I did not look too closely at this one, but based on your info I suspect the clean method would pick the first entry and clear the others while what I wanted was to only clear until the exit point.

Using OHLCSTCX got me a lot closer. After understanding that it computes exits based on open times and the take_profit / stop_loss calculation is based on high/low in the candle, I updated my code with similar logic and the results were pretty close for take_profit case. However, stop_loss example with very many stops still produced quite different results.

Finally, I tried the SL/TP args in Portfolio.from_signals. This got me the closest to what I wanted (< 1% difference, likely due to fee calculations). One part that took me a bit by surprise was that the exit fill and tp/sl logic was different from OHLCSTCX. Instead of using open/high/low as OHLCSTCX, Portfolio.from_signals used close for most of the calculations.

In terms of speed, vectorbt was about 7-10x times faster than the naive iteration I implemented, which is awesome! I think using TP/SL in Portfolio.from_signals directly was best as it avoided 2 loops with OHLCSTCX, one to generate exits and then another to generate the trades.

Only scratching the surface here, I definitely need to dive a bit deeper in the code. I don't know if this would cost performance, but in the general case I would love to figure out a way where the following pieces are fully customizable:

• entry and exit points
• execution for matching entries / exits
• execution for calculating fill prices
• fee calculation (for instance, this could be based on the asset or the quote)

In theory, entries / exits can be computed separately and cleaned up to only leave the matches expected by vectorbt. Then some logic changes can deal with potentially different calculations for fill prices and fees, but I need to read that code some more. Ideally though, everything would be computed in one iteration with something like Portfolio.from_execution_config(entry_generator, entry_price_filler, exit_generator, exit_price_filler, entry_exit_matcher, fee_calculator).

[polakowo]

@davejonh

you can set stop_entry_price (https://vectorbt.dev/docs/portfolio/enums.html#vectorbt.portfolio.enums.StopEntryPrice) to 'price' or 'fillprice' instead of close if you want it to closely match OHLCSTX. The exit price can be customized with stop_exit_price (https://vectorbt.dev/docs/portfolio/enums.html#vectorbt.portfolio.enums.StopExitPrice). Generally, you can provide any argument (such as fees) as an array with the same shape as close to specify a value for a specific timestamp.

Have you tried Portfolio.from_order_func? You can implement an arbitrary logic with it + in event-driven manner.