Generating entry and exit signals

[m4rc3l-h3]

Hey,
thanks for the effort providing this library! Great work.
I am currently struggling with understanding the process of creating entry and exit signals using the generate_enex_nb function. Below you find an example of how I am currently using the function. However, I have a couple of interrelated questions. I tam trying to be as concise and understandable as possible, sorry if it does not work out completely ;)

1. Is the function as well as related similar functions intended to work on a single trend array containing True/False only? If so, why is the array passed as part of a Tuple and why do we need a col parameter? If not, how would be pass multiple arrays (e.g., b and c in the example below)?
2. In general, I intend to have an entry at point x if b and c are true for x and a is true for x-1. An exit should be returned as soon as either b or c are false. I created a function that uses this conditions to create a trend array, however, from my understanding of the complete workflow, I thought it should be part of the generate_enex_nb function. At this point I do not understand of how to pass b and c (see commented lines below) to the function.

Thanks for taking time to help me out and to understand the library better. Any help is much appreciated!
Best regards

Code example:

from datetime import datetime
import pandas as pd
from numba import njit
import numpy as np
from vectorbt.signals.nb import generate_enex_nb
from vectorbt import _typing as tp

df = pd.DataFrame({
    'a': [True, False, False, False, False, False, False, True, False, False],
    #'b': [True, True, True, False, False, True, True, True, True, True],
    #'c': [True, True, True, False, False, True, True, True, True, True]
}, index=pd.Index([
    datetime(2020, 1, 1),
    datetime(2020, 1, 2),
    datetime(2020, 1, 3),
    datetime(2020, 1, 4),
    datetime(2020, 1, 5),
    datetime(2020, 1, 6),
    datetime(2020, 1, 7),
    datetime(2020, 1, 8),
    datetime(2020, 1, 9),
    datetime(2020, 1, 10)
]))

@njit
def exit_func_nb(from_i : int, to_i : int, col : int, *args : tp.Args) -> tp.Tuple[tp.Array2d, tp.Array2d]:
    '''Generate exits from trend'''
    end = -1
    for i in range(from_i, to_i):
        if not args[0][i]:
            end = i
            break;
    
    if end == -1:
        temp = np.empty((1,), dtype=np.int_)
        return temp[:0]
    else:
        return np.array([end])

@njit
def entry_func_nb(from_i : int, to_i : int, col : int, *args : tp.Args) -> tp.Tuple[tp.Array2d, tp.Array2d]: 
    '''Generate entries from trend'''
    start = -1
    for i in range(from_i, to_i):
        if args[0][i]:
            start = i
            break;
    
    if start == -1:
        temp = np.empty((1,), dtype=np.int_)
        return temp[:0]
    else:
        return np.array([start])

entries, exits = generate_enex_nb(
    df.shape, 1, 1, 
    #entry_func_nb, (df.a.to_numpy(),df.b.to_numpy()), 
    #exit_func_nb, (df.a.to_numpy(), (df.b.to_numpy(),)))
    entry_func_nb, (df.a.to_numpy(),), 
    exit_func_nb, (df.a.to_numpy(),))

print('Entries: \n', entries)
print('Exits: \n', exits)

[polakowo]

@m4rc3l-h3

Okay, you need to keep in mind that each column in vectorbt is a separate backtesting instance. Providing multiple columns means vectorbt will execute the same logic on each of those columns separately. This way you can construct thousands of columns and backtest them all at once. In your example, you have only one column that is created by combining a, b, and c, so your shape should be df.shape[0] or (df.shape[0], 1). But I advise you to not put a, b, and c into one data frame but keep them separately since they represent different features of the same backtesting instance. Later, if you want to run multiple backtests (e.g., to test multiple parameters), you can expand columns of each a, b, and c.

generate_enex_nb takes some shape (in your case, it's (10, 1)) and on each column (you have only one), it first runs entry_func_nb with from_i=0 and to_i=10 to find the first entry signal (let's say you returned np.array([3])), then it runs exit_func_nb with from_i=4 and to_i=10 to find the exit signal for the previous entry, then it again proceeds with entry_func_nb and so on. I call this approach a "chain" because entries and exits are generated strictly one after another. This resembles how Portfolio.from_signals works: once you encounter the first entry and enter a position, you wait for an exit signal to exit the position while ignoring all entry signals that come before. Then you wait for the next entry while ignoring all exit signals.

Don't use variable arguments such as *args, but explicitly specify all arguments that your function expects. Also, remember to pass your arguments as two-dimensional arrays to select the right column using col on each of them.

Here's how to perform your example correctly:

from datetime import datetime
import pandas as pd
from numba import njit
import numpy as np
from vectorbt import _typing as tp

index = pd.Index([
    datetime(2020, 1, 1),
    datetime(2020, 1, 2),
    datetime(2020, 1, 3),
    datetime(2020, 1, 4),
    datetime(2020, 1, 5),
    datetime(2020, 1, 6),
    datetime(2020, 1, 7),
    datetime(2020, 1, 8),
    datetime(2020, 1, 9),
    datetime(2020, 1, 10)
])
a = pd.Series([True, False, False, False, False, False, False, True, False, False], index=index, name='a')
b = pd.Series([True, True, True, False, False, True, True, True, True, True], index=index, name='b')
c = pd.Series([True, True, True, False, False, True, True, True, True, True], index=index, name='c')

@njit
def entry_choice_nb(from_i : int, to_i : int, col : int, a: tp.Array2d, b: tp.Array2d, c: tp.Array2d) -> tp.Array1d:
    for i in range(from_i, to_i):
        if i - 1 >= 0:
            if b[i, col] and c[i, col] and a[i - 1, col]:
                temp = np.empty((1,), dtype=np.int_)
                temp[0] = i
                return temp
            
    temp = np.empty(0, dtype=np.int_)
    return temp

@njit
def exit_choice_nb(from_i : int, to_i : int, col : int, b: tp.Array2d, c: tp.Array2d) -> tp.Array1d:
    for i in range(from_i, to_i):
        if not b[i, col] or not c[i, col]:
            temp = np.empty((1,), dtype=np.int_)
            temp[0] = i
            return temp
        
    temp = np.empty(0, dtype=np.int_)
    return temp
        

a_2d = a.to_numpy()[:, None]
b_2d = b.to_numpy()[:, None]
c_2d = c.to_numpy()[:, None]
entries, exits = pd.DataFrame.vbt.signals.generate_both(
    a_2d.shape,
    entry_choice_func_nb=entry_choice_nb, 
    entry_args=(a_2d, b_2d, c_2d), 
    exit_choice_func_nb=exit_choice_nb, 
    exit_args=(b_2d, c_2d)
)

print('Entries: \n', entries)
print('Exits: \n', exits)
Entries: 
        0
0  False
1   True
2  False
3  False
4  False
5  False
6  False
7  False
8   True
9  False
Exits: 
        0
0  False
1  False
2  False
3   True
4  False
5  False
6  False
7  False
8  False
9  False

But using generate_enex_nb is a bit of an overkill for your example, as the same can be done with NumPy:

entries = b & c & a.shift()
exits = ~b | ~c

This will not remove multiple True values in a row though (look at exits), but you don't necessarily need to clean up since Portfolio.from_signals takes care of this automatically.

If you want to test this for different data, instead of re-running this pipeline for each data, you can make each of a, b, and c a data frame with multiple columns (one column per kind of data), and your entries and exits will also become data frames that are now easily analyzable.

[m4rc3l-h3]

Thanks for taking time to clarify this issue and providing the corrected example. The process in much clearer now and I will build on that to dig deeper into working with the library .