One can tell, the values of SMA, no matter from built-in factor SimpleMovingAverage or from talib.SMA, they are identical. B ut those of RSI are quite different.

Can someone tell?

Cheers

Thomas

It appears that the built-in RSI factor is computed using Cutler's method rather than using the more standard Welles Wilder version.

Hi mhp,

Thanks for the reply. I also realized the cause of the difference. I created an own custom factor which use the Wlider's version. But it seems not the same as that from talib.RSI. I notice, the talib.RSI values are (alomost) identical with those from stockchart.com and yahoo.com/finance.

Maybe you know where to get out the source code of talib.RSI?

Cheers

Here's what I came up with for wrapping a CustomFactor around the TALIB RSI function:

class WRSI(CustomFactor):  
    # Relative Strength Index using Wilder's smoothing  
    # (default RSI factor is Cutler's RSI which uses SMA smoothing)  
    inputs = (USEquityPricing.close,)  
    params = {'rsi_len' : 14,}  
    window_length = 80 # allow at least 4 times RSI len for proper smoothing  
    def compute(self, today, assets, out, close, rsi_len):  
        # TODO: figure out how this can be coded without a loop  
        rsi = []  
        for col in close.T:  
            try:  
                rsi.append(talib.RSI(col, timeperiod=rsi_len)[-1])  
            except:  
                rsi.append(np.nan)  
        out[:] = rsi  

Hi mhp,

Many thanks to your WRSI. It's wondeful! :-)

Cheers

Hi mhp,

Sorry, a question, if I want to calculate the RSI of 10 or other length, how should I call the factor? I try followings but it failt:

... my_wrsi_10 = WRSI(params= {'rsi_len' : 10})
...

Cheers

This is how to do it:

...my_wrsi_10 = WRSI(rsi_len=10)

For a very tiny speed boost you could also shorten the window length in this case, thus:

...my_wrsi_10 = WRSI(rsi_len=10, window_length=40)

Keep in mind that the "length" in Wilder's smoothing is equivalent to 2*length-1 of typical EMA smoothing, which is why I recommend 4X as minimum.

If you want to go nuts with this, download this sample worksheet and experiment with how many extra bars are actually needed to make today's value stable.

Hi,

Best thanks!

After much trial and error, I've isolated the difficulty I was having running longer backtests without getting memory errors to the WRSI function as coded above. I have no idea why wrapping a talib function in this way would cause a memory leak, but apparently it does.

In any case, I wanted to find a better way to code it, based on the RSI factor in the zipline source code, which looks like this:

class RSI(CustomFactor, SingleInputMixin):  
    """  
    Relative Strength Index  

    **Default Inputs**: [USEquityPricing.close]  

    **Default Window Length**: 15  
    """  
    window_length = 15  
    inputs = (USEquityPricing.close,)  

    def compute(self, today, assets, out, closes):  
        diffs = diff(closes, axis=0)  
        ups = nanmean(clip(diffs, 0, inf), axis=0)  
        downs = abs(nanmean(clip(diffs, -inf, 0), axis=0))  
        return evaluate(  
            "100 - (100 / (1 + (ups / downs)))",  
            local_dict={'ups': ups, 'downs': downs},  
            global_dict={},  
            out=out,  
        )

To convert this to Wilder's smoothing, I had to do 4 things: (a) add a 'rsi_len' parameter to allow the window length to be longer than the calculation length; (b) use np.average to compute the smoothing rather than nanmean; (c) get the decay_length right for Wilder's smoothing; (d) replace the numexpr evaluate call with something less efficient since Q algos are not allowed to import numexpr.

Here is the improved function:

class WRSI(CustomFactor):  
    # Relative Strength Index using Wilder's smoothing  
    # (default RSI factor is Cutler's RSI which uses SMA smoothing)  
    inputs = (USEquityPricing.close,)  
    params = {'rsi_len' : 14,}  
    window_length = 60 # allow at least 4 times RSI len for proper smoothing  
    def compute(self, today, assets, out, close, rsi_len):  
        diffs = np.diff(close, axis=0)  
        count = len(diffs)  
        decay_rate = (1.0 - (1.0 / rsi_len)) # Wilder's smoothing (different from standard EWMA)  
        weights = np.full(count, decay_rate, float) ** np.arange(count + 1, 1, -1)  
        ups = np.average(np.clip(diffs, 0, np.inf), axis=0, weights=weights)  
        downs = abs(np.average(np.clip(diffs, -np.inf, 0), axis=0, weights=weights))  
        out[:] = [100 - (100 / (1 + (up / down))) for up, down in zip(ups, downs)]  

Well, I'm still getting some memory errors after this code change. I guess they're just random, based on current server load. In any case, the new WRSI code is still better.

Hi mhp,

I wonder how and where have found out you get memory leak or memory erros?

Cheers

I mean do you get any error message by back testing?