Backtest da Estratégia Saudade de Casa em Python

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import math

df = pd.read_csv('../data/M30/PETR4.csv', index_col='datetime')[["open", "high", "low", "close"]]
df

def bb(df, k=2, n=20):
  df['standard deviation'] = df['close'].rolling(n).std()
  df['middle band'] = df['close'].rolling(n).mean()
  df['upper band'] = df['middle band'] + df['standard deviation'] * k
  df['lower band'] = df['middle band'] - df['standard deviation'] * k
  
  return df

df = bb(df)
df.drop(columns=["standard deviation"], inplace=True)
df.dropna(inplace=True)

df.head(5)

df["day"] = pd.to_datetime(df.index).strftime('%Y-%m-%d')
df["first of day"] = df["day"] != df["day"].shift(1)
df.head(5)

# A bullish "missing home" opens below the lower BB 
bullish_candle = (df["first of day"] == True) & \
    (df["open"] < df['lower band']) 

# A bearish "missing home" opens above the upper BB
bearish_candle = (df["first of day"] == True) & \
    (df["open"] > df['upper band'])
    

# Signal is  1 when the next candle exceeds the high of the bullish candle
# Signal is -1 when the next candle has its low below the low of the
# bearish candle. 
# If none occurs, then the signal is 0 and no trade is placed.
df["signal"] = np.where(
    (bullish_candle == True) & (df["high"].shift(-1) > df["high"]), 
    1, 
    np.where(
        (bearish_candle == True) & (df["low"].shift(-1) < df["low"]), 
        -1, 
        0
    )
)

long_trades = df[df["signal"] == 1]
short_trades = df[df["signal"] == -1]

print(f"Total Compras: {len(long_trades)}")
print(f"Total Vendas: {len(short_trades)}")
print(f"Total Trades: {len(long_trades+short_trades)}")

# initial capital is $100,000 
total_capital = [100000]
all_profits = []
number_bullish_gain = 0
number_bearish_gain = 0
number_bullish_loss = 0
number_bearish_loss = 0

ongoing = False
signal = 0
min_tick = 0.01

for i in range(0,len(df)):

# bullish:
    if (df["signal"][i] == 1):
        signal = 1
        entry = df["high"][i] + min_tick
        stop = df["low"][i] - min_tick
        risk = entry - stop
        ongoing = True 

# bearish:
    elif (df["signal"][i] == -1):
        signal = -1
        entry = df["low"][i] - min_tick
        stop = df["high"][i] + min_tick
        risk = entry - stop 
        ongoing = True

target_band = 'middle'

for i in range(0,len(df)):

    if (signal == 1 and target_band == 'opposite'):
        target = df["upper band"][i]

    elif (signal == -1 and target_band == 'opposite'):
        target = df["lower band"][i]

    elif (target_band == 'middle'):
        target = df["middle band"][i]

    else:
        print('Unknown target')

for i in range(0,len(df)):
    
    # Ignore signals where you might have been stopped in the same candle once
    # we are unable to say what happened first 
    if (signal == 1 and df["high"][i] >= df["high"][i-1] and df["low"][i] <= stop): 
        ongoing = False
    elif (signal == -1 and df["low"][i] <= df["low"][i-1] and df["high"][i] >= stop):
        ongoing = False

# Example with fixed shares
shares = 100

for i in range(0,len(df)):

# bullish:
    if (signal == 1 and df["high"][i] >= target):      
        profit = shares * (target - entry)
        all_profits += [profit]
        current_capital = total_capital[-1]
        total_capital += [current_capital + profit]
        number_bullish_gain += 1
        ongoing = False

# bearish:
    elif (signal == -1 and df["low"][i] <= target):
        profit = shares * (target - entry)
        all_profits += [profit]
        current_capital = total_capital[-1]
        total_capital += [current_capital + profit]
        number_bearish_gain += 1
        ongoing = False

# Example with fixed shares
shares = 100

for i in range(0,len(df)):

    # bullish:
    if (signal == 1 and df["low"][i] <= stop):
        profit = shares * (stop - entry)
        all_profits += [profit]
        current_capital = total_capital[-1]
        total_capital += [current_capital + profit]
        number_bullish_loss += 1
        ongoing = False

    # bearsih:

    elif (signal == -1 and df["high"][i] >= stop):
        profit = shares * (stop - entry)
        all_profits += [profit]
        current_capital = total_capital[-1]
        total_capital += [current_capital + profit]
        number_bearish_loss += 1
        ongoing = False

# Create a function to round any number to the smalles multiple of 100
def round_down(x):
    return int(math.floor(x / 100.0)) * 100

def missing_home_algorithm(
    df,    
    capital_exposure,
    initial_capital,
    target_band='middle'): # we define the middle band as standard if nothing is provided

    # List with the total capital after every operation
    total_capital = [initial_capital]

    # List with all profits and a couting splitting bullish and bearish operations
    all_profits = [] 
    number_bullish_gain = 0
    number_bearish_gain = 0
    number_bullish_loss = 0
    number_bearish_loss = 0
  
    ongoing = False # at the start no trade is ongoing
    signal = 0      # initialising signal
    min_tick = 0.01 # That's the min variation for this asset

    for i in range(0,len(df)):
        
        # start of the trade
        if ongoing == False:

            # bullish signal
            if (df["signal"][i] == 1):
                signal = 1
                entry = df["high"][i] + min_tick
                stop = df["low"][i] - min_tick
                risk = entry - stop
                shares = round_down(capital_exposure / risk)

                ongoing = True

            # bearish signal
            elif (df["signal"][i] == -1):            
                signal = -1
                entry = df["low"][i] - min_tick
                stop = df["high"][i] + min_tick
                risk = entry - stop                
                shares = round_down(capital_exposure / risk)

                ongoing = True

        else:
            # if I am in a trade, my target is variable and updated every candle    
            if (signal == 1 and target_band == 'opposite'):
                target = df["upper band"][i]
            elif (signal == -1 and target_band == 'opposite'):
                target = df["lower band"][i]
            elif (target_band == 'middle'):
                target = df["middle band"][i]
            else:
                print('No target defined/recognised')
                break                

            # operation where we don't know if the stop happened first is NOT considered  
            if (signal == 1 and df["high"][i] >= df["high"][i-1] and df["low"][i] <= stop): 
            
                #buy operation cancelled
                ongoing = False

            elif (signal == -1 and df["low"][i] <= df["low"][i-1] and df["high"][i] >= stop):
          
                #sell operation cancelled
                ongoing = False

            # bullish target
            elif (signal == 1 and df["high"][i] >= target):
                # target was reached
                profit = shares * (target - entry)

                # Append profit to list and create a new entry with the capital
                # after the operation is complete
                all_profits += [profit]
                current_capital = total_capital[-1] # current capital is the last entry in the list
                total_capital += [current_capital + profit]
                number_bullish_gain += 1

                #buy operation target
                ongoing = False

            # bearish target
            elif (signal == -1 and df["low"][i] <= target):
                # target was reached
                profit = shares * (target - entry)

                # Append profit to list and create a new entry with the capital
                # after the operation is complete
                all_profits += [profit]
                current_capital = total_capital[-1] # current capital is the last entry in the list
                total_capital += [current_capital + profit]                
                number_bearish_gain += 1

                #sell operation target
                ongoing = False  

            # stop loss
            elif (signal == 1 and df["low"][i] <= stop):
                # stop was reached: end of operation
                profit = shares * (stop - entry)

                # Append profit to list and create a new entry with the capital
                # after the operation is complete
                all_profits += [profit]
                current_capital = total_capital[-1] # current capital is the last entry in the list
                total_capital += [current_capital + profit]
                number_bullish_loss += 1

                #stop in bullish
                ongoing = False

            elif (signal == -1 and df["high"][i] >= stop):
                # stop was reached: end of operation
                profit = shares * (stop - entry)

                # Append profit to list and create a new entry with the capital
                # after the operation is complete
                all_profits += [profit]
                current_capital = total_capital[-1] # current capital is the last entry in the list
                total_capital += [current_capital + profit]
                number_bearish_loss += 1

                #stop in bearlish
                ongoing = False            

    total_number_bullish = number_bullish_gain + number_bullish_loss
    total_number_bearish = number_bearish_gain + number_bearish_loss
       
    pct_bullish_gain = (number_bullish_gain / total_number_bullish) * 100
    pct_bearish_gain = (number_bearish_gain / total_number_bearish) * 100
    
    return all_profits, pct_bullish_gain, pct_bearish_gain, total_capital

def get_drawdown(data, column = "close"):
    data["Max"] = data[column].cummax()
    data["Delta"] = data['Max'] - data[column]
    data["Drawdown"] = 100 * (data["Delta"] / data["Max"])
    max_drawdown = data["Drawdown"].max()
    return max_drawdown

def strategy_test(all_profits, pct_bullish_gain, pct_bearish_gain, total_capital):
    number_gains = [x for x in all_profits if x >= 0] 
    number_losses = [x for x in all_profits if x < 0] 
    gains = len(number_gains)
    losses = len(number_losses)
    sum_gains = sum(number_gains)
    sum_losses = sum(number_losses)
    avg_gains = sum_gains / gains
    avg_losses = sum_losses / losses
    num_operations = gains + losses
    pct_gains = 100 * (gains / num_operations)
    pct_losses = 100 - pct_gains
    total_profit = sum(all_profits)
    pct_profit = (total_profit / total_capital[0]) * 100
    EV = (pct_gains * avg_gains + pct_losses * avg_losses) / 100
    
    # Compute drawdown
    total_capital = pd.DataFrame(data=total_capital, columns=["total_capital"])
    drawdown = get_drawdown(data=total_capital, column="total_capital")

    return {
        "num_operations": num_operations,
        "gains": gains,
        "pct_gains": pct_gains,
        "avg_gains": avg_gains.round(),
        "pct_bullish_gains": pct_bullish_gain,
        "pct_bearish_gains": pct_bearish_gain,
        "losses": losses,
        "pct_losses": pct_losses, 
        "avg_loss": avg_losses.round(),
        "total_profit": total_profit,
        "pct_profit": pct_profit,
        "drawdown": drawdown,
        'EV': EV
    }

def capital_plot(total_capital, all_profits):
  all_profits = [0] + all_profits # make sure both lists are the same size
  cap_evolution = pd.DataFrame({'Capital': total_capital, 'Profit': all_profits})
  plt.title("Curva de Capital")
  plt.xlabel("Total Operações")
  cap_evolution['Capital'].plot()

all_profits, pct_bullish_gain, pct_bearish_gain, total_capital = missing_home_algorithm(
  df, 
  capital_exposure = 1000, 
  initial_capital = 100000, 
  target_band='middle'
)

capital_plot(total_capital, all_profits)

statistics = strategy_test(all_profits, pct_bullish_gain, pct_bearish_gain, total_capital)
statistics = pd.DataFrame.from_dict(statistics, orient='index')
statistics 

all_profits, pct_bullish_gain, pct_bearish_gain, total_capital = missing_home_algorithm(
  df,
  capital_exposure = 1000,
  initial_capital = 100000,
  target_band='opposite'
)

capital_plot(total_capital, all_profits)

statistics = strategy_test(all_profits, pct_bullish_gain, pct_bearish_gain, total_capital)
statistics = pd.DataFrame.from_dict(statistics, orient='index')
statistics