def get_bab_pf_values(StockReturns):
    first_date = StockPrices['date'].min()
    last_date = StockPrices['date'].max()
    stock_first = StockPrices[StockPrices['date'] == first_date][['ticker']].reset_index(drop=True)
    stock_last = StockPrices[StockPrices['date'] == last_date][['ticker']].reset_index(drop=True)
    stock_universe = stock_first.merge(stock_last).merge(StockBeta)
    tickers = stock_universe[['ticker']]
    # test_dates = np.sort(StockPrices['date'].astype(datetime.datetime).unique())
    build_start_date = datetime.datetime(2011, 11, 1)
    build_end_date = datetime.datetime(2014, 11, 7)
    test_start_date = datetime.datetime(2014, 11, 10)
    test_end_date = datetime.datetime(2015, 1, 31)
    decay = 0.003

    prices_build = StockPrices[StockPrices['date'] == build_end_date][['ticker', 'adj_close']]
    (Coef, Res) = functions.wReg(StockReturns, CarhartDaily, tickers, decay,
                                 build_start_date, build_end_date)
    betas = Coef.merge(tickers).rename(columns={'Mkt-RF': 'beta'})[['ticker', 'beta']].reset_index(drop=True)
    sortCoef = betas.sort('beta').reset_index(drop=True)
    N = sortCoef.shape[0] / 10

    font_size = 20
    # color_cycle = ['b', 'g', 'r', 'c', 'm', 'y', 'k', 'lightblue', 'gold', 'pink']
    color_cycle = []
    for n in range(10):
        color_cycle.append((n * 0.1, 1.0 - n * 0.1, 0.0))
    pfValuesAll = pd.DataFrame()
    for n in range(10):
        tmpData = sortCoef.head(N * (n + 1)).tail(N)
        mean_beta = tmpData['beta'].mean()
        wTickers = tmpData[['ticker']].reset_index(drop=True)
        wTickers['weight'] = 1 / np.float64(N)
        portfolio = wTickers.merge(prices_build).rename(columns={'adj_close': 'price'})
        portfolio['nShare'] = (CAPITAL * portfolio['weight'] / portfolio['price']).map(functions.intPart)
        pfValues = functions.testPortfolio_simple(StockPrices, StockReturns, SP500Prices, StockBeta,
                                                  portfolio, test_start_date, test_end_date)
        pfValues['beta group'] = n
        pfValues['mean beta'] = mean_beta
        pfValues['value'] = pfValues['value'] + CAPITAL - pfValues['value'][0]
        plt.plot(pfValues['date'], pfValues['value'],
                 linewidth=2.0, color=color_cycle[n],
                 label='mean beta %0.2f' % mean_beta)
        pfValuesAll = pfValuesAll.append(pfValues)

    matplotlib.rc('xtick', labelsize=font_size)
    matplotlib.rc('ytick', labelsize=font_size)

    # plt.title('Performance of Beta Groups', size=font_size)
    plt.ylabel('Account Value', size=font_size)
    plt.xlabel('Date', size=font_size)
    plt.grid()
    plt.legend(loc=3)
    plt.show()
    return pfValuesAll
pf_0208['price_current'] = pf_0208['price_current'].map(dollar_to_float)
pf_0208['value'] = pf_0208['value'].map(dollar_to_float) * pf_0208['nShare'].map(lambda q: np.sign(q))

# single stock performance
pf_0208['return'] = np.log(pf_0208['price_current'] / pf_0208['price']) * 100 * np.sign(pf_0208['nShare'])
pf_0208['position'] = np.abs(pf_0208['value'])

# test_end_date = last_date
decay = 0.003
tickers = get_stock_universe(StockPrices)
build_start_date = datetime.datetime(2012, 2, 6)
build_end_date = datetime.datetime(2015, 2, 6)

# prices_build = StockPrices[StockPrices['date'] == build_end_date][['ticker', 'adj_close']]

(Coef, Res) = functions.wReg(StockReturns, CarhartDaily, tickers, decay,
                             build_start_date, build_end_date)
