Best posts made by Mariano Volpedo

Hi,

To develop momentum strategies, its relevant to understand is the trend is strong or a mean reversion is coming. Tipically, Hurst Exponent claims to work, but unfortunally I dont see value on this indicator with my data (latinamerican mutual funds).

Finally I found the MMI as an alternative with better results to implement in my strategies. You can get the explanation and several backtestings on https://financial-hacker.com/the-market-meanness-index/ (ps: you can read there with 55 is important)

This is my implementation on backtrader, pls your feedback is welcome

class MMI(bt.Indicator):
    lines = ('mmi',)
    plotinfo = dict(plothlines=[55])
    params = dict(period=100,)

    def __init__(self):
        self.m = Average(self.data.close, period = self.p.period) #replace with median
        
    def next(self):
            nl = 0
            nh = 0

            for j in range(self.p.period-1):
                if j < 1:
                    continue
                i=j * -1
                if (self.data.close[i] > self.m[0]) and (self.data.close[i] > self.data.close[i-1]) :
                    nl += 1
                if (self.data.close[i] < self.m[0]) and (self.data.close[i] < self.data.close[i-1]) :
                    nh += 1
            self.l.mmi[0] = 100.0 * (nl+nh)/(self.p.period - 1)

This is my whole dark theme, I´ve tried to emulate TradingView schema.

plt.style.use('fivethirtyeight')

plt.rcParams["figure.figsize"] = (10, 6)
plt.rcParams['lines.linewidth'] = 1

SIZE = 7
plt.rcParams['axes.labelsize'] = SIZE
plt.rcParams['ytick.labelsize'] = SIZE
plt.rcParams['xtick.labelsize'] = SIZE
plt.rcParams["font.size"] = SIZE

COLOR = '1'
plt.rcParams['text.color'] = COLOR
plt.rcParams['axes.labelcolor'] = COLOR
plt.rcParams['xtick.color'] = COLOR
plt.rcParams['ytick.color'] = COLOR


plt.rcParams['grid.linewidth']=0.1
plt.rcParams['grid.color']="0.2"
plt.rcParams['lines.color']="0.5"
plt.rcParams['axes.edgecolor']="0.2"
plt.rcParams['axes.linewidth']=0.5

plt.rcParams['figure.facecolor']="#101622"
plt.rcParams['axes.facecolor']="#101622"
plt.rcParams["savefig.dpi"]=120
dpi = plt.rcParams["savefig.dpi"]
width = 700
height = 1200
plt.rcParams['figure.figsize'] = height/dpi, width/dpi
plt.rcParams["savefig.facecolor"] ="#101622"
plt.rcParams["savefig.edgecolor"]="#101622"

plt.rcParams['legend.fontsize'] = SIZE
plt.rcParams['legend.title_fontsize'] = SIZE + 1
plt.rcParams['legend.labelspacing'] =0.25
plt.rcParams['image.cmap']='tab10'

@sid_vishnu you will found severals backtrader vids on Part Time Larry channel. Hope this help.

https://www.youtube.com/channel/UCY2ifv8iH1Dsgjrz-h3lWLQ

Hey, dear community !

Building volatility targeting strategies, I found that this relevant indicator is missing.

You could find more about this here:
https://quantpedia.com/an-introduction-to-volatility-targeting/#:~:text=Volatility target is the level,volatility is easier to predict.

Hope this helps. Comments?

PS: GARCH implementation for the next version but literature says it's expensive and you get similar results using faster EWMA

class StdDevReturns(bt.Indicator):

    lines = ('stddev',)
    params = dict(
                    method="simple", # or ewma_pd or ewma_np
                    annualized = True,
                    period=20,
                    alpha=0.06, # only for ewma
                    adjust=True, # only for ewma_pd
                    trading_year_days=252,
                )
    
    def __init__(self):
        self.addminperiod(self.params.period + 2)
        if self.p.annualized:
            self.annualized = self.p.trading_year_days ** (1 / 2)
        else:
            self.annualized = 1
        
    def next(self):
        returns = self.Returns(self.data0.get(size=self.p.period))
        
        if self.p.method == "simple":
            self.lines.stddev[0] = returns.std() * self.annualized
        elif self.p.method == "ewma_pd":
            data = pd.DataFrame(returns)
            self.lines.stddev[0] = data.ewm(alpha=self.p.alpha, adjust= self.p.adjust).std().iloc[-1][0] * self.annualized
        elif self.p.method == "ewma_np":            
            self.lines.stddev[0] = self.CalculateEWMAVol(returns, 1 - self.p.alpha) * self.annualized

    def Returns(self, prices):
        return np.diff(np.log(prices)) #np.diff(prices) / prices[1:]
    
    def CalculateEWMAVol(self, returns, _lambda):   
        period = len(returns)
        average_returns = returns.mean()
    
        e = np.arange(period-1, -1, -1)
        r = np.repeat(_lambda, period)
        vector_lambda = np.power(r, e)
    
        sxxewm = (np.power(returns - average_returns, 2) * vector_lambda).sum()
        Vart = sxxewm/vector_lambda.sum()
        EWMAVol = math.sqrt(Vart)
    
        return EWMAVol