Python中带宽方法的投资组合重新平衡 [英] Portfolio rebalancing with bandwidth method in python
问题描述
我们需要计算2只股票的不断重新平衡的投资组合.让我们将它们称为A和B.它们都应在投资组合中具有相等的份额.因此，如果我的投资组合中有100美元，则有50美元投向了A，而50美元投向了B.由于两种股票的表现都大相径庭，它们将无法保持相等的权重(3个月后，A可能已经价值70美元，而B下降至45 $).问题在于，他们必须将自己的投资组合份额保持在一定的公差范围内.该带宽为5％.因此，我需要一个函数来执行以下操作:如果A> B * 1.05或A * 1.05< B然后重新平衡.
We need to calculate a continuously rebalanced portfolio of 2 stocks. Lets call them A and B. They shall both have an equal part of the portfolio. So if I have 100$ in my portfolio 50$ get invested in A and 50$ in B. As both stocks perform very differently they will not keep their equal weights (after 3 month already A may be worth 70$ while B dropped to 45$). The problem is that they have to keep their share of the portfolio within a certain bandwidth of tolerance. This bandwidth is 5%. So I need a function that does: If A > B*1.05 or A*1.05 < B then rebalance.
第一部分仅用于以最快的方式使某些数据具有共同的讨论基础并使结果具有可比性，因此您只需复制并粘贴整个代码即可使用.
This first part serves only to get the fastest way some data to have a common basis of discussion and to make results comparable, so you can just copy and paste this whole code and it works for you..
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基本上只是计算数据帧的长度，因此可以始终告诉我们我们在哪里".因此，实际的计算从这里开始:
Nowe start to calculate the relative performance of each stock with the formula: df.ibm/df.ibm[0]. The problem is that as soon as we break the first bandwidth, we need to reset the 0 in our formula: df.ibm/df.ibm[0], since we rebalance and need to start calculating from that point on. So we use df.d for this placeholder function and set it equal to df.t as soon as a bandwidth gets broken df.t basically just counts the length of the dataframe and can tell us therefore always "where we are". So here the actual calculation starts:
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)
The problem is, that I am getting this error form the last line of code, where I try to apply the function with 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')问题是错误语句的给定选项都不能解决我的问题，所以我真的不知道该怎么办...
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') The problem is that none of the given options of the error statement solves my problem, so I really don't know what to do...
到目前为止，我唯一发现的就是下面的链接，但是调用R函数对我来说不起作用，因为我需要将其应用于相当大的数据集，而且我还可能在此函数中实现优化，因此肯定可以需要在python中构建.无论如何，这是链接:在python中使用投资组合优化方法的财务库
The only thing I found so far was the link below, but calling a R function won't work for me because I need to apply that to quite big datasets and I may also implement an optimization in this function, so it definitely needs to be built in python. Here is the link anyway: Finance Lib with portfolio optimization method in python
手动(这不是处理大数据的好方法)，我计算出重新平衡的第一个日期为:03.11.1972 00:00:00
Manually (what is not a good way to handle big data), I calculated that the first date for a rebalancing would be: 03.11.1972 00:00:00
第一次重新平衡时数据帧的输出应如下所示:
The output of the dataframe at the first rebalancing should look like this:
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
非常感谢您的支持！
@Alexander:是的，第二天将进行重新平衡.
@Alexander: Yes, the rebalancing will take place the following day.
@maxymoo:如果在代码之后执行此代码，则将获得每只股票的投资组合权重，它们的权重不在45％到55％之间.而是介于75％和25％之间:
@maxymoo: If you implement this code after yours, you get the portfolio weights of each stock and they don't rest between 45 and 55%. It's rather between 75% and 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()
一个小时左右我都没有尝试修复，但是没有找到.
I tried no for an hour or so to fix, but didn't find it.
我可以做些什么使这个问题更清楚吗?
Can I do anything to make this question clearer?
推荐答案
此处的主要思想是根据美元而不是比率来工作.如果你 跟踪ibm的股票数量和相对美元价值，以及 福特股票，那么您可以将重新平衡的标准表示为
The main idea here is to work in terms of dollars instead of ratios. If you keep track of the number of shares and the relative dollar values of the ibm and ford shares, then you can express the criterion for rebalancing as
mask = (df['ratio'] >= 1+tol) | (df['ratio'] <= 1-tol)
比率等于
df['ratio'] = df['ibm value'] / df['ford value']
，df['ibm value']和df['ford value']代表实际美元价值.
and df['ibm value'], and df['ford value'] represent actual dollar values.
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])
这篇关于Python中带宽方法的投资组合重新平衡的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
