Python中带宽方法的投资组合重新平衡

Question

我们需要计算2只股票的不断重新平衡的投资组合。让我们将它们称为A和B。它们都应具有投资组合的相等部分。因此，如果我的投资组合中有100美元，则有50美元投向了A，而50美元投向了B。由于两种股票的表现都大相径庭，它们将无法保持相等的权重（3个月后，A可能已经价值70美元，而B下降至45美元$）。问题在于，他们必须将自己的投资组合份额保持在一定的公差范围内。该带宽为5％。因此，我需要一个执行以下功能的函数：如果A>
B * 1.05或A * 1.05 <B，则重新平衡。

第一部分仅以最快的方式使某些数据具有共同的讨论基础并使结果具有可比性，因此您只需复制并粘贴整个代码即可使用。

import pandas as pd
from datetime import datetime
import numpy as np


df1 = pd.io.data.get_data_yahoo("IBM", 
                                start=datetime(1970, 1, 1), 
                                end=datetime.today())
df1.rename(columns={'Adj Close': 'ibm'}, inplace=True)

df2 = pd.io.data.get_data_yahoo("F", 
                                start=datetime(1970, 1, 1), 
                                end=datetime.today())
df2.rename(columns={'Adj Close': 'ford'}, inplace=True)

df = df1.join(df2.ford, how='inner')
del df["Open"]
del df["High"]
del df["Low"]
del df["Close"]
del df["Volume"]

现在，开始使用公式df.ibm/df.ibm[0]计算每种股票的相对表现。问题在于，一旦打破第一个带宽，就需要在公式df.ibm/df.ibm[0]中重置0，因为我们需要重新平衡并需要从该点开始计算。因此，我们将df.d用于此占位符函数，并将其设置为等于df.t，一旦带宽中断df.t基本上只是计算数据帧的长度，因此可以始终告诉我们“我们在哪里”。因此，此处开始实际计算：

tol = 0.05 #settintg the bandwidth tolerance
df["d"]= 0 # 
df["t"]= np.arange(len(df))
tol = 0.3

def flex_relative(x):
    if df.ibm/df.ibm.iloc[df.d].values < df.ford/df.ford.iloc[df.d].values * (1+tol):
        return  df.iloc[df.index.get_loc(x.name) - 1]['d'] == df.t
    elif df.ibm/df.ibm.iloc[df.d].values > df.ford/df.ford.iloc[df.d].values * (1+tol):
        return df.iloc[df.index.get_loc(x.name) - 1]['d'] == df.t
    else:
        return df.ibm/df.ibm.iloc[df.d].values, df.ford/df.ford.iloc[df.d].values



df["ibm_performance"], df["ford_performance"], = df.apply(flex_relative, axis =1)

问题是，我从代码的最后一行收到此错误，我尝试在其中使用 df.apply(flex_relative, axis =1)

ValueError: ('The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().', u'occurred at index 1972-06-01 00:00:00') 问题是错误语句的给定选项都不能解决我的问题，所以我真的不知道该怎么办…

到目前为止，我唯一发现的就是下面的链接，但是调用R函数对我来说不起作用，因为我需要将其应用于相当大的数据集，而且我可能还会对此函数进行优化，因此肯定需要内置python。

手动（这不是处理大数据的好方法），我计算出重新平衡的第一个日期是： 03.11.1972 00:00:00

第一次重新平衡时数据帧的输出应如下所示：

                     ibm        ford        d   t   ibm_performance ford_performance
1972-11-01 00:00:00 6,505655    0,387415    0   107 1,021009107 0,959552418
1972-11-02 00:00:00 6,530709    0,398136    0   108 1,017092172 0,933713605
1972-11-03 00:00:00 6,478513    0,411718    0   109 1,025286667 0,902911702 # this is the day, the rebalancing was detected
1972-11-06 00:00:00 6,363683    0,416007    109 110 1,043787536 0,893602752 # this is the day the day the rebalancing is implemented, therefore df.d gets set = df.t = 109
1972-11-08 00:00:00 6,310883    0,413861    109 111 1,052520384 0,898236364
1972-11-09 00:00:00 6,227073    0,422439    109 112 1,066686226 0,879996875

多谢您的支持！

