qis 3.2.7__tar.gz → 3.2.8__tar.gz

{qis-3.2.7 → qis-3.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qis
-Version: 3.2.7
+Version: 3.2.8
 Summary: Implementation of visualisation and reporting analytics for Quantitative Investment Strategies
 License: LICENSE.txt
 Keywords: quantitative,investing,portfolio optimization,systematic strategies,volatility

{qis-3.2.7 → qis-3.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "qis"
-version = "3.2.7"
+version = "3.2.8"
 description = "Implementation of visualisation and reporting analytics for Quantitative Investment Strategies"
 license = "LICENSE.txt"
 authors = ["Artur Sepp <artursepp@gmail.com>"]

{qis-3.2.7 → qis-3.2.8}/qis/examples/factsheets/strategy_benchmark.py

@@ -147,10 +147,12 @@ def run_unit_test(unit_test: UnitTests):
         ac_group_data = multi_portfolio_data.portfolio_datas[0].group_data
         asset_tickers = multi_portfolio_data.portfolio_datas[0].weights.columns
         sub_ac_group_data = pd.Series(asset_tickers, index=asset_tickers)
-
+        turnover_groups = multi_portfolio_data.portfolio_datas[0].group_data
+        multi_portfolio_data.portfolio_datas[0].benchmark_prices = multi_portfolio_data.benchmark_prices
         weights_tracking_error_report_by_ac_subac(multi_portfolio_data=multi_portfolio_data,
                                                   ac_group_data=ac_group_data,
                                                   sub_ac_group_data=sub_ac_group_data,
+                                                  turnover_groups=turnover_groups,
                                                   time_period=time_period)
 
     plt.show()
@@ -158,7 +160,7 @@ def run_unit_test(unit_test: UnitTests):
 
 if __name__ == '__main__':
 
-    unit_test = UnitTests.STRATEGY_BENCHMARK_PLT
+    unit_test = UnitTests.TRACKING_ERROR
 
     is_run_all_tests = False
     if is_run_all_tests:

{qis-3.2.7 → qis-3.2.8}/qis/portfolio/__init__.py

@@ -2,8 +2,8 @@
 from qis.portfolio.portfolio_data import (PortfolioData,
                                           PortfolioInput,
                                           AttributionMetric,
-                                          SnapshotPeriod,
-                                          StrategySignalData)
+                                          SnapshotPeriod)
+from qis.portfolio.signal_data import StrategySignalData
 
 from qis.portfolio.multi_portfolio_data import MultiPortfolioData
 

{qis-3.2.7 → qis-3.2.8}/qis/portfolio/portfolio_data.py

@@ -6,8 +6,7 @@ import pandas as pd
 import seaborn as sns
 import matplotlib.pyplot as plt
 from numba import njit
-from dataclasses import dataclass, asdict
-from statsmodels.regression.linear_model import RegressionResults as RegModel
+from dataclasses import dataclass
 from typing import Union, Dict, Any, Optional, Tuple, List
 from enum import Enum
 
@@ -28,6 +27,7 @@ import qis.plots.derived.returns_scatter as prs
 import qis.plots.derived.returns_heatmap as rhe
 import qis.models.linear.ewm_factors as ef
 from qis.models.linear.ewm import compute_ewm_vol
+from qis.portfolio.signal_data import StrategySignalData
 from qis.portfolio.ewm_portfolio_risk import compute_portfolio_vol, compute_portfolio_risk_contributions
 
 
@@ -347,7 +347,8 @@ class PortfolioData:
                      add_total: bool = True,
                      vol_span: int = 33,
                      freq: Optional[str] = None,
-                     is_unit_based_traded_volume: bool = True
+                     is_unit_based_traded_volume: bool = True,
+                     **kwargs
                      ) -> Union[pd.DataFrame, pd.Series]:
 
         if is_unit_based_traded_volume:  # for unit generated backtest
@@ -1476,228 +1477,41 @@ class PortfolioData:
                        ax=axs[1],
                        **kwargs)
 
