@Princeton-Wong

Basic idea behind is applying electric signal processing filter technique on any indicators to identify trend in a better way, that will filters out unwanted trend periods (either too long or too short) or try to auto-identify the correct trend period (I havent covered in here though).

@chewbacca
maybe a if in next can do?

if self.datas[0].datetime.datetime.hour==9 and self.datas[0].datetime.datetime.minute==1:
    self.buy()```

@Jakob-Schütte

yes, and better use self.p.period instead of a hardcode value 14.
super call related to inheritance, tbh i'm not sure for details.

Here's the Super Smoother and generic filter class based on John F. Ehlers book. Applicable to all common indicators for filtering/smoothing. Tested the modified RSI against the graph in the book and works fine.

Feel free to create and share new indicators or discuss effectiveness below.

Supersmoother

class genericSuperSmoother(bt.Indicator):
    '''P.49
    a=e(−1.414*3.14159 / Period)
    b=2 * a * Cos(1.414 * 180 / Period)
    c2=b
    c3=−a * a
    c1=1 − c2 − c3
    Output=c1 * (Input + Input[1]) / 2 + c2 * Output[1] + c3 * Output[2]
    '''
    lines=('outputLine','inputLine')
    params=(
            ('inputLine',None),
            ('smoothingPeriod',60),
            )
    plotinfo=dict(subplot=True)
    plotlines=dict(
        inputLine=dict(_plotskip=True)
    )

    def __init__(self):
        super(genericSuperSmoother, self).__init__()
        self.l.inputLine=self.p.inputLine
        a=math.exp(-1.414*math.pi/self.p.smoothingPeriod)
        b=2*a*math.cos(math.radians(1.414*180/self.p.smoothingPeriod))
        self.p.c2=b
        self.p.c3=-a*a
        self.p.c1=1-self.p.c2-self.p.c3

    def nextstart(self):
        self.l.outputLine[0]=self.l.outputLine[-1]=self.l.outputLine[-2]=0
    def next(self):
        self.l.outputLine[0]=self.p.c1*(self.l.inputLine[0]+self.l.inputLine[-1])/2+self.p.c2*self.l.outputLine[-1]+self.p.c3*self.l.outputLine[-2]

Filtering (I called Tuning below)

class genericTuningClass(bt.Indicator):
    '''
    The generic tuning
    '''
    lines=('outputLine','inputLine')
    params=(
            ('filterType', 'twoPoleHighPass'),
            ('inputLine','self.data.close'),
            ('K', 1),
            ('bandwidth',0),
            ('period',60),
            )
    plotinfo=dict(subplot=True)
    plotlines=dict(
        inputLine=dict(_plotskip=True)
        )

    def __init__(self):
        super(genericTuningClass, self).__init__()
        self.addminperiod(self.p.period)
        self.l.inputLine=eval(self.p.inputLine)
        filterType=self.p.filterType
        radianMapping={'singlePole':math.radians(360/self.p.period),
        'twoPoleHighPass':math.radians(0.707*360/self.p.period),
        'twoPoleLowPass':math.radians(1.414*360/self.p.period)}
        try:
            radianSetting=radianMapping[self.p.filterType]
        except:
            if self.p.K ==1 and self.p.bandwidth ==0:
                raise TypeError
            radianSetting=math.radians(self.p.K * self.p.bandwidth * 360/self.p.period)
        alphaValue=(math.cos(radianSetting)+math.sin(radianSetting)-1)/math.cos(radianSetting)
        lambdaValue=math.cos(math.radians(360/self.p.period))
        sigmaValue=(1/math.cos(math.radians(360*self.p.bandwidth/self.p.period)))-math.sqrt((1/math.cos(math.radians(360*self.p.bandwidth/self.p.period)))**2-1)
        #P.28 - Below filter set are value for 'b0','b1','b2','a1','a2' ('a0'=1 so skipped)
        FilterSet={'EMA':{'b0':alphaValue,
                          'b1':0,
                          'b2':0,
                          'a1':-(1-alphaValue),
                          'a2':0},
                    'twoPoleLowPass':{'b0':alphaValue**2,
                                    'b1':0,
                                    'b2':0,
                                    'a1':-2*(1-alphaValue),
                                    'a2':0},
                    #High Pass Plus has b1=-(1+alpha/2) instead of -1(1-alpha/2)
                    'highPassPlus':{'b0':(1+alphaValue/2),
                                    'b1':-(1+alphaValue/2),
                                    'b2':0,
                                    'a1':-(1-alphaValue),
                                    'a2':0},
                    'highPass':{'b0':(1-alphaValue/2),
                                    'b1':-(1-alphaValue/2),
                                    'b2':0,
                                    'a1':-(1-alphaValue),
                                    'a2':0},
                    'twoPoleHighPass':{'b0':(1-alphaValue/2)**2,
                                    'b1':-2*(1-alphaValue/2)**2,
                                    'b2':(1-alphaValue/2)**2,
                                    'a1':-2*(1-alphaValue),
                                    'a2':(1-alphaValue)**2},
                    'bandPass':{'b0':(1-sigmaValue)/2,
                                    'b1':0,
                                    'b2':-(1-sigmaValue)/2,
                                    'a1':-lambdaValue*(1+sigmaValue),
                                    'a2':sigmaValue},
                    'bandStop':{'b0':(1+sigmaValue)/2,
                                    'b1':-2*lambdaValue*(1+sigmaValue)/2,
                                    'b2':(1+sigmaValue)/2,
                                    'a1':-lambdaValue*(1+sigmaValue),
                                    'a2':sigmaValue}}
        self.p.paramsSet=FilterSet[filterType]
        if (self.p.filterType=='bandPass' or self.p.filterType=='bandStop') and (sigmaValue==0 or lambdaValue==0):
            raise IndexError

    def nextstart(self):
        #Seed Recursive value
        self.l.outputLine[0]=self.l.outputLine[-1]=0

    def next(self):
        #Formula=b0*input+b1*input[-1]+b2*input[-2]-a1*output[-1]-a2*output[-2]
        self.l.outputLine[0]= self.p.paramsSet['b0']*self.l.inputLine[0] \
                                +self.p.paramsSet['b1']*self.l.inputLine[-1] \
                                +self.p.paramsSet['b2']*self.l.inputLine[-2] \
                                -self.p.paramsSet['a1']*self.l.outputLine[-1]\
                                -self.p.paramsSet['a2']*self.l.outputLine[-2]
        ''' #For debug purpose only
        print('b0:{:.2f}, i0:{:.2f}, b1:{:.2f}, i1:{:.2f}, b2:{:.2f}, i2:{:.2f}, a1:{:.2f}, o1:{:.2f}, a2:{:.2f}, o2:{:.2f}. Output:{:.2f}'.format(
                            self.p.paramsSet['b0'],self.l.inputLine[0],
                            self.p.paramsSet['b1'],self.l.inputLine[-1],
                            self.p.paramsSet['b2'],self.l.inputLine[-2],
                            self.p.paramsSet['a1'],self.l.outputLine[-1],
                            self.p.paramsSet['a2'],self.l.outputLine[-2],
                            self.l.outputLine[0]))
        '''

Example modified RSI

class modifiedRSI(bt.Indicator):
    lines=('modifiedRSI',)
    params=(('period',10),
    ('HPperiod',48),
    ('smoothingPeriod',10),
    )
    plotinfo=dict(subplot=True)
    plotlines=dict(
    modifiedRSI=dict(_fill_gt=(70, 'red'),
                    _fill_lt=(30, 'green')),
        )
    def _plotinit(self):
        self.plotinfo.plotyhlines=[10,30,70,90]

    def __init__(self):
        self.l.HPclose=genericTuningClass(filterType='twoPoleHighPass',inputLine='self.data.close',period=self.p.HPperiod)
        self.l.smoothHPClose=genericSuperSmoother(inputLine=self.l.HPclose,smoothingPeriod=self.p.smoothingPeriod)
        self.l.upDay = bt.ind.UpDay(self.l.smoothHPClose)
        self.l.downDay = bt.ind.DownDay(self.l.smoothHPClose)
        self.l.upSum = bt.ind.SumN(self.l.upDay, period=self.p.period)
        self.l.downSum = bt.ind.SumN(self.l.downDay, period=self.p.period)
        self.l.denom=self.l.upSum+self.l.downSum
        self.l.modRSI = 100*self.l.upSum/self.l.denom
        self.l.modifiedRSI=genericSuperSmoother(inputLine=self.l.modRSI,smoothingPeriod=self.p.smoothingPeriod)

Data - Multiple Timeframes
Quoting from above article: The data with the smallest timeframe (and thus the larger number of bars) must be the 1st one to be added to the Cerebro instance

The reason your strategy using daily (data0) instead of intraday (data1) because you inputted the daily bar first. Try input intraday (data1) first then resample back to daily (data0), this should solve your problem.

@barton05 said in Problem with my custom Indicator, UIcerIndex:

self.l.sqAvg = bt.ind.SumN(self.l.perDrawdown,period=self.p.period)**2/14

should be changed to:

self.l.sqAvg = bt.ind.SumN(self.l.perDrawdown,period=self.p.period)**2/self.p.period

Referencing RSI in backtrader and simplfied the design a bit, see if it helps

import backtrader as bt

class RVI(bt.Indicator):
    lines = ('rvi','upDaySTD','downDaySTD')
    params = (('period', 14),
    ('movav', bt.ind.MovAv.Smoothed),
    ('upperband', 70.0),
    ('lowerband', 30.0),
    ('safehigh', 100.0),
    ('safelow', 50.0),
    )

    plotinfo = dict(subplot=True)
    plotlines = dict(
        upDaySTD=dict(_plotskip=True),
        downDaySTD=dict(_plotskip=True),
    )

    def _plotinit(self):
        self.plotinfo.plotyhlines = [self.p.upperband, self.p.lowerband]

    def __init__(self):
        super(RVI, self).__init__()
        self.lines.upDaySTD=bt.If(self.data-self.data(-1)<0,bt.ind.StdDev(self.data, period=self.p.period),0)
        self.lines.downDaySTD=bt.If(self.data-self.data(-1)>0,bt.ind.StdDev(self.data, period=self.p.period),0)
        maup = self.p.movav(self.lines.upDaySTD, period=self.p.period)
        madown = self.p.movav(self.lines.downDaySTD, period=self.p.period)
        highrs = self._rscalc(self.p.safehigh)
        lowrs = self._rscalc(self.p.safelow)
        rv = bt.ind.DivZeroByZero(maup, madown, highrs, lowrs)
        self.l.rvi = 100.0 - 100.0 / (1.0 + rv)

    def _rscalc(self, rsi):
        try:
            rs = (-100.0 / (rsi - 100.0)) - 1.0
        except ZeroDivisionError:
            return float('inf')
        return rs

Maybe dont need to reinvent the wheel? Using bt.talib.CDL3WHITESOLDIERS and bt.talib.CDL3BLACKCROWS should work.

@Jakob-Schütte fyi.

class ulcerIndex(bt.Indicator):
    lines = ('Ulcer','highestClose','perDrawdown','sqAvg')
    params = (('period', 14),)
    plotlines = dict(
        highestClose=dict(_plotskip=True),
        perDrawdown=dict(_plotskip=True),
        sqAvg=dict(_plotskip=True),
    )
    def __init__(self):
        # To make mixins work - super at the end for cooperative inheritance
        super(ulcerIndex, self).__init__()
        self.l.highestClose = bt.ind.Highest(self.data.close, period=self.p.period)
        self.l.perDrawdown = (self.data.close-self.l.highestClose)/self.l.highestClose * 100
        self.l.sqAvg = bt.ind.SumN(self.l.perDrawdown,period=self.p.period)**2/14
        self.l.Ulcer= pow(self.l.sqAvg,0.5)

Yeah, his QTA book is a good book to study and it makes sense to me.

For continueITDDAnalyzer:

I have created one analyzer called ITDDAnalyzer and another called continueITDDAnalyzer. Former one is to compute ITDD at the end of ONE simulation while continueITDDAnalyzer compute succeeding simulations.

from __future__ import (absolute_import, division, print_function,
						unicode_literals)

import backtrader as bt
from backtrader.analyzers import returns as returns
import pandas as pd
from backtrader.analyzers import TimeReturn
import logging

class ITDDAnalyzer(bt.TimeFrameAnalyzerBase):
	def CalculateITDD(self):
		value = self.strategy.broker.getvalue()
		if value > self.peak:
			self.peak = value
			self.ddlen = 0  # start of streak
		self.dd=dd= 100.0 * (self.peak - value) / self.peak
		self.ddlen+=bool(dd)
		self.ITDD=max(self.ITDD, self.dd)
		self.ITDDLength=max(self.ITDDLength,self.ddlen)

	def start(self,*args,**kwargs):
		self.ITDD=0
		self.ITDDLength=0
		self.initV=self.strategy.broker.getvalue()
		self.peak=float('-inf')
		self.ddlen= -1
		self.dd = 0
		self.ITDDRecord=[]

	def __init__(self):
		self._returns = TimeReturn(timeframe=bt.TimeFrame.Months)

	def notify_trade(self,trade):
		if self.strategy.getposition(self.data).size==0:
			#Calculate the ITDD together with commission included
			self.CalculateITDD()
			self.CARreturn=(self.strategy.broker.getvalue()/self.initV - 1)*100*252/max(trade.barlen,1)
			self.ITDDRecord.append([self.ITDD, self.ITDDLength,self.CARreturn])
			#Reset Parameters for next trade
			self.ITDD=0
			self.ITDDLength=int(0)
			self.initV=self.strategy.broker.getvalue()
			self.peak=float('-inf')
			self.ddlen= -1
			self.dd = 0

	def on_dt_over(self):
		if self.strategy.getposition(self.data).size==0:
			self.CalculateITDD()


class continueITDDAnalyzer(ITDDAnalyzer):
	def __init__(self):
		self._returns = TimeReturn(timeframe=bt.TimeFrame.Months)
		self.ITDDSet=self.strategy.contITDDSet

	def start(self):
		self.ITDD=self.ITDDSet['ITDD']
		self.ITDDLength=self.ITDDSet['ITDDLength']
		self.initV=self.ITDDSet['initV']
		self.value=self.strategy.broker.getvalue()
		self.peak=float(self.ITDDSet['peak'])
		self.ddlen=self.ITDDSet['ddlen']
		self.dd =self.ITDDSet['dd']

	def get_analysis(self):
		ITDDSet = {'ITDD':self.ITDD,
					'ITDDLength':self.ITDDLength,
					'initV':self.initV,
					'value':self.strategy.broker.getvalue(),
					'peak':self.peak,
					'ddlen':self.ddlen,
					'dd':self.dd}
		return ITDDSet

For SizingStra, it is a simple strategy to buy and sell. One point to note is that the BuyPrice and SellPrice were pre-recorded in previous WFA simulation (tf or tradeFeed in below code). It has its own buy/sell price instead of bar open/close bar price particularly when strategy has trail stop that is NOT using bar close price to close the transaction in previous trading. I did it on purpose giving I want to have monte on my trade results. I extracted the most important part for your reference as well.

	def __init__(self,targetRatio,tradeFeed):
		self.historicOrder=[] 
		self.totalCommission=0 # This is to record total commission paid in simulation
		self.o=dict()  # orders per data (main, stop, limit, manual-close)
		self.targetRatio = targetRatio #Target ratio is to calculate the fraction
		self.tf= tradeFeed

	def next(self):
		self.analyzers.contITDD.CalculateITDD()
		if (self.tf.ix[self.datas[0].datetime.datetime()]['BuyPrice'])>0:
			PValue=self.broker.getvalue()
			calSize=int(PValue*self.targetRatio/self.datas[0].open[0])
			targetSize=max(calSize,0)
			BuyPrice = self.tf.ix[self.datas[0].datetime.datetime()]['BuyPrice']
			oneSimLogger.debug('PValue:{}, TargetSize:{}, BuyPrice:{}'.format(self.broker.getvalue(),targetSize,BuyPrice))
			self.o = [self.buy(data=self.datas[0],exectype=bt.Order.Limit, size=targetSize,price=BuyPrice)]
		elif (self.tf.ix[self.datas[0].datetime.datetime()]['SellPrice'])>0:
			pos = self.getposition(self.data).size
			SellPrice = self.tf.ix[self.datas[0].datetime.datetime()]['SellPrice']
			oneSimLogger.debug('PValue:{}, TargetSize:{}, SellPrice:{}'.format(self.broker.getvalue(),pos,SellPrice))
			self.o = [self.sell(data=self.datas[0],size=pos,exectype=bt.Order.Stop,price=SellPrice)]