def __init__(self,
rebalancingParam=Resolution.Daily,
lookback=1,
period=63,
resolution=Resolution.Daily,
targetReturn=0.02,
optimizer=None):
"""Initialize the model
Args:
rebalancingParam: Rebalancing parameter. If it is a timedelta, date rules or Resolution, it will be converted into a function.
If None will be ignored.
The function returns the next expected rebalance time for a given algorithm UTC DateTime.
The function returns null if unknown, in which case the function will be called again in the
next loop. Returning current time will trigger rebalance.
lookback(int): Historical return lookback period
period(int): The time interval of history price to calculate the weight
resolution: The resolution of the history price
optimizer(class): Method used to compute the portfolio weights"""
self.lookback = lookback
self.period = period
self.resolution = resolution
self.optimizer = MinimumVariancePortfolioOptimizer(
-1, 1, targetReturn) if optimizer is None else optimizer
self.symbolDataBySymbol = {}
# If the argument is an instance of Resolution or Timedelta
# Redefine rebalancingFunc
rebalancingFunc = rebalancingParam
if isinstance(rebalancingParam, int):
rebalancingParam = Extensions.ToTimeSpan(rebalancingParam)
if isinstance(rebalancingParam, timedelta):
rebalancingFunc = lambda dt: dt + rebalancingParam
if rebalancingFunc:
self.SetRebalancingFunc(rebalancingFunc)
def __init__(self,
rebalancingParam = None,
lookback = 1,
period = 63,
resolution = Resolution.Daily,
optimizer = None):
"""Initialize the model
Args:
lookback(int): Historical return lookback period
period(int): The time interval of history price to calculate the weight
resolution: The resolution of the history price
optimizer(class): Method used to compute the portfolio weights"""
self.lookback = lookback
self.period = period
self.resolution = resolution
self.optimizer = MinimumVariancePortfolioOptimizer() if optimizer is None else optimizer
self.symbolDataBySymbol = {}
self.pendingRemoval = []
# If the argument is an instance of Resolution or Timedelta
# Redefine rebalancingFunc
rebalancingFunc = rebalancingParam
if isinstance(rebalancingParam, int):
rebalancingParam = Extensions.ToTimeSpan(rebalancingParam)
if isinstance(rebalancingParam, timedelta):
rebalancingFunc = lambda dt: dt + rebalancingParam
if rebalancingFunc:
self.SetRebalancingFunc(rebalancingFunc)
def __init__(self,
lookback = 1,
period = 63,
resolution = Resolution.Daily,
optimizer = None):
"""Initialize the model
Args:
lookback(int): Historical return lookback period
period(int): The time interval of history price to calculate the weight
resolution: The resolution of the history price
optimizer(class): Method used to compute the portfolio weights"""
self.lookback = lookback
self.period = period
self.resolution = resolution
self.optimizer = MinimumVariancePortfolioOptimizer() if optimizer is None else optimizer
self.symbolDataBySymbol = {}
self.pendingRemoval = []
def __init__(self,
rebalance = Resolution.Daily,
portfolioBias = PortfolioBias.LongShort,
lookback = 1,
period = 63,
resolution = Resolution.Daily,
targetReturn = 0.02,
optimizer = None):
"""Initialize the model
Args:
rebalance: Rebalancing parameter. If it is a timedelta, date rules or Resolution, it will be converted into a function.
If None will be ignored.
The function returns the next expected rebalance time for a given algorithm UTC DateTime.
The function returns null if unknown, in which case the function will be called again in the
next loop. Returning current time will trigger rebalance.
portfolioBias: Specifies the bias of the portfolio (Short, Long/Short, Long)
lookback(int): Historical return lookback period
period(int): The time interval of history price to calculate the weight
resolution: The resolution of the history price
optimizer(class): Method used to compute the portfolio weights"""
super().__init__()
self.lookback = lookback
self.period = period
self.resolution = resolution
self.portfolioBias = portfolioBias
self.sign = lambda x: -1 if x < 0 else (1 if x > 0 else 0)
lower = 0 if portfolioBias == PortfolioBias.Long else -1
upper = 0 if portfolioBias == PortfolioBias.Short else 1
self.optimizer = MinimumVariancePortfolioOptimizer(lower, upper, targetReturn) if optimizer is None else optimizer
self.symbolDataBySymbol = {}
# If the argument is an instance of Resolution or Timedelta
# Redefine rebalancingFunc
rebalancingFunc = rebalance
if isinstance(rebalance, int):
rebalance = Extensions.ToTimeSpan(rebalance)
if isinstance(rebalance, timedelta):
rebalancingFunc = lambda dt: dt + rebalance
if rebalancingFunc:
self.SetRebalancingFunc(rebalancingFunc)
class MeanVarianceOptimizationPortfolioConstructionModel(
PortfolioConstructionModel):
def __init__(self,
rebalancingParam=Resolution.Daily,
lookback=1,
period=63,
resolution=Resolution.Daily,
targetReturn=0.02,
optimizer=None):
"""Initialize the model
Args:
rebalancingParam: Rebalancing parameter. If it is a timedelta, date rules or Resolution, it will be converted into a function.
If None will be ignored.
The function returns the next expected rebalance time for a given algorithm UTC DateTime.
The function returns null if unknown, in which case the function will be called again in the
next loop. Returning current time will trigger rebalance.
lookback(int): Historical return lookback period
period(int): The time interval of history price to calculate the weight
resolution: The resolution of the history price
optimizer(class): Method used to compute the portfolio weights"""
self.lookback = lookback
self.period = period
self.resolution = resolution
self.optimizer = MinimumVariancePortfolioOptimizer(
-1, 1, targetReturn) if optimizer is None else optimizer
self.symbolDataBySymbol = {}
# If the argument is an instance of Resolution or Timedelta
# Redefine rebalancingFunc
rebalancingFunc = rebalancingParam
if isinstance(rebalancingParam, int):
rebalancingParam = Extensions.ToTimeSpan(rebalancingParam)
if isinstance(rebalancingParam, timedelta):
rebalancingFunc = lambda dt: dt + rebalancingParam
if rebalancingFunc:
self.SetRebalancingFunc(rebalancingFunc)
def ShouldCreateTargetForInsight(self, insight):
if len(
PortfolioConstructionModel.FilterInvalidInsightMagnitude(
self.Algorithm, [insight])) == 0:
return False
symbolData = self.symbolDataBySymbol.get(insight.Symbol)
if insight.Magnitude is None:
self.algorithm.SetRunTimeError(
ArgumentNullException(
'MeanVarianceOptimizationPortfolioConstructionModel does not accept \'None\' as Insight.Magnitude. Please checkout the selected Alpha Model specifications.'
))
symbolData.Add(self.Algorithm.Time, insight.Magnitude)
return True
def DetermineTargetPercent(self, activeInsights):
"""
Will determine the target percent for each insight
Args:
Returns:
"""
targets = {}
symbols = [insight.Symbol for insight in activeInsights]
# Create a dictionary keyed by the symbols in the insights with an pandas.Series as value to create a data frame
returns = {
str(symbol): data.Return
for symbol, data in self.symbolDataBySymbol.items()
if symbol in symbols
}
returns = pd.DataFrame(returns)
# The portfolio optimizer finds the optional weights for the given data
weights = self.optimizer.Optimize(returns)
weights = pd.Series(weights, index=returns.columns)
# Create portfolio targets from the specified insights
for insight in activeInsights:
weight = weights[str(insight.Symbol)]
targets[insight] = weight
return targets
def OnSecuritiesChanged(self, algorithm, changes):
'''Event fired each time the we add/remove securities from the data feed
Args:
algorithm: The algorithm instance that experienced the change in securities
changes: The security additions and removals from the algorithm'''
# clean up data for removed securities
super().OnSecuritiesChanged(algorithm, changes)
for removed in changes.RemovedSecurities:
symbolData = self.symbolDataBySymbol.pop(removed.Symbol, None)
symbolData.Reset()
# initialize data for added securities
symbols = [x.Symbol for x in changes.AddedSecurities]
history = algorithm.History(symbols, self.lookback * self.period,
self.resolution)
if history.empty: return
tickers = history.index.levels[0]
for ticker in tickers:
symbol = SymbolCache.GetSymbol(ticker)
if symbol not in self.symbolDataBySymbol:
symbolData = self.MeanVarianceSymbolData(
symbol, self.lookback, self.period)
symbolData.WarmUpIndicators(history.loc[ticker])
self.symbolDataBySymbol[symbol] = symbolData
class MeanVarianceSymbolData:
'''Contains data specific to a symbol required by this model'''
def __init__(self, symbol, lookback, period):
self.symbol = symbol
self.roc = RateOfChange(f'{symbol}.ROC({lookback})', lookback)
self.roc.Updated += self.OnRateOfChangeUpdated
self.window = RollingWindow[IndicatorDataPoint](period)
def Reset(self):
self.roc.Updated -= self.OnRateOfChangeUpdated
self.roc.Reset()
self.window.Reset()
def WarmUpIndicators(self, history):
for tuple in history.itertuples():
self.roc.Update(tuple.Index, tuple.close)
def OnRateOfChangeUpdated(self, roc, value):
if roc.IsReady:
self.window.Add(value)
def Add(self, time, value):
item = IndicatorDataPoint(self.symbol, time, value)
self.window.Add(item)
@property
def Return(self):
return pd.Series(data=[(1 + float(x.Value))**252 - 1
for x in self.window],
index=[x.EndTime for x in self.window])
@property
def IsReady(self):
return self.window.IsReady
def __str__(self, **kwargs):
return '{}: {:.2%}'.format(self.roc.Name,
(1 + self.window[0])**252 - 1)
class MeanVarianceOptimizationPortfolioConstructionModel(PortfolioConstructionModel):
def __init__(self,
rebalancingParam = None,
lookback = 1,
period = 63,
resolution = Resolution.Daily,
optimizer = None):
"""Initialize the model
Args:
lookback(int): Historical return lookback period
period(int): The time interval of history price to calculate the weight
resolution: The resolution of the history price
optimizer(class): Method used to compute the portfolio weights"""
self.lookback = lookback
self.period = period
self.resolution = resolution
self.optimizer = MinimumVariancePortfolioOptimizer() if optimizer is None else optimizer
self.symbolDataBySymbol = {}
self.pendingRemoval = []
# If the argument is an instance of Resolution or Timedelta
# Redefine rebalancingFunc
rebalancingFunc = rebalancingParam
if isinstance(rebalancingParam, int):
rebalancingParam = Extensions.ToTimeSpan(rebalancingParam)
if isinstance(rebalancingParam, timedelta):
rebalancingFunc = lambda dt: dt + rebalancingParam
if rebalancingFunc:
self.SetRebalancingFunc(rebalancingFunc)
def CreateTargets(self, algorithm, insights):
"""
Create portfolio targets from the specified insights
Args:
algorithm: The algorithm instance
insights: The insights to create portfolio targets from
Returns:
An enumerable of portfolio targets to be sent to the execution model
"""
# Always add new insights
insights = PortfolioConstructionModel.FilterInvalidInsightMagnitude(algorithm, insights)
for insight in insights:
symbolData = self.symbolDataBySymbol.get(insight.Symbol)
if insight.Magnitude is None:
algorithm.SetRunTimeError(ArgumentNullException('MeanVarianceOptimizationPortfolioConstructionModel does not accept \'None\' as Insight.Magnitude. Please checkout the selected Alpha Model specifications.'))
symbolData.Add(algorithm.Time, insight.Magnitude)
targets = []
if not self.IsRebalanceDue(insights, algorithm.UtcTime):
return targets
for symbol in self.pendingRemoval:
targets.append(PortfolioTarget.Percent(algorithm, symbol, 0))
self.pendingRemoval.clear()
symbols = [insight.Symbol for insight in insights]
if len(symbols) == 0:
return targets
# Create a dictionary keyed by the symbols in the insights with an pandas.Series as value to create a data frame
returns = { str(symbol) : data.Return for symbol, data in self.symbolDataBySymbol.items() if symbol in symbols }
returns = pd.DataFrame(returns)
# The portfolio optimizer finds the optional weights for the given data
weights = self.optimizer.Optimize(returns)
weights = pd.Series(weights, index = returns.columns)
# Create portfolio targets from the specified insights
for insight in insights:
weight = weights[str(insight.Symbol)]
target = PortfolioTarget.Percent(algorithm, insight.Symbol, weight)
if target is not None:
targets.append(target)
return targets
def OnSecuritiesChanged(self, algorithm, changes):
'''Event fired each time the we add/remove securities from the data feed
Args:
algorithm: The algorithm instance that experienced the change in securities
changes: The security additions and removals from the algorithm'''
# clean up data for removed securities
super().OnSecuritiesChanged(algorithm, changes)
for removed in changes.RemovedSecurities:
self.pendingRemoval.append(removed.Symbol)
symbolData = self.symbolDataBySymbol.pop(removed.Symbol, None)
symbolData.Reset()
# initialize data for added securities
symbols = [ x.Symbol for x in changes.AddedSecurities ]
history = algorithm.History(symbols, self.lookback * self.period, self.resolution)
if history.empty: return
tickers = history.index.levels[0]
for ticker in tickers:
symbol = SymbolCache.GetSymbol(ticker)
if symbol not in self.symbolDataBySymbol:
symbolData = self.MeanVarianceSymbolData(symbol, self.lookback, self.period)
symbolData.WarmUpIndicators(history.loc[ticker])
self.symbolDataBySymbol[symbol] = symbolData
class MeanVarianceSymbolData:
'''Contains data specific to a symbol required by this model'''
def __init__(self, symbol, lookback, period):
self.symbol = symbol
self.roc = RateOfChange(f'{symbol}.ROC({lookback})', lookback)
self.roc.Updated += self.OnRateOfChangeUpdated
self.window = RollingWindow[IndicatorDataPoint](period)
def Reset(self):
self.roc.Updated -= self.OnRateOfChangeUpdated
self.roc.Reset()
self.window.Reset()
def WarmUpIndicators(self, history):
for tuple in history.itertuples():
self.roc.Update(tuple.Index, tuple.close)
def OnRateOfChangeUpdated(self, roc, value):
if roc.IsReady:
self.window.Add(value)
def Add(self, time, value):
item = IndicatorDataPoint(self.symbol, time, value)
self.window.Add(item)
@property
def Return(self):
return pd.Series(
data = [(1 + float(x.Value))**252 - 1 for x in self.window],
index = [x.EndTime for x in self.window])
@property
def IsReady(self):
return self.window.IsReady
def __str__(self, **kwargs):
return '{}: {:.2%}'.format(self.roc.Name, (1 + self.window[0])**252 - 1)