Backtest da Estratégia de IFR2 Utilizando Médias Móveis Como Filtro

# %%capture means we suppress the output
%%capture

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
!pip install yfinance
import yfinance as yf

df = yf.download("LREN3.SA", start="2015-01-01", end="2020-12-30").copy()[["Open", "High", "Close"]]

def rsi(data, column, window=2):   
    
    data = data.copy()
    
    # Establish gains and losses for each day
    data["Variation"] = data[column].diff()
    data = data[1:]
    data["Gain"] = np.where(data["Variation"] > 0, data["Variation"], 0)
    data["Loss"] = np.where(data["Variation"] < 0, data["Variation"], 0)

    # Calculate simple averages so we can initialize the classic averages
    simple_avg_gain = data["Gain"].rolling(window).mean()
    simple_avg_loss = data["Loss"].abs().rolling(window).mean()
    classic_avg_gain = simple_avg_gain.copy()
    classic_avg_loss = simple_avg_loss.copy()

    for i in range(window, len(classic_avg_gain)):
        classic_avg_gain[i] = (classic_avg_gain[i - 1] * (window - 1) + data["Gain"].iloc[i]) / window
        classic_avg_loss[i] = (classic_avg_loss[i - 1] * (window - 1) + data["Loss"].abs().iloc[i]) / window
    
    # Calculate the RSI
    RS = classic_avg_gain / classic_avg_loss
    RSI = 100 - (100 / (1 + RS))
    return RSI

df["IFR2"] = rsi(df, column="Close")
df.head()

# arithmetic moving average calculation
df["MMA200"] = df["Close"].rolling(200).mean()
df["MMA50"] = df["Close"].rolling(50).mean()

#e xponential moving average calculation
df['MME80'] = df["Close"].ewm(span=80).mean()

df.tail()

# percentage change calculation 
df["Variation 200"] = df["MMA200"].pct_change()
df["Variation 50"] = df["MMA50"].pct_change()
df["Variation 80"] = df["MME80"].pct_change()

# We don't need them anymore
df.drop(columns=["MMA200", "MMA50", "MME80"], inplace=True)

df.tail()

df["Target1"] = df["High"].shift(1)
df["Target2"] = df["High"].shift(2)
df["Target"] = df[["Target1", "Target2"]].max(axis=1)
  
# We don't need them anymore
df.drop(columns=["Target1", "Target2"], inplace=True)

def strategy_points(data, rsi_parameter_entry, variation_column):

  # Define exact buy price
  condition_1 = df["IFR2"] <= rsi_parameter_entry
  condition_2 = df[variation_column] > 0 
  data["Buy Price"] = np.where(condition_1 & condition_2, data["Close"], np.nan)

  # Define exact sell price
  data["Sell Price"] = np.where(
      data["High"] > data['Target'],
      np.where(data['Open'] > data['Target'], data['Open'], data['Target']),
      np.nan)

  return data 

import math

# 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 backtest_algorithm(data, initial_capital=10000):
  
  total_capital = [initial_capital] # list with the total capital after every operation
  all_profits = [0] # list with profits for every operation
  
  ongoing = False 
  
  for i in range(0,len(data)):
    if ongoing == True:
      if ~(np.isnan(data['Sell Price'][i])):
        
        # Define exit point and total profit
        exit = data['Sell Price'][i]
        profit = shares * (exit - 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]
        ongoing = False

    else:
      if ~(np.isnan(data['Buy Price'][i])):
        entry = data['Buy Price'][i]
        shares = round_down(initial_capital / entry)
        ongoing = True

  return all_profits, 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, total_capital):
    num_operations = (len(all_profits) - 1)
    gains = sum(x >= 0 for x in all_profits)
    pct_gains = 100 * (gains / num_operations)
    losses = num_operations - gains
    pct_losses = 100 - pct_gains
    total_profit = sum(all_profits)
    pct_profit = (total_profit / total_capital[0]) * 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.round(),
      "losses": losses,
      "pct_losses": pct_losses.round(), 
      "total_profit": total_profit,
      "pct_profit": pct_profit,
      "drawdown": drawdown
    }

periods = [200, 80, 50]

statistics = {}
cap_evolution = {}

for period in periods: 
    variation_column = "Variation " + str(period)
    df = strategy_points(data=df, rsi_parameter_entry=30, variation_column=variation_column)
    all_profits, total_capital = backtest_algorithm(df)
    statistics[period] = strategy_test(all_profits, total_capital)
    key1 = "all_profits_" + str(period)
    key2 = "total_capital_" + str(period)
    cap_evolution[period] = { key1: all_profits, key2: total_capital }

statistics

statistics = pd.DataFrame.from_dict(statistics, orient="index").round(2)
statistics

def plot_bars(title, x, y, x_label="IFR2", y_label=None):
  fig = plt.figure()
  plt.gca().spines['right'].set_visible(False)
  plt.gca().spines['top'].set_visible(False)
  
  colors = ["paleturquoise", "mediumturquoise", "darkcyan", "darkslategrey"]
  plt.bar(x, y, color=colors)
  
  plt.title(title)
  plt.xlabel(x_label)
  if y_label != None: 
    plt.ylabel(y_label) 

  for i, v in enumerate(y):
    plt.text(
      x=i,
      y=v,
      s=str(v),
      horizontalalignment='center',
      verticalalignment='bottom',
      fontdict=dict(fontsize=12)
    )

x = statistics.index.astype(str)

plot_bars(title="Número de Operações", x=x, y=statistics["num_operations"], x_label="Média Móvel")

plot_bars(title="Lucro Total (%)", x=x, y=statistics["pct_profit"], x_label="Média Móvel")

plot_bars(title="Drawdown (%)", x=x, y=statistics["drawdown"], x_label="Média Móvel")

def profit_per_operation(data, strategy_title): 
  profit = data["pct_profit"] / data["num_operations"]
  df = pd.DataFrame(profit).round(2)
  df.rename(columns = {0: "profit_per_operation"}, inplace=True)
  print(strategy_title, "\n\n", df)

profit_per_operation(
  statistics, 
  strategy_title="Entrada em IFR2<=30, saída na máx. dos 2 dias anteriores, sem stop:"
)

def strategy_points(data, rsi_parameter_entry, rsi_parameter_exit, variation_column):
 
 # Define exact buy price
 condition_1 = df["IFR2"] <= rsi_parameter_entry
 condition_2 = df[variation_column] > 0 
 data["Buy Price"] = np.where(condition_1 & condition_2, data["Close"], np.nan)
 
 # Define exact sell price
 data["Sell Price"] = np.where(data["IFR2"] >= rsi_parameter_exit, data["Close"], np.nan)
 
 return data

backtest = {}

for period in periods: 
  variation_column = "Variation " + str(period)
  df = strategy_points(
    data=df, 
    rsi_parameter_entry=30, 
    rsi_parameter_exit=70, 
    variation_column=variation_column
  )
  all_profits, total_capital = backtest_algorithm(df)
  backtest[period] = strategy_test(all_profits, total_capital)

backtest = pd.DataFrame.from_dict(backtest, orient="index").round(2)
backtest

plot_bars(title="Número de Operações", x=x, y=backtest["num_operations"], x_label="Média Móvel")

plot_bars(title="Lucro Total (%)", x=x, y=backtest["pct_profit"], x_label="Média Móvel")

plot_bars(title="Drawdown (%)", x=x, y=backtest["drawdown"], x_label="Média Móvel")

def algorithm_with_stop(data, max_days, initial_capital=10000):

  # List with the total capital after every operation
  total_capital = [initial_capital]  
  # List with profits for every operation. We initialize with 0 so 
  # both lists have the same size
  all_profits = [0] 

  days_in_operation = 0

  ongoing = False 

  for i in range(0,len(df)):
      if ongoing == True:
          days_in_operation += 1

          # If any of the following conditions are met, the operation will end
          if days_in_operation == max_days or ~(np.isnan(df['Sell Price'][i])):

              # Define exit point and total profit
              exit = np.where(
                  ~(np.isnan(df['Sell Price'][i])), 
                  df['Sell Price'][i], 
                  df['Close'][i])
              profit = shares * (exit - 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]
              total_capital += [current_capital + profit]
              
              ongoing = False
      else:
          if ~(np.isnan(df['Buy Price'][i])):
              entry = df['Buy Price'][i]
              shares = round_down(initial_capital / entry)
              days_in_operation = 0
              ongoing = True
    
  return all_profits, total_capital

backtest_with_stop = {}

for period in periods:
  variation_column = "Variation " + str(period)
  df = strategy_points(
    data=df, 
    rsi_parameter_entry=30, 
    rsi_parameter_exit=70, 
    variation_column=variation_column
  )
  all_profits, total_capital = algorithm_with_stop(df, max_days=7)
  backtest_with_stop[period] = strategy_test(all_profits, total_capital)

backtest_with_stop = pd.DataFrame.from_dict(backtest_with_stop, orient="index").round(2)
backtest_with_stop

plot_bars(title="Número de Operações", x=x, y=backtest_with_stop["num_operations"], x_label="Média Móvel")

plot_bars(title="Lucro Total (%)", x=x, y=backtest_with_stop["pct_profit"], x_label="Média Móvel")

plot_bars(title="Drawdown (%)", x=x, y=backtest_with_stop["drawdown"], x_label="Média Móvel")

profit_per_operation(backtest, strategy_title="Entrada em IFR2 <= 30, saída em IFR2 >= 70, sem stop:")

profit_per_operation(backtest_with_stop, strategy_title="Entrada em IFR2 <= 30, saída em IFR2 >= 70, stop de 7 dias:")