Comparando os Resultados da Estratégia de IFR2 nos Ativos do Ibovespa

# %%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

def get_ibov_tickers():
    url = "http://bvmf.bmfbovespa.com.br/indices/ResumoCarteiraTeorica.aspx?Indice=IBOV&idioma=pt-br"
    html = pd.read_html(url, decimal=",", thousands=".", index_col="Código")[0][:-1]
    tickers = (html.index + ".SA").to_list()
    return tickers

tickers = get_ibov_tickers()

# Remove ticker without data
tickers.remove("ASAI3.SA")

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

df.head()

df.columns = [" ".join(col).strip() for col in df.columns.values]
df.head()

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

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

    # Define exact buy price
    data["Buy Price"] = np.where(data["IFR2"] <= rsi_parameter_entry, 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 

dict_of_df = {}

for ticker in tickers:
    # Isolate the columns (open, high, close) of each asset into a dataframe
    # and store it in a dictionary 'dict_of_df' 
    data = df[
        [("Open " + ticker), 
         ("High " + ticker), 
         ("Close " + ticker)]].copy()
    
    # Rename the columns
    data.rename(columns={
        ("Open " + ticker): 'Open', 
        ("High " + ticker): 'High', 
        ("Close " + ticker): 'Close'}, inplace=True)
    
    data.dropna(inplace=True)
    
    # Calculate IFR2 and add it to a new column
    data["IFR2"] = rsi(data=data, column="Close")
    
    # Calculate purchase and sale prices
    data = strategy_points(data)
    
    dict_of_df[ticker] = 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 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(data)):
        
        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(data['Sell Price'][i])):
                
                # Define exit point and total profit
                exit = np.where(
                    ~(np.isnan(data['Sell Price'][i])), 
                    data['Sell Price'][i], 
                    data['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(data['Buy Price'][i])):
                entry = data['Buy Price'][i]
                shares = round_down(initial_capital / entry)
                days_in_operation = 0
                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")
    
    profit_per_operation = pct_profit / num_operations

    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,
      "profit_per_operation": profit_per_operation, 
      "drawdown": drawdown
    }

statistics = {}

for ticker in tickers:
    data = dict_of_df[ticker]
    all_profits, total_capital = algorithm_with_stop(data=data, max_days=7)
    statistics[ticker] = strategy_test(all_profits, total_capital)

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

# Values were generated by running a prior backtest
statistics.loc["IBOV Portfolio Strategy"] = [72, 52, 72.0, 20, 28.0, 5842.15, 58.42, 0.81, 26.2]
statistics.tail()

sorted_by_profit_per_operation = statistics.sort_values("profit_per_operation", ascending=False)
pd.set_option("display.max_rows", 100)
sorted_by_profit_per_operation

sorted_by_drawdown = statistics.sort_values("drawdown")
pd.set_option("display.max_rows", 100)
sorted_by_drawdown

def plot_barh(x, y, x_label, title, figsize=(12, 18), highlights_index=None, invert_yaxis=False):
    fig = plt.figure(figsize=figsize)

    positives = x > 0
    graph = plt.barh(y, x, color=positives.map({True: "#49ce8b", False: "r"}))
    
    if highlights_index != None:
        graph[y.get_loc(highlights_index)].set_color("#033660")

    plt.margins(y=0.01)
    plt.xlabel(x_label, fontsize='x-large')
    plt.title(title, fontsize='xx-large')
    
    if invert_yaxis == True:
        plt.gca().invert_yaxis()
    
    return graph 

plot_barh(
    x=sorted_by_profit_per_operation["profit_per_operation"],
    y=sorted_by_profit_per_operation.index,
    x_label="Lucro por Operação (%)",
    title="Backtest da estratégia de IFR2 aplicada nos ativos do Ibovespa, nos últimos 6 anos", 
    highlights_index="IBOV Portfolio Strategy"
)