Hello Mark,

What are the n0, n1, n2, ... values above? Or are they just labels? There's probably an elegant way of doing the computation using numpy; I just wanted to make sure I understand that you are just using the n's as labels, and not something else.

Grant

Thanks Grant! Those are just labels. Think of them as the index of the output

Mark,

Here's a numpy example:

import numpy as np

def initialize(context):  
    context.spy = symbols('SPY')  
    context.n = 1  
def handle_data(context, data):  
    print getWeights(context.n)  
    context.n += 1

def getWeights(n):  
    lam = 0.1  
    l = lam*np.ones(n)  
    w = np.ones(n) - l  
    c = np.arange(n)  
    return np.multiply(w,np.power(l,c))  

The output is:

2015-01-05 PRINT [ 0.9]  
2015-01-06 PRINT [ 0.9 0.09]  
2015-01-07 PRINT [ 0.9 0.09 0.009]  
2015-01-08 PRINT [ 0.9 0.09 0.009 0.0009]  
2015-01-09 PRINT [ 9.00000000e-01 9.00000000e-02 9.00000000e-03 9.00000000e-04 9.00000000e-05]  

Based on the output, it appears to be working correctly.

I'm not clear on what you are trying to do, but note that Pandas has a built-in EWMA function. See:

http://pandas.pydata.org/pandas-docs/stable/generated/pandas.stats.moments.ewma.html
http://pandas.pydata.org/pandas-docs/stable/computation.html

So, you might just store your volatility measure in a Pandas DataFrame and then apply the Pandas EWMA to it to smooth the data.

Grant

Note that post by Gary Hawkins was deleted. I am keeping this post, since it is germane.

Hello Gary,

I don't have time for a tutorial (and I'm no expert), but you might have a look at https://www.quantopian.com/posts/working-with-history-dataframes. Scott provides some guidance there, and I posted a simple algo to his thread that makes use of Pandas. If you have specific questions, you could revive the thread and post them there. Then Scott, Thomas, and others can respond, as well.

Grant

Grant - thanks for taking a stab at this! It looks like the np.ones function is not quite what I need. Let me try to explain again what I'm working on. My goal is to calculate an EWMA leveraging a decay of 0.94 to build weights. For example:

weight 0 = (1-0.94)(0.94)^0
weight 1 = (1-0.94)(0.94)^1
... weight 576 = (1.0.94)(0.94)^571

These weights will be multiplied by series-z to develop a new series of weighted values. The purpose of the weights is to put more weight on the more recent numbers in my formula. I will then take the simple moving average of this weighted series.

Is there a simple way to determine the # of bars in the backtest? I can then use this # in a range function to build my count for weights 0 through n for the exponent in my formula...

When I try x=len(context.stocks), it prints a value of 1 vs .the total length of stock data. The reason why I don't want to use the ones formula is because I only need one weight per date...it looks like one spits out multiple values per weight.

Hi Mark,
Can you use one of the Python package TA-Lib exponential moving average functions to calculate it directly? This package is available in Quantopian. Here is another post that has some example code for how to call it. https://www.quantopian.com/posts/ema-50-vs-100 Just go to the source code tab to see example usage.

Basically you can call it by doing: talib.EMA( timeseries, lookback_window)

There is also double, and triple exponential weighted moving averages available in this TA-Lib package.

You can also find info for all of the pre-built TA-Lib functions here if its helpful:
http://ta-lib.org/function.html

Thanks for the input Justin and the example...I will definitely look through it. The reason why I'm calculating manually is so that I can use my own decay rate to customize the weights...hence the EWMA vs. EMA

Is there a simple way to determine the # of bars in the backtest?

Mark,

In my example code above, the cumulative number of bars in the backtest is stored in context.n (assuming that you are not using the history API, which provides a trailing window of bar data at the backtest start).

Note that the weights become itsy bitsy looking back in time, so you don't need to accumulate a trailing window of every backtest bar. Your best approach will probably be to get the data via the history API and then apply a canned smoothing function (from Pandas, TA-Lib, etc.). If you need to apply your own custom smoothing routine, the Pandas rolling_apply is handy (see http://pandas.pydata.org/pandas-docs/stable/computation.html).

Grant

I'm making some progress here...hopefully you can help me in the final stages! So I have the following code:

        current_price = data[stock].price  
        close_series=pd.Series(current_price, index=prices.index)  
        length=np.array(range(len(close_series)))[::-1]  

I'm trying to create a count column for the entire length of the price history series with the most recent date beginning with "0". This is easy to do in ipython, but I think the datatype pulled from Quantopian is making the conversion from ipython to quantopian difficult. I'm going to use this count as the exponent in the ewma formula. When I print length, the results return:

2014-01-06PRINT[29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5  
  4  3  2  1  0]  
2014-01-07PRINT[29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5  
  4  3  2  1  0]  
2014-01-08PRINT[29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5  
  4  3  2  1  0]  

The count is looking at 30 day containers within each datetime stamp. Why does the result not just show something like the below:

2014-01-06PRINT[29]  
2014-01-07PRINT[28]  
2014-01-08PRINT[27]  

I want one exponent per date because I need one weight per date (or bar). Hence, why I require the later vs. the former example.

Please let me know what I'm doing wrong!