@亚历山大：是的，重新平衡将在第二天进行。

@maxymoo：如果在代码之后执行此代码，则将获得每只股票的投资组合权重，它们的权重不在45％到55％之间。介于75％和25％之间：

df["ford_weight"] = df.ford_prop*df.ford/(df.ford_prop*df.ford+df.ibm_prop*df.ibm) #calculating the actual portfolio weights
df["ibm_weight"] = df.ibm_prop*df.ibm/(df.ford_prop*df.ford+df.ibm_prop*df.ibm)

print df
print df.ibm_weight.min()
print df.ibm_weight.max()
print df.ford_weight.min()
print df.ford_weight.max()

我一个小时左右都没有尝试修复，但是没有找到。

我可以做些什么使这个问题更清楚吗？

Answer 1

这里的主要思想是根据美元而不是比率来工作。如果您跟踪ibm和福特股票的数量以及相对美元价值，则可以将重新平衡的标准表示为

mask = (df['ratio'] >= 1+tol) | (df['ratio'] <= 1-tol)

比率等于

    df['ratio'] = df['ibm value'] / df['ford value']

和df['ibm value']，df['ford value']代表实际美元价值。

import datetime as DT
import numpy as np
import pandas as pd
import pandas.io.data as PID

def setup_df():
    df1 = PID.get_data_yahoo("IBM", 
                             start=DT.datetime(1970, 1, 1), 
                             end=DT.datetime.today())
    df1.rename(columns={'Adj Close': 'ibm'}, inplace=True)

    df2 = PID.get_data_yahoo("F", 
                             start=DT.datetime(1970, 1, 1), 
                             end=DT.datetime.today())
    df2.rename(columns={'Adj Close': 'ford'}, inplace=True)

    df = df1.join(df2.ford, how='inner')
    df = df[['ibm', 'ford']]
    df['sh ibm'] = 0
    df['sh ford'] = 0
    df['ibm value'] = 0
    df['ford value'] = 0
    df['ratio'] = 0
    return df

def invest(df, i, amount):
    """
    Invest amount dollars evenly between ibm and ford
    starting at ordinal index i.
    This modifies df.
    """
    c = dict([(col, j) for j, col in enumerate(df.columns)])
    halfvalue = amount/2
    df.iloc[i:, c['sh ibm']] = halfvalue / df.iloc[i, c['ibm']]
    df.iloc[i:, c['sh ford']] = halfvalue / df.iloc[i, c['ford']]

    df.iloc[i:, c['ibm value']] = (
        df.iloc[i:, c['ibm']] * df.iloc[i:, c['sh ibm']])
    df.iloc[i:, c['ford value']] = (
        df.iloc[i:, c['ford']] * df.iloc[i:, c['sh ford']])
    df.iloc[i:, c['ratio']] = (
        df.iloc[i:, c['ibm value']] / df.iloc[i:, c['ford value']])

def rebalance(df, tol, i=0):
    """
    Rebalance df whenever the ratio falls outside the tolerance range.
    This modifies df.
    """
    c = dict([(col, j) for j, col in enumerate(df.columns)])
    while True:
        mask = (df['ratio'] >= 1+tol) | (df['ratio'] <= 1-tol)
        # ignore prior locations where the ratio falls outside tol range
        mask[:i] = False
        try:
            # Move i one index past the first index where mask is True
            # Note that this means the ratio at i will remain outside tol range
            i = np.where(mask)[0][0] + 1
        except IndexError:
            break
        amount = (df.iloc[i, c['ibm value']] + df.iloc[i, c['ford value']])
        invest(df, i, amount)
    return df

df = setup_df()
tol = 0.05
invest(df, i=0, amount=100)
rebalance(df, tol)

df['portfolio value'] = df['ibm value'] + df['ford value']
df['ibm weight'] = df['ibm value'] / df['portfolio value']
df['ford weight'] = df['ford value'] / df['portfolio value']

print df['ibm weight'].min()
print df['ibm weight'].max()
print df['ford weight'].min()
print df['ford weight'].max()

# This shows the rows which trigger rebalancing
mask = (df['ratio'] >= 1+tol) | (df['ratio'] <= 1-tol)
print(df.loc[mask])