我们需要计算 2 只股票的持续再平衡投资组合。让我们称他们为 A 和 B。他们在投资组合中的份额应该相等。因此，如果我的投资组合中有 100 美元，50 美元投资于 A，50 美元投资于 B。由于两只股票的表现非常不同，它们将不会保持相同的权重(3 个月后 A 可能值(value) 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]。问题是，一旦我们打破了第一个带宽，我们就需要重置公式中的 0:df.ibm/df.ibm[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: ('Series 的真值不明确。使用 a.empty、a.bool()、a.item()、a.any() 或 a.all()。', u'occurred at index 1972-06-01 00:00:00') 问题是错误语句的给定选项都没有解决我的问题，所以我真的不知道该怎么做。 .

到目前为止，我唯一找到的是下面的链接，但是调用 R 函数对我来说不起作用，因为我需要将它应用于相当大的数据集，而且我可能还会在此函数中实现优化，所以它肯定需要在python中构建。这里是链接:Finance Lib with portfolio optimization method in 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

非常感谢您的支持!

@Alexander:是的，重新平衡将在第二天进行。

@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()

我尝试了 no 一个小时左右来修复，但没有找到它。

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

最佳答案

这里的主要思想是以美元而不是比率来计算。如果你 跟踪 ibm 的股票数量和相对美元值(value) 福特股票，那么您可以将重新平衡的标准表示为

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

比率等于

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

和df['ibm value']和df['ford value']代表实际的美元值(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])

关于python - 在 python 中使用带宽方法进行投资组合再平衡，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/30745160/