tickers_after_reg = tickers.merge(Coef[['ticker']])
tickers_industry = tickers.merge(industry_data[['ticker']])
betas = Coef.merge(tickers_industry).rename(columns={'Mkt-RF': 'beta'})[['ticker', 'beta']].reset_index(drop=True)
sortCoef = betas.sort('beta').reset_index(drop=True)
N = sortCoef.shape[0] / 10
# long_tickers = sortCoef.head(4*N).tail(3*N)[['ticker']].sort('ticker').reset_index(drop=True)
long_tickers = sortCoef.head(4 * N)[['ticker']].sort('ticker').reset_index(drop=True)
short_tickers = sortCoef.tail(4 * N)[['ticker']].sort('ticker').reset_index(drop=True)
beta_bound = 0.4
position_bound = 0.02
sector_bound = 0.02
three_factor_bound = 0.01
trim = 0.002

stats, wTickers = pf_optimizer(long_tickers, short_tickers, Coef, industry_data, CarhartDaily, StockBeta,
Beispiel #3
0
def get_bab_pf_values(StockReturns):
    first_date = StockPrices['date'].min()
    last_date = StockPrices['date'].max()
    stock_first = StockPrices[StockPrices['date'] == first_date][[
        'ticker'
    ]].reset_index(drop=True)
    stock_last = StockPrices[StockPrices['date'] == last_date][[
        'ticker'
    ]].reset_index(drop=True)
    stock_universe = stock_first.merge(stock_last).merge(StockBeta)
    tickers = stock_universe[['ticker']]
    # test_dates = np.sort(StockPrices['date'].astype(datetime.datetime).unique())
    build_start_date = datetime.datetime(2011, 11, 1)
    build_end_date = datetime.datetime(2014, 11, 7)
    test_start_date = datetime.datetime(2014, 11, 10)
    test_end_date = datetime.datetime(2015, 1, 31)
    decay = 0.003

    prices_build = StockPrices[StockPrices['date'] == build_end_date][[
        'ticker', 'adj_close'
    ]]
    (Coef, Res) = functions.wReg(StockReturns, CarhartDaily, tickers, decay,
                                 build_start_date, build_end_date)
    betas = Coef.merge(tickers).rename(columns={'Mkt-RF': 'beta'})[[
        'ticker', 'beta'
    ]].reset_index(drop=True)
    sortCoef = betas.sort('beta').reset_index(drop=True)
    N = sortCoef.shape[0] / 10

    font_size = 20
    # color_cycle = ['b', 'g', 'r', 'c', 'm', 'y', 'k', 'lightblue', 'gold', 'pink']
    color_cycle = []
    for n in range(10):
        color_cycle.append((n * 0.1, 1.0 - n * 0.1, 0.0))
    pfValuesAll = pd.DataFrame()
    for n in range(10):
        tmpData = sortCoef.head(N * (n + 1)).tail(N)
        mean_beta = tmpData['beta'].mean()
        wTickers = tmpData[['ticker']].reset_index(drop=True)
        wTickers['weight'] = 1 / np.float64(N)
        portfolio = wTickers.merge(prices_build).rename(
            columns={'adj_close': 'price'})
        portfolio['nShare'] = (CAPITAL * portfolio['weight'] /
                               portfolio['price']).map(functions.intPart)
        pfValues = functions.testPortfolio_simple(StockPrices, StockReturns,
                                                  SP500Prices, StockBeta,
                                                  portfolio, test_start_date,
                                                  test_end_date)
        pfValues['beta group'] = n
        pfValues['mean beta'] = mean_beta
        pfValues['value'] = pfValues['value'] + CAPITAL - pfValues['value'][0]
        plt.plot(pfValues['date'],
                 pfValues['value'],
                 linewidth=2.0,
                 color=color_cycle[n],
                 label='mean beta %0.2f' % mean_beta)
        pfValuesAll = pfValuesAll.append(pfValues)

    matplotlib.rc('xtick', labelsize=font_size)
    matplotlib.rc('ytick', labelsize=font_size)

    # plt.title('Performance of Beta Groups', size=font_size)
    plt.ylabel('Account Value', size=font_size)
    plt.xlabel('Date', size=font_size)
    plt.grid()
    plt.legend(loc=3)
    plt.show()
    return pfValuesAll
START_TRAIN = datetime.datetime(2011, 11, 1)
END_TRAIN = datetime.datetime(2014, 11, 6)
BUILD_DATE = datetime.datetime(2014,11, 7)
BETA_BOUND = 0.4
WEIGHT_BOUND = 0.02
CAPITAL = 1e7

DataFolder = 'D:\Dropbox\CQA 2014\Data'
(StockPrices, SP500Prices, CarhartDaily, StockBeta) = ReadData.ReadAll(DataFolder)
StockReturns = ReadData.ReadReturn(DataFolder)
SP500Returns = ReadData.GetSP500Return(SP500Prices)
tickers = ReadData.ReadTickers(DataFolder)

decay = 0.003 # Cheating...# Half-Value Period is 100 trading days
(Coef, Res) = functions.wReg(StockReturns, CarhartDaily, tickers, decay, START_TRAIN, END_TRAIN)
Coef.to_csv(r'%s/Coef_%s_%s_%.4f.csv' % (DataFolder, START_TRAIN.date(), END_TRAIN.date(), decay), index=False)
Res.to_csv(r'%s/Res_%s_%s_%.4f.csv' % (DataFolder, START_TRAIN.date(), END_TRAIN.date(), decay), index=False)
# Coef = pd.read_csv(r'%s/Coef_%s_%s_%.4f.csv' % (DataFolder, START_TRAIN.date(), END_TRAIN.date(), decay))
# Res = pd.read_csv(r'%s/Res_%s_%s_%.4f.csv' % (DataFolder, START_TRAIN.date(), END_TRAIN.date(), decay))


betas = Coef.merge(tickers).rename(columns={'Mkt-RF': 'beta'})[['ticker', 'beta']].reset_index(drop=True)
sortCoef = betas.sort('beta').reset_index(drop=True)
N = sortCoef.shape[0] / 10
longTickers = sortCoef.head(4*N).tail(3*N)[['ticker']].sort('ticker').reset_index(drop=True)
shortTickers = sortCoef.tail(4*N)[['ticker']].sort('ticker').reset_index(drop=True)
pfTickers = pd.concat((shortTickers[['ticker']], longTickers[['ticker']]), axis=0).sort('ticker').reset_index(drop=True)
# def getCovMatrix(tickers):

CarhartSample = CarhartDaily[(CarhartDaily['date'] >= START_TRAIN) &
n_periods = (test_dates.shape[0] - start_index - rebalance_gap) / rebalance_gap
pfValues = pd.DataFrame()

# n_periods = 1
total_value = CAPITAL
sp500_value = CAPITAL
value_error_count = 0
diff_threshold = 0.05

for k in range(n_periods):
    # k = 13
    back_date = test_dates[start_index - 750 + k * rebalance_gap]
    start_date = test_dates[start_index + k * rebalance_gap]
    end_date = test_dates[start_index + (k+1) * rebalance_gap]
    print 'end_date = %s' % end_date
    (Coef, Res) = functions.wReg(StockReturns, CarhartDaily, tickers, decay, back_date, start_date)
    # find long/short universe
    betas = Coef.merge(tickers).rename(columns={'Mkt-RF': 'beta'})[['ticker', 'beta']].reset_index(drop=True)
    sortCoef = betas.sort('beta').reset_index(drop=True)
    N = sortCoef.shape[0] / 10
    longTickers = sortCoef.head(4*N).tail(3*N)[['ticker']].sort('ticker').reset_index(drop=True)
    shortTickers = sortCoef.tail(3*N)[['ticker']].append(sortCoef.head(N)[['ticker']]).sort('ticker').reset_index(drop=True)
    shortTickersHigh = sortCoef.tail(3*N)[['ticker']].sort('ticker').reset_index(drop=True)
    shortTickersLow = sortCoef.head(N)[['ticker']].sort('ticker').reset_index(drop=True)
    mean_smb_40 = CarhartDaily[CarhartDaily['date'] <= start_date]['SMB'].tail(40).mean()
    mean_smb_130 = CarhartDaily[CarhartDaily['date'] <= start_date]['SMB'].tail(130).mean()
    diff_mean = mean_smb_40 - mean_smb_130
    try:
        (opt_comp, wTickers) = functions.pfOptimizer8(longTickers, shortTickersHigh, shortTickersLow,
                                                      Coef, Res, CarhartDaily, StockBeta,
                                                      BETA_BOUND, WEIGHT_BOUND, back_date, start_date,
Beispiel #6
0
    dollar_to_float) * pf_0208['nShare'].map(lambda q: np.sign(q))

# single stock performance
pf_0208['return'] = np.log(pf_0208['price_current'] /
                           pf_0208['price']) * 100 * np.sign(pf_0208['nShare'])
pf_0208['position'] = np.abs(pf_0208['value'])

# test_end_date = last_date
decay = 0.003
tickers = get_stock_universe(StockPrices)
build_start_date = datetime.datetime(2012, 2, 6)
build_end_date = datetime.datetime(2015, 2, 6)

# prices_build = StockPrices[StockPrices['date'] == build_end_date][['ticker', 'adj_close']]

(Coef, Res) = functions.wReg(StockReturns, CarhartDaily, tickers, decay,
                             build_start_date, build_end_date)
tickers_after_reg = tickers.merge(Coef[['ticker']])
tickers_industry = tickers.merge(industry_data[['ticker']])
betas = Coef.merge(tickers_industry).rename(columns={'Mkt-RF': 'beta'})[[
    'ticker', 'beta'
]].reset_index(drop=True)
sortCoef = betas.sort('beta').reset_index(drop=True)
N = sortCoef.shape[0] / 10
# long_tickers = sortCoef.head(4*N).tail(3*N)[['ticker']].sort('ticker').reset_index(drop=True)
long_tickers = sortCoef.head(4 * N)[['ticker'
                                     ]].sort('ticker').reset_index(drop=True)
short_tickers = sortCoef.tail(4 * N)[['ticker'
                                      ]].sort('ticker').reset_index(drop=True)
beta_bound = 0.4
position_bound = 0.02
sector_bound = 0.02
def risk_return_expectation():
    back_date = datetime.datetime(2010, 11, 1)
    start_date = datetime.datetime(2013, 11, 1)
    end_date = datetime.datetime(2014, 10, 31)
    tickers = ReadData.ReadTickers(DataFolder)
    BETA_BOUND = 0.4
    WEIGHT_BOUND = 0.02
    decay = 0.003

    (Coef, Res) = functions.wReg(StockReturns, CarhartDaily, tickers, decay,
                                 back_date, start_date)
    betas = Coef.merge(tickers).rename(columns={'Mkt-RF': 'beta'})[[
        'ticker', 'beta'
    ]].reset_index(drop=True)
    sortCoef = betas.sort('beta').reset_index(drop=True)
    N = sortCoef.shape[0] / 10
    longTickers = sortCoef.head(4 * N).tail(
        3 * N)[['ticker']].sort('ticker').reset_index(drop=True)
    shortTickers = sortCoef.tail(
        3 * N)[['ticker']].sort('ticker').reset_index(drop=True)
    wTickers = functions.pfOptimizer(longTickers, shortTickers, Coef,
                                     StockBeta, BETA_BOUND, WEIGHT_BOUND)
    wTickers = wTickers[(wTickers['weight'] >= 0.001) |
                        (wTickers['weight'] <= -0.001)]
    total_value = 1e7
    sp500_value = 1e7

    # Initial Exposures
    Exposure = wTickers.merge(Coef)
    ini_beta = (Exposure['weight'] * Exposure['Mkt-RF']).sum()
    ini_smb = (Exposure['weight'] * Exposure['SMB']).sum()
    ini_hml = (Exposure['weight'] * Exposure['HML']).sum()
    ini_umd = (Exposure['weight'] * Exposure['UMD']).sum()
    print 'ini_beta = %.2f' % ini_beta
    print 'ini_smb = %.2f' % ini_smb
    print 'ini_hml = %.2f' % ini_hml
    print 'ini_umd = %.2f' % ini_umd

    # test portfolio
    pfValues = functions.testPortfolio2(
        StockPrices, SP500Prices, StockBeta, Coef, wTickers, total_value,
        sp500_value, start_date,
        end_date).rename(columns={'SP500value': 'sp500value'})
    pfValues['return'] = (pfValues['value'] - total_value) / total_value
    pfValues['sp500return'] = (pfValues['sp500value'] -
                               total_value) / total_value

    fig = plt.figure()
    ax = fig.add_subplot(1, 1, 1)
    matplotlib.rc('xtick', labelsize=36)
    matplotlib.rc('ytick', labelsize=36)
    plt.plot(pfValues['date'],
             pfValues['return'] * 100,
             color=cit_color,
             linewidth=6,
             label='Portfolio Value')
    plt.plot(pfValues['date'],
             pfValues['sp500return'] * 100,
             color='b',
             linewidth=6,
             label='S&P 500')
    plt.legend(loc=2, prop={'size': 36})
    fmt = '%.2f%%'  # Format you want the ticks, e.g. '40%'
    yticks = mtick.FormatStrFormatter(fmt)
    plt.xticks(rotation=25)
    ax.yaxis.set_major_formatter(yticks)
    plt.gcf().subplots_adjust(bottom=0.18)
    plt.grid()
    plt.show()

    breakpoints = [
        datetime.datetime(2013, 11, 30),
        datetime.datetime(2013, 12, 31),
        datetime.datetime(2014, 1, 31),
        datetime.datetime(2014, 2, 28),
        datetime.datetime(2014, 3, 31),
        datetime.datetime(2014, 4, 30),
        datetime.datetime(2014, 5, 31),
        datetime.datetime(2014, 6, 30),
        datetime.datetime(2014, 7, 31),
        datetime.datetime(2014, 8, 31),
        datetime.datetime(2014, 9, 30),
        datetime.datetime(2014, 10, 31),
    ]

    comparison = pd.DataFrame()
    tmp_start = datetime.datetime(2013, 10, 30)
    for tmp_end in breakpoints:
        print tmp_end
        tmp_pfValues = pfValues[(pfValues['date'] > tmp_start)
                                & (pfValues['date'] <= tmp_end)]
        # tmp_return = tmp_pfValues['return'].sum()
        # tmp_sp500_return = tmp_pfValues['sp500return'].sum()
        start_value = tmp_pfValues['value'].iloc[0]
        end_value = tmp_pfValues['value'].iloc[-1]
        tmp_return = ((end_value - start_value) / start_value) * 100
        start_sp500 = tmp_pfValues['sp500value'].iloc[0]
        end_sp500 = tmp_pfValues['sp500value'].iloc[-1]
        tmp_sp500_return = ((end_sp500 - start_sp500) / start_value) * 100
        comparison = comparison.append(
            pd.DataFrame([{
                'return': tmp_return,
                'sp500return': tmp_sp500_return
            }]))
        tmp_start = tmp_end

    comparison

    pfReturns = pfValues[['date', 'value', 'sp500value']]
    pfReturns['daily_return'] = (
        pfReturns['value'] -
        pfReturns['value'].shift(1)) / pfReturns['value'].shift(1)
    pfReturns['daily_sp500return'] = (
        pfReturns['sp500value'] -
        pfReturns['sp500value'].shift(1)) / pfReturns['value'].shift(1)
    pfReturns = pfReturns[1:]

    # Annualized volatility
    vol_portfolio = pfReturns['daily_return'].std() * math.sqrt(252)
    vol_sp500 = pfReturns['daily_sp500return'].std() * math.sqrt(252)
    n_days = np.float(pfReturns.shape[0])
    ave_return = ((pfValues['value'].iloc[-1] / pfValues['value'].iloc[0])**
                  (1 / n_days) - 1) * 100
    ave_sp500_return = (
        (pfValues['sp500value'].iloc[-1] / pfValues['sp500value'].iloc[0])**
        (1 / n_days) - 1) * 100
    cum_return = (pfValues['value'].iloc[-1] -
                  pfValues['value'].iloc[0]) / pfValues['value'].iloc[0] * 100
    cum_sp500return = (
        pfValues['sp500value'].iloc[-1] -
        pfValues['sp500value'].iloc[0]) / pfValues['sp500value'].iloc[0] * 100
    print 'cum_return = %.2f' % cum_return
    print 'cum_sp500return = %.2f' % cum_sp500return
    print 'vol_portfolio = %.4f' % vol_portfolio
    print 'vol_sp500 = %.4f' % vol_sp500

    sharpe_portfolio = pfReturns['daily_return'].mean() / vol_portfolio * 252
    sharpe_sp500 = pfReturns['daily_sp500return'].mean() / vol_sp500 * 252

    down_dev_portfolio = math.sqrt(
        pfReturns[pfReturns['daily_return'] < 0]['daily_return'].map(
            lambda x: x**2).sum() / n_days)
    down_dev_sp500 = math.sqrt(
        pfReturns[pfReturns['daily_sp500return'] < 0]['daily_sp500return'].map(
            lambda x: x**2).sum() / n_days)

    print 'down_dev_portfolio = %.4f' % down_dev_portfolio
    print 'down_dev_sp500 = %.4f' % down_dev_sp500

    max_drawdown = 0
    max_drawdown_sp500 = 0

    for i in range(pfValues.shape[0] - 1):
        for j in range(i + 1, pfValues.shape[0]):
            tmp_drawdown = (
                pfValues['value'].iloc[j] -
                pfValues['value'].iloc[i]) / pfValues['value'].iloc[i] * 100
            tmp_drawdown_sp500 = (pfValues['sp500value'].iloc[j] -
                                  pfValues['sp500value'].iloc[i]
                                  ) / pfValues['sp500value'].iloc[i] * 100
            max_drawdown = min(max_drawdown, tmp_drawdown)
            max_drawdown_sp500 = min(max_drawdown_sp500, tmp_drawdown_sp500)

    print 'max_drawdown = %.2f' % max_drawdown
    print 'max_drawdown_sp500 = %.2f' % max_drawdown_sp500

    pfReturns = pfReturns.merge(CarhartDaily, on='date')
    y = pfReturns['daily_return'] * 100 - pfReturns['RF']
    X = sm.add_constant(pfReturns[['Mkt-RF', 'SMB', 'HML', 'UMD']])
    model = sm.OLS(y, X).fit()
    print model.params
Beispiel #8
0
n_periods = (test_dates.shape[0] - start_index - rebalance_gap) / rebalance_gap
pfValues = pd.DataFrame()

# n_periods = 1
total_value = CAPITAL
sp500_value = CAPITAL
value_error_count = 0
diff_threshold = 0.05

for k in range(n_periods):
    # k = 13
    back_date = test_dates[start_index - 750 + k * rebalance_gap]
    start_date = test_dates[start_index + k * rebalance_gap]
    end_date = test_dates[start_index + (k + 1) * rebalance_gap]
    print 'end_date = %s' % end_date
    (Coef, Res) = functions.wReg(StockReturns, CarhartDaily, tickers, decay,
                                 back_date, start_date)
    # find long/short universe
    betas = Coef.merge(tickers).rename(columns={'Mkt-RF': 'beta'})[[
        'ticker', 'beta'
    ]].reset_index(drop=True)
    sortCoef = betas.sort('beta').reset_index(drop=True)
    N = sortCoef.shape[0] / 10
    longTickers = sortCoef.head(4 * N).tail(
        3 * N)[['ticker']].sort('ticker').reset_index(drop=True)
    shortTickers = sortCoef.tail(3 * N)[['ticker']].append(
        sortCoef.head(N)[['ticker']]).sort('ticker').reset_index(drop=True)
    shortTickersHigh = sortCoef.tail(
        3 * N)[['ticker']].sort('ticker').reset_index(drop=True)
    shortTickersLow = sortCoef.head(N)[[
        'ticker'
    ]].sort('ticker').reset_index(drop=True)
def risk_return_expectation():
    back_date = datetime.datetime(2010, 11, 1)
    start_date = datetime.datetime(2013, 11, 1)
    end_date = datetime.datetime(2014, 10, 31)
    tickers = ReadData.ReadTickers(DataFolder)
    BETA_BOUND = 0.4
    WEIGHT_BOUND = 0.02
    decay = 0.003

    (Coef, Res) = functions.wReg(StockReturns, CarhartDaily, tickers, decay, back_date, start_date)
    betas = Coef.merge(tickers).rename(columns={'Mkt-RF': 'beta'})[['ticker', 'beta']].reset_index(drop=True)
    sortCoef = betas.sort('beta').reset_index(drop=True)
    N = sortCoef.shape[0] / 10
    longTickers = sortCoef.head(4*N).tail(3*N)[['ticker']].sort('ticker').reset_index(drop=True)
    shortTickers = sortCoef.tail(3*N)[['ticker']].sort('ticker').reset_index(drop=True)
    wTickers = functions.pfOptimizer(longTickers, shortTickers,
                                                  Coef, StockBeta,
                                                  BETA_BOUND, WEIGHT_BOUND)
    wTickers = wTickers[(wTickers['weight'] >= 0.001) | (wTickers['weight'] <= -0.001)]
    total_value = 1e7
    sp500_value = 1e7

    # Initial Exposures
    Exposure = wTickers.merge(Coef)
    ini_beta = (Exposure['weight']*Exposure['Mkt-RF']).sum()
    ini_smb = (Exposure['weight']*Exposure['SMB']).sum()
    ini_hml = (Exposure['weight']*Exposure['HML']).sum()
    ini_umd = (Exposure['weight']*Exposure['UMD']).sum()
    print 'ini_beta = %.2f' % ini_beta
    print 'ini_smb = %.2f' % ini_smb
    print 'ini_hml = %.2f' % ini_hml
    print 'ini_umd = %.2f' % ini_umd

    # test portfolio
    pfValues = functions.testPortfolio2(StockPrices, SP500Prices, StockBeta, Coef, wTickers,
                                        total_value, sp500_value, start_date, end_date).rename(columns={'SP500value': 'sp500value'})
    pfValues['return'] = (pfValues['value']-total_value)/total_value
    pfValues['sp500return'] = (pfValues['sp500value']-total_value)/total_value

    fig = plt.figure()
    ax = fig.add_subplot(1,1,1)
    matplotlib.rc('xtick', labelsize=36)
    matplotlib.rc('ytick', labelsize=36)
    plt.plot(pfValues['date'], pfValues['return']*100, color=cit_color, linewidth=6,
             label='Portfolio Value')
    plt.plot(pfValues['date'], pfValues['sp500return']*100, color='b', linewidth=6,
             label='S&P 500')
    plt.legend(loc=2, prop={'size': 36})
    fmt = '%.2f%%' # Format you want the ticks, e.g. '40%'
    yticks = mtick.FormatStrFormatter(fmt)
    plt.xticks(rotation=25)
    ax.yaxis.set_major_formatter(yticks)
    plt.gcf().subplots_adjust(bottom=0.18)
    plt.grid()
    plt.show()

    breakpoints = [datetime.datetime(2013, 11, 30),
                   datetime.datetime(2013, 12, 31),
                   datetime.datetime(2014, 1, 31),
                   datetime.datetime(2014, 2, 28),
                   datetime.datetime(2014, 3, 31),
                   datetime.datetime(2014, 4, 30),
                   datetime.datetime(2014, 5, 31),
                   datetime.datetime(2014, 6, 30),
                   datetime.datetime(2014, 7, 31),
                   datetime.datetime(2014, 8, 31),
                   datetime.datetime(2014, 9, 30),
                   datetime.datetime(2014, 10, 31),
                   ]

    comparison = pd.DataFrame()
    tmp_start = datetime.datetime(2013, 10, 30)
    for tmp_end in breakpoints:
        print tmp_end
        tmp_pfValues = pfValues[(pfValues['date'] > tmp_start) &
                                (pfValues['date'] <= tmp_end)]
        # tmp_return = tmp_pfValues['return'].sum()
        # tmp_sp500_return = tmp_pfValues['sp500return'].sum()
        start_value = tmp_pfValues['value'].iloc[0]
        end_value = tmp_pfValues['value'].iloc[-1]
        tmp_return = ((end_value - start_value) / start_value) * 100
        start_sp500 = tmp_pfValues['sp500value'].iloc[0]
        end_sp500 = tmp_pfValues['sp500value'].iloc[-1]
        tmp_sp500_return = ((end_sp500 - start_sp500) / start_value) * 100
        comparison = comparison.append(pd.DataFrame([{'return': tmp_return,
                                                     'sp500return': tmp_sp500_return
                                                     }]))
        tmp_start = tmp_end

    comparison

    pfReturns = pfValues[['date', 'value', 'sp500value']]
    pfReturns['daily_return'] = (pfReturns['value']-pfReturns['value'].shift(1))/pfReturns['value'].shift(1)
    pfReturns['daily_sp500return'] = (pfReturns['sp500value']-pfReturns['sp500value'].shift(1))/pfReturns['value'].shift(1)
    pfReturns = pfReturns[1:]

    # Annualized volatility
    vol_portfolio = pfReturns['daily_return'].std()*math.sqrt(252)
    vol_sp500 = pfReturns['daily_sp500return'].std()*math.sqrt(252)
    n_days = np.float(pfReturns.shape[0])
    ave_return = ((pfValues['value'].iloc[-1]/pfValues['value'].iloc[0])**(1/n_days)-1)*100
    ave_sp500_return = ((pfValues['sp500value'].iloc[-1]/pfValues['sp500value'].iloc[0])**(1/n_days)-1)*100
    cum_return = (pfValues['value'].iloc[-1]-pfValues['value'].iloc[0])/pfValues['value'].iloc[0]*100
    cum_sp500return = (pfValues['sp500value'].iloc[-1]-pfValues['sp500value'].iloc[0])/pfValues['sp500value'].iloc[0]*100
    print 'cum_return = %.2f' % cum_return
    print 'cum_sp500return = %.2f' % cum_sp500return
    print 'vol_portfolio = %.4f' % vol_portfolio
    print 'vol_sp500 = %.4f' % vol_sp500

    sharpe_portfolio = pfReturns['daily_return'].mean()/vol_portfolio * 252
    sharpe_sp500 = pfReturns['daily_sp500return'].mean()/vol_sp500  * 252

    down_dev_portfolio = math.sqrt(pfReturns[pfReturns['daily_return']<0]['daily_return'].map(lambda x: x**2).sum()/n_days)
    down_dev_sp500 = math.sqrt(pfReturns[pfReturns['daily_sp500return']<0]['daily_sp500return'].map(lambda x: x**2).sum()/n_days)

    print 'down_dev_portfolio = %.4f' % down_dev_portfolio
    print 'down_dev_sp500 = %.4f' % down_dev_sp500

    max_drawdown = 0
    max_drawdown_sp500 = 0

    for i in range(pfValues.shape[0]-1):
        for j in range(i+1, pfValues.shape[0]):
            tmp_drawdown = (pfValues['value'].iloc[j]-pfValues['value'].iloc[i])/pfValues['value'].iloc[i]*100
            tmp_drawdown_sp500 = (pfValues['sp500value'].iloc[j]-pfValues['sp500value'].iloc[i])/pfValues['sp500value'].iloc[i]*100
            max_drawdown = min(max_drawdown, tmp_drawdown)
            max_drawdown_sp500 = min(max_drawdown_sp500, tmp_drawdown_sp500)

    print 'max_drawdown = %.2f' % max_drawdown
    print 'max_drawdown_sp500 = %.2f' % max_drawdown_sp500

    pfReturns = pfReturns.merge(CarhartDaily, on='date')
    y = pfReturns['daily_return'] * 100 - pfReturns['RF']
    X = sm.add_constant(pfReturns[['Mkt-RF', 'SMB', 'HML', 'UMD']])
    model = sm.OLS(y, X).fit()
    print model.params
END = datetime.datetime(2014, 11, 5)

(StockPrices, SP500Prices, CarhartDaily,
 StockBeta) = ReadData.ReadAll(DataFolder)
StockReturns = ReadData.ReadReturn(DataFolder)
SP500Returns = ReadData.GetSP500Return(SP500Prices)
tickers = ReadData.ReadTickers(DataFolder)

# StockReturnsTrain = StockReturns[(StockReturns['endDate'] >= START_TRAIN) &
#                                 (StockReturns['endDate'] <= END_TRAIN)].merge(tickers)
# StockReturnsTest = StockReturns[StockReturns['endDate'] >= START].merge(tickers)

decayList = [0, 0.001, 0.002, 0.003, 0.004, 0.005, 0.01]
# decay = functions.GetDecay(StockReturns, CarhartDaily, decayList, START_TRAIN, END_TRAIN, START, END, tickers)
decay = 0.003  # Cheating...
(Coef, Res) = functions.wReg(StockReturns, CarhartDaily, tickers, decay,
                             START_TRAIN, END_TRAIN)

Coef.to_csv(r'%s/Coef_%s_%s_%.4f.csv' %
            (DataFolder, START_TRAIN.date(), END_TRAIN.date(), decay),
            index=False)
Res.to_csv(r'%s/Res_%s_%s_%.4f.csv' %
           (DataFolder, START_TRAIN.date(), END_TRAIN.date(), decay),
           index=False)
# comp = StockBeta.merge(CoefTrain[['ticker', 'betaTrain']]).merge(CoefTest[['ticker', 'betaTest']])
# plt.figure(1)
# plt.subplot(221)
# plt.xlabel('cqaBeta')
# plt.ylabel('betaTrain')
# plt.scatter(comp['cqaBeta'], comp['betaTrain'])
# plt.plot(range(4), range(4), 'r-')
# plt.subplot(222)