-
-@dataclass
-class StrategySignalData:
-    """
-    data class instance applied for output of strategy backtest data
-    """
-    log_returns: pd.DataFrame = None
-    ra_carry: pd.DataFrame = None  # risk-adjusted carry
-    momentum: pd.DataFrame = None
-    signal: pd.DataFrame = None  # signal output
-    instrument_vols: pd.DataFrame = None  # instrument vols
-    instrument_target_vols: pd.DataFrame = None  # target vols for portfolio allocation
-    instrument_target_signal_vol_weights: pd.DataFrame = None  # target vols * signal
-    instrument_portfolio_leverages: pd.DataFrame = None  # = portfolio weight / instrument_target_signal_vol_weights
-    weights: pd.DataFrame = None  # final weights
-    kwargs: Dict[str, pd.DataFrame] = None  # any other outputs
-
-    def locate_period(self, time_period: TimePeriod) -> StrategySignalData:
-        # nb: does not work for returns
-        data_dict = asdict(self)
-        for key, df in data_dict.items():
-            if df is not None:
-                data_dict[key] = time_period.locate(df)
-        return StrategySignalData(**data_dict)
-
-    def rename_data(self, names_map: Dict[str, str]) -> StrategySignalData:
-        data_dict = asdict(self)
-        for key, df in data_dict.items():
-            if df is not None:
-                data_dict[key] = df.rename(names_map, axis=1)
-        return StrategySignalData(**data_dict)
-
-    def get_current_signal_by_groups(self, group_data: pd.Series,
-                                     group_order: List[str] = None
-                                     ) -> Dict[str, pd.DataFrame]:
-        group_dict = dfg.get_group_dict(group_data=group_data,
-                                        group_order=group_order,
-                                        total_column=None)
-        group_signals = {}
-        agg_by_group = {}
-        last_date = qis.date_to_str(self.signal.index[-21])
-        current_date = qis.date_to_str(self.signal.index[-1])
-        last_signals = self.signal.iloc[-21, :]
-        current_signals = self.signal.iloc[-1, :]
-        for group, tickers in group_dict.items():
-            last_signals_ = last_signals[tickers]
-            current_signals_ = current_signals[tickers]
-            group_signals[group] = pd.concat([last_signals_.rename(last_date),
-                                              current_signals_.rename(current_date)
-                                              ], axis=1)
-
-            agg_by_group[group] = pd.Series({last_date: np.nanmean(last_signals_),
-                                             current_date: np.nanmean(current_signals_)})
-        agg_by_group = {'Total by groups': pd.DataFrame.from_dict(agg_by_group, orient='index')}
-        agg_by_group.update(group_signals)
-        return agg_by_group
-
-    def asdiff(self, tickers: List[str] = None,
-               freq: str = None,
-               sample_size: Optional[int] = 21,  # can use rolling instead for freq
-               time_period: TimePeriod = None
-               ) -> StrategySignalData:
-
-        if tickers is None:
-            tickers = self.log_returns.columns.to_list()
-        # nb: does not work for returns
-        if time_period is not None:
-            ssd = self.locate_period(time_period=time_period)
-        else:
-            ssd = self
-
-        data_dict = asdict(ssd)
-        if sample_size is not None:
-            for key, df in data_dict.items():
-                if df is not None:
-                    data_dict[key] = qis.df_resample_at_int_index(df=df[tickers], func=None, sample_size=sample_size).diff()
-        else:
-            for key, df in data_dict.items():
-                if df is not None:
-                    data_dict[key] = qis.df_resample_at_freq(df=df[tickers], freq=freq, include_end_date=True).diff()
-        return StrategySignalData(**data_dict)
-
-    def estimate_signal_changes_joint(self,
-                                      tickers: List[str] = None,
-                                      freq: Optional[str] = None,
-                                      sample_size: Optional[int] = 21,  # can use rolling instead for freq
-                                      time_period: TimePeriod = None
-                                      ) -> Tuple[pd.DataFrame, RegModel, TimePeriod]:
-        if tickers is None:
-            tickers = self.log_returns.columns.to_list()
-        ssd = self.asdiff(tickers=tickers, sample_size=sample_size, freq=freq, time_period=time_period)
-        y_var_name = 'weight_change'
-        y = qis.melt_df_by_columns(ssd.weights.iloc[:-1, :], y_var_name=y_var_name)[y_var_name]
-        x_var_name1 = 'momentum_change'
-        x1 = qis.melt_df_by_columns(ssd.momentum.iloc[:-1, :], y_var_name=x_var_name1)[x_var_name1]
-        x_var_name2 = 'target_vol_change'
-        x2 = qis.melt_df_by_columns(ssd.instrument_target_vols.iloc[:-1, :], y_var_name=x_var_name2)[x_var_name2]
-        x_var_name3 = 'port_leverage_change'
-        x3 = qis.melt_df_by_columns(ssd.instrument_portfolio_leverages.iloc[:-1, :], y_var_name=x_var_name3)[x_var_name3]
-        if self.ra_carry is not None:
-            x_var_name0 = 'carry_change'
-            x0 = qis.melt_df_by_columns(ssd.ra_carry.iloc[:-1, :], y_var_name=x_var_name0)[x_var_name0]
-            x = pd.concat([x0, x1, x2, x3], axis=1).dropna()
-        else:
-            x = pd.concat([x1, x2, x3], axis=1).dropna()
-        x_names = x.columns.to_list()
-        y = y.reindex(index=x.index)
-
-        # keep last obs for prediction
-        fitted_model = qis.fit_ols(x=x.to_numpy(), y=y.to_numpy(), order=1, fit_intercept=False)
-        actual_change = ssd.weights.iloc[-1, :]
-        predictions = {}
-        for ticker in tickers:
-            if self.ra_carry is not None:
-                x_ts = np.array([ssd.ra_carry[ticker].iloc[-1],
-                                 ssd.momentum[ticker].iloc[-1],
-                                 ssd.instrument_target_vols[ticker].iloc[-1],
-                                 ssd.instrument_portfolio_leverages[ticker].iloc[-1]])
-            else:
-                x_ts = np.array([ssd.momentum[ticker].iloc[-1],
-                                 ssd.instrument_target_vols[ticker].iloc[-1],
-                                 ssd.instrument_portfolio_leverages[ticker].iloc[-1]])
-            pred_t = {}
-            total_pred = 0.0
-            for idx, x_t in enumerate(x_ts):
-                pred_x = fitted_model.params[idx] * x_t
-                total_pred += pred_x
-                pred_t[x_names[idx]] = pred_x
-            pred_t['predicted'] = total_pred
-            pred_t['actual'] = actual_change[ticker]
-            pred_t['residual'] = actual_change[ticker] - total_pred
-            pred_t['residual %'] = total_pred / actual_change[ticker]
-            pred_t['r2'] = fitted_model.rsquared
-            predictions[ticker] = pd.Series(pred_t)
-
-        predictions = pd.DataFrame.from_dict(predictions, orient='index')
-        prediction_period = TimePeriod(start=ssd.weights.index[-2], end=ssd.weights.index[-1])
-
-        return predictions, fitted_model, prediction_period
-
-    def estimate_signal_changes_by_groups(self,
-                                          group_data: pd.Series, group_order: List[str] = None,
-                                          freq: Optional[str] = None,
-                                          sample_size: Optional[int] = 21,  # can use rolling instead for freq
-                                          time_period: TimePeriod = None
-                                          ) -> Tuple[Dict[str, pd.DataFrame], Dict[str, RegModel], TimePeriod]:
-        """
-        estimate weight change for groups
-        """
-        group_dict = dfg.get_group_dict(group_data=group_data,
-                                        group_order=group_order,
-                                        total_column=None)
-        predictions = {}
-        fitted_models = {}
-        prediction_period = None
-        for group, tickers in group_dict.items():
-            prediction, fitted_model, prediction_period = self.estimate_signal_changes_joint(
-                tickers=tickers, freq=freq,
-                sample_size=sample_size,
-                time_period=time_period)
-            predictions[group] = prediction
-            fitted_models[group] = fitted_model
-        return predictions, fitted_models, prediction_period
-
-    def estimate_signal_changes_individual(self,
-                                           tickers: List[str] = None,
-                                           freq: Optional[str] = None,
-                                           sample_size: Optional[int] = 21,  # can use rolling instead for freq
-                                           time_period: TimePeriod = None
-                                           ) -> Tuple[pd.DataFrame, Dict[str, RegModel]]:
-        if tickers is None:
-            tickers = self.log_returns.columns.to_list()
-        ssd = self.asdiff(tickers=tickers, sample_size=sample_size, freq=freq, time_period=time_period)
-        y_var_name = 'weight_change'
-        y = ssd.weights
-        x_var_name1 = 'momentum_change'
-        x1 = ssd.momentum
-        x_var_name2 = 'target_vol_change'
-        x2 = ssd.instrument_target_vols
-        x_var_name3 = 'port_leverage_change'
-        x3 = ssd.instrument_portfolio_leverages
-        if self.ra_carry is not None:
-            x_var_name0 = 'carry_change'
-            x0 = ssd.ra_carry
-            x_names = [x_var_name0, x_var_name1, x_var_name2, x_var_name3]
-        else:
-            x_names = [x_var_name1, x_var_name2, x_var_name3]
-
-        predictions = {}
-        fitted_models = {}
-        for ticker in tickers:
-            if self.ra_carry is not None:
-                x = pd.concat([x0[ticker].rename(x_var_name0),
-                               x1[ticker].rename(x_var_name1),
-                               x2[ticker].rename(x_var_name2),
-                               x3[ticker].rename(x_var_name3)], axis=1)
-            else:
-                x = pd.concat([x1[ticker].rename(x_var_name1),
-                               x2[ticker].rename(x_var_name2),
-                               x3[ticker].rename(x_var_name3)], axis=1)
-
-            # keep last obs for prediction
-            fitted_model = qis.fit_ols(x=x.iloc[:-1, :].to_numpy(), y=y[ticker].iloc[:-1].to_numpy(), order=1, fit_intercept=False)
-            actual_change = y[ticker].iloc[-1]
-            x_ts = x.iloc[-1, :].to_numpy()
-            pred_t = {}
-            total_pred = 0.0
-            for idx, x_t in enumerate(x_ts):
-                pred_x = fitted_model.params[idx] * x_t
-                total_pred += pred_x
-                pred_t[x_names[idx]] = pred_x
-            pred_t['predicted'] = total_pred
-            pred_t['actual'] = actual_change
-            pred_t['residual'] = actual_change - total_pred
-            pred_t['residual %'] = total_pred / actual_change
-            pred_t['r2'] = fitted_model.rsquared
-            predictions[ticker] = pd.Series(pred_t)
-            fitted_models[ticker] = fitted_model
-
-        predictions = pd.DataFrame.from_dict(predictions, orient='index')
-
-        return predictions, fitted_models
+    def plot_turnover(self,
+                      regime_benchmark: str = None,
+                      is_agg: bool = False,
+                      is_grouped: bool = False,
+                      group_data: pd.Series = None,
+                      group_order: List[str] = None,
+                      time_period: TimePeriod = None,
+                      roll_period: Optional[int] = 260,
+                      add_total: bool = True,
+                      title: str = None,
+                      freq: Optional[str] = None,
+                      regime_params: BenchmarkReturnsQuantileRegimeSpecs = None,
+                      ax: plt.Subplot = None,
+                      **kwargs
+                      ) -> None:
+        turnover = self.get_turnover(is_agg=is_agg,
+                                     is_grouped=is_grouped,
+                                     group_data=group_data,
+                                     group_order=group_order,
+                                     time_period=time_period,
+                                     roll_period=roll_period,
+                                     add_total=add_total,
+                                     freq=freq,
+                                     **kwargs)
+        turnover_title = title or f"{roll_period}-period rolling {freq}-freq Turnover"
+        qis.plot_time_series(df=turnover,
+                             var_format='{:,.2%}',
+                             # y_limits=(0.0, None),
+                             legend_stats=qis.LegendStats.AVG_NONNAN_LAST,
+                             title=turnover_title,
+                             ax=ax,
+                             **kwargs)
+        if regime_benchmark is not None:
+            self.add_regime_shadows(ax=ax, regime_benchmark=regime_benchmark, index=turnover.index,
+                                    regime_params=regime_params)
 
 
 @njit

{qis-3.2.7 → qis-3.2.8}/qis/portfolio/reports/strategy_benchmark_factsheet.py

@@ -746,7 +746,7 @@ def weights_tracking_error_report_by_ac_subac(multi_portfolio_data: MultiPortfol
 
         # turnover
         fig, ax = plt.subplots(1, 1, figsize=figsize, tight_layout=True)
-        figs['turnover'] = fig
+        figs['joint_turnover'] = fig
         multi_portfolio_data.plot_turnover(ax=ax,
                                            time_period=time_period,
                                            regime_benchmark=regime_benchmark,
@@ -754,6 +754,20 @@ def weights_tracking_error_report_by_ac_subac(multi_portfolio_data: MultiPortfol
                                            #turnover_rolling_period=260,
                                            #freq_turnover=None,
                                            **kwargs)
+        # group turnover
+        fig, ax = plt.subplots(1, 1, figsize=figsize, tight_layout=True)
+        figs['group_turnover'] = fig
+        multi_portfolio_data.portfolio_datas[strategy_idx].plot_turnover(ax=ax,
+                                                                         time_period=time_period,
+                                                                         regime_benchmark=regime_benchmark,
+                                                                         regime_params=regime_params,
+                                                                         is_grouped=True,
+                                                                         group_data=turnover_groups,
+                                                                         group_order=turnover_order,
+                                                                         add_total=False,
+                                                                         #turnover_rolling_period=260,
+                                                                         #freq_turnover=None,
+                                                                         **kwargs)
 
     return figs, dfs
 

{qis-3.2.7 → qis-3.2.8}/qis/portfolio/reports/strategy_signal_factsheet.py

@@ -9,7 +9,8 @@ import seaborn as sns
 from typing import Tuple, List, Dict, Optional
 import qis as qis
 from qis import TimePeriod, BenchmarkReturnsQuantileRegimeSpecs
-from qis.portfolio.portfolio_data import PortfolioData, StrategySignalData
+from qis.portfolio.portfolio_data import PortfolioData
+from qis.portfolio.signal_data import StrategySignalData
 
 
 def generate_weight_change_report(portfolio_data: PortfolioData,

qis-3.2.8/qis/portfolio/signal_data.py

@@ -0,0 +1,238 @@
+"""
+signal data outpout for portfolio data reporting
+"""
+from __future__ import annotations
+import numpy as np
+import pandas as pd
+from statsmodels.regression.linear_model import RegressionResults as RegModel
+from dataclasses import dataclass, asdict
+from typing import Dict, List, Optional, Tuple
+from qis.utils.dates import TimePeriod
+from qis.utils.df_str import date_to_str
+from qis.utils.df_groups import get_group_dict
+from qis.utils.df_melt import melt_df_by_columns
+from qis.utils.ols import fit_ols
+from qis.utils.df_freq import df_resample_at_int_index, df_resample_at_freq
+
+
+@dataclass
+class StrategySignalData:
+    """
+    data class instance applied for output of strategy backtest data
+    """
+    log_returns: pd.DataFrame = None
+    ra_carry: pd.DataFrame = None  # risk-adjusted carry
+    momentum: pd.DataFrame = None
+    signal: pd.DataFrame = None  # signal output
+    instrument_vols: pd.DataFrame = None  # instrument vols
+    instrument_target_vols: pd.DataFrame = None  # target vols for portfolio allocation
+    instrument_target_signal_vol_weights: pd.DataFrame = None  # target vols * signal
+    instrument_portfolio_leverages: pd.DataFrame = None  # = portfolio weight / instrument_target_signal_vol_weights
+    weights: pd.DataFrame = None  # final weights
+    kwargs: Dict[str, pd.DataFrame] = None  # any other outputs
+
+    def locate_period(self, time_period: TimePeriod) -> StrategySignalData:
+        # nb: does not work for returns
+        data_dict = asdict(self)
+        for key, df in data_dict.items():
+            if df is not None:
+                data_dict[key] = time_period.locate(df)
+        return StrategySignalData(**data_dict)
+
+    def rename_data(self, names_map: Dict[str, str]) -> StrategySignalData:
+        data_dict = asdict(self)
+        for key, df in data_dict.items():
+            if df is not None:
+                data_dict[key] = df.rename(names_map, axis=1)
+        return StrategySignalData(**data_dict)
+
+    def get_current_signal_by_groups(self, group_data: pd.Series,
+                                     group_order: List[str] = None
+                                     ) -> Dict[str, pd.DataFrame]:
+        group_dict = get_group_dict(group_data=group_data,
+                                        group_order=group_order,
+                                        total_column=None)
+        group_signals = {}
+        agg_by_group = {}
+        last_date = date_to_str(self.signal.index[-21])
+        current_date = date_to_str(self.signal.index[-1])
+        last_signals = self.signal.iloc[-21, :]
+        current_signals = self.signal.iloc[-1, :]
+        for group, tickers in group_dict.items():
+            last_signals_ = last_signals[tickers]
+            current_signals_ = current_signals[tickers]
+            group_signals[group] = pd.concat([last_signals_.rename(last_date),
+                                              current_signals_.rename(current_date)
+                                              ], axis=1)
+
+            agg_by_group[group] = pd.Series({last_date: np.nanmean(last_signals_),
+                                             current_date: np.nanmean(current_signals_)})
+        agg_by_group = {'Total by groups': pd.DataFrame.from_dict(agg_by_group, orient='index')}
+        agg_by_group.update(group_signals)
+        return agg_by_group
+
+    def asdiff(self, tickers: List[str] = None,
+               freq: str = None,
+               sample_size: Optional[int] = 21,  # can use rolling instead for freq
+               time_period: TimePeriod = None
+               ) -> StrategySignalData:
+
+        if tickers is None:
+            tickers = self.log_returns.columns.to_list()
+        # nb: does not work for returns
+        if time_period is not None:
+            ssd = self.locate_period(time_period=time_period)
+        else:
+            ssd = self
+
+        data_dict = asdict(ssd)
+        if sample_size is not None:
+            for key, df in data_dict.items():
+                if df is not None:
+                    data_dict[key] = df_resample_at_int_index(df=df[tickers], func=None, sample_size=sample_size).diff()
+        else:
+            for key, df in data_dict.items():
+                if df is not None:
+                    data_dict[key] = df_resample_at_freq(df=df[tickers], freq=freq, include_end_date=True).diff()
+        return StrategySignalData(**data_dict)
+
+    def estimate_signal_changes_joint(self,
+                                      tickers: List[str] = None,
+                                      freq: Optional[str] = None,
+                                      sample_size: Optional[int] = 21,  # can use rolling instead for freq
+                                      time_period: TimePeriod = None
+                                      ) -> Tuple[pd.DataFrame, RegModel, TimePeriod]:
+        if tickers is None:
+            tickers = self.log_returns.columns.to_list()
+        ssd = self.asdiff(tickers=tickers, sample_size=sample_size, freq=freq, time_period=time_period)
+        y_var_name = 'weight_change'
+        y = melt_df_by_columns(ssd.weights.iloc[:-1, :], y_var_name=y_var_name)[y_var_name]
+        x_var_name1 = 'momentum_change'
+        x1 = melt_df_by_columns(ssd.momentum.iloc[:-1, :], y_var_name=x_var_name1)[x_var_name1]
+        x_var_name2 = 'target_vol_change'
+        x2 = melt_df_by_columns(ssd.instrument_target_vols.iloc[:-1, :], y_var_name=x_var_name2)[x_var_name2]
+        x_var_name3 = 'port_leverage_change'
+        x3 = melt_df_by_columns(ssd.instrument_portfolio_leverages.iloc[:-1, :], y_var_name=x_var_name3)[x_var_name3]
+        if self.ra_carry is not None:
+            x_var_name0 = 'carry_change'
+            x0 = melt_df_by_columns(ssd.ra_carry.iloc[:-1, :], y_var_name=x_var_name0)[x_var_name0]
+            x = pd.concat([x0, x1, x2, x3], axis=1).dropna()
+        else:
+            x = pd.concat([x1, x2, x3], axis=1).dropna()
+        x_names = x.columns.to_list()
+        y = y.reindex(index=x.index)
+
+        # keep last obs for prediction
+        fitted_model = fit_ols(x=x.to_numpy(), y=y.to_numpy(), order=1, fit_intercept=False)
+        actual_change = ssd.weights.iloc[-1, :]
+        predictions = {}
+        for ticker in tickers:
+            if self.ra_carry is not None:
+                x_ts = np.array([ssd.ra_carry[ticker].iloc[-1],
+                                 ssd.momentum[ticker].iloc[-1],
+                                 ssd.instrument_target_vols[ticker].iloc[-1],
+                                 ssd.instrument_portfolio_leverages[ticker].iloc[-1]])
+            else:
+                x_ts = np.array([ssd.momentum[ticker].iloc[-1],
+                                 ssd.instrument_target_vols[ticker].iloc[-1],
+                                 ssd.instrument_portfolio_leverages[ticker].iloc[-1]])
+            pred_t = {}
+            total_pred = 0.0
+            for idx, x_t in enumerate(x_ts):
+                pred_x = fitted_model.params[idx] * x_t
+                total_pred += pred_x
+                pred_t[x_names[idx]] = pred_x
+            pred_t['predicted'] = total_pred
+            pred_t['actual'] = actual_change[ticker]
+            pred_t['residual'] = actual_change[ticker] - total_pred
+            pred_t['residual %'] = total_pred / actual_change[ticker]
+            pred_t['r2'] = fitted_model.rsquared
+            predictions[ticker] = pd.Series(pred_t)
+
+        predictions = pd.DataFrame.from_dict(predictions, orient='index')
+        prediction_period = TimePeriod(start=ssd.weights.index[-2], end=ssd.weights.index[-1])
+
+        return predictions, fitted_model, prediction_period
+
+    def estimate_signal_changes_by_groups(self,
+                                          group_data: pd.Series, group_order: List[str] = None,
+                                          freq: Optional[str] = None,
+                                          sample_size: Optional[int] = 21,  # can use rolling instead for freq
+                                          time_period: TimePeriod = None
+                                          ) -> Tuple[Dict[str, pd.DataFrame], Dict[str, RegModel], TimePeriod]:
+        """
+        estimate weight change for groups
+        """
+        group_dict = get_group_dict(group_data=group_data,
+                                    group_order=group_order,
+                                    total_column=None)
+        predictions = {}
+        fitted_models = {}
+        prediction_period = None
+        for group, tickers in group_dict.items():
+            prediction, fitted_model, prediction_period = self.estimate_signal_changes_joint(
+                tickers=tickers, freq=freq,
+                sample_size=sample_size,
+                time_period=time_period)
+            predictions[group] = prediction
+            fitted_models[group] = fitted_model
+        return predictions, fitted_models, prediction_period
+
+    def estimate_signal_changes_individual(self,
+                                           tickers: List[str] = None,
+                                           freq: Optional[str] = None,
+                                           sample_size: Optional[int] = 21,  # can use rolling instead for freq
+                                           time_period: TimePeriod = None
+                                           ) -> Tuple[pd.DataFrame, Dict[str, RegModel]]:
+        if tickers is None:
+            tickers = self.log_returns.columns.to_list()
+        ssd = self.asdiff(tickers=tickers, sample_size=sample_size, freq=freq, time_period=time_period)
+        y_var_name = 'weight_change'
+        y = ssd.weights
+        x_var_name1 = 'momentum_change'
+        x1 = ssd.momentum
+        x_var_name2 = 'target_vol_change'
+        x2 = ssd.instrument_target_vols
+        x_var_name3 = 'port_leverage_change'
+        x3 = ssd.instrument_portfolio_leverages
+        if self.ra_carry is not None:
+            x_var_name0 = 'carry_change'
+            x0 = ssd.ra_carry
+            x_names = [x_var_name0, x_var_name1, x_var_name2, x_var_name3]
+        else:
+            x_names = [x_var_name1, x_var_name2, x_var_name3]
+
+        predictions = {}
+        fitted_models = {}
+        for ticker in tickers:
+            if self.ra_carry is not None:
+                x = pd.concat([x0[ticker].rename(x_var_name0),
+                               x1[ticker].rename(x_var_name1),
+                               x2[ticker].rename(x_var_name2),
+                               x3[ticker].rename(x_var_name3)], axis=1)
+            else:
+                x = pd.concat([x1[ticker].rename(x_var_name1),
+                               x2[ticker].rename(x_var_name2),
+                               x3[ticker].rename(x_var_name3)], axis=1)
+
+            # keep last obs for prediction
+            fitted_model = fit_ols(x=x.iloc[:-1, :].to_numpy(), y=y[ticker].iloc[:-1].to_numpy(), order=1, fit_intercept=False)
+            actual_change = y[ticker].iloc[-1]
+            x_ts = x.iloc[-1, :].to_numpy()
+            pred_t = {}
+            total_pred = 0.0
+            for idx, x_t in enumerate(x_ts):
+                pred_x = fitted_model.params[idx] * x_t
+                total_pred += pred_x
+                pred_t[x_names[idx]] = pred_x
+            pred_t['predicted'] = total_pred
+            pred_t['actual'] = actual_change
+            pred_t['residual'] = actual_change - total_pred
+            pred_t['residual %'] = total_pred / actual_change
+            pred_t['r2'] = fitted_model.rsquared
+            predictions[ticker] = pd.Series(pred_t)
+            fitted_models[ticker] = fitted_model
+
+        predictions = pd.DataFrame.from_dict(predictions, orient='index')
+
+        return predictions, fitted_models

{qis-3.2.7 → qis-3.2.8}/qis/settings.yaml

@@ -18,4 +18,3 @@ OUTPUT_PATH:
 
 AWS_POSTGRES:
   ""
-