Is there a way to run Alphalens using my own custom input matrix of returns (ie. custom factor adjusted) rather than inputting Prices (ie. the "pricing" table in the examples) for each period?

I have been thinking about the nice "Alpha decomposition" #180 feature. The information it provides is actually a small part of what already available in pyfolio and the Quantopian's new Risk Model. On one side we cannot replicate all the information provided by those two tools but on the other side it would be great to have all that analysis without having to build an algorithm and run a backtest, something that could be integrated into Alphalens.

Then, why don't we create a function in Alphalens that builds the input required by pyfolio and the Quantopian's new Risk Model? Alphalens already simulates the cumulative returns of a portfolio weighted by factor values, so we only need to format those information in a way that is compatible with the other two tools. That would be a pure theoretical analysis, but except for commissions and slippage the results would be realistic and it also would serve as benchmark for the algorithm (users can compare the algorithm results, after setting commission and slippage to 0, with these theoretical results and check if they implemented the algorithm correctly).

I haven't looked at pyfolio in details so I don't know the details of the input, but if @twiecki can help me with those details I can work on this feature and the same for Quantopian's new Risk Mode (I don't know if that is part of pyfolio or a separate project).

'performance.create_pyfolio_input' now computes positions too. Also it is now possible to select the 'period' to be used in benchmark computation and for factor returns/positions is now possible to select equal weighing instead of factor weighing.

Here is where I'm headed with the new api thoughts from https://github.com/quantopian/alphalens/pull/110 so to review creating a tear sheet would be a two step process.

1. format the data
2. call for the tear sheet

where all of the tear sheets take a factor_data dataframe that looks something like

Right now the main blocking issue is the event-study-esque plots as that function requires raw prices. I think that the number of plots and the uniqueness of what they are saying probably merits them getting a separate tear sheet (which would be able to take raw prices).

For issue #253 refactor compute_forward_returns add get_clean_factor API refactor get_clean_factor_and_forward_returns as compose of compute_forward_returns and get_clean_factor

This breaks down the full tear sheet into multiple smaller ones covering: returns, information, and turnover analysis.

This PR is aimed mainly at issue #106 so Thomas your thoughts would be great!

This is a first start so things are pretty rough, and it definitely won't pass tests but I think there will be a lot of discussion so I'm not too worried.

This begins the development of the "factors_interaction_tearsheet" from issue #219. The goal of this pull request is to get feedback on whether this branch seems to be going in the right direction.

Description of Changes

1. Create join_factor_with_factor_and_forward_returns function
   • Creates a function complimentary to get_clean_factor_and_forward_returns that joins an additional factor to the factor_data dataframe returned by get_clean_factor_and_forward_returns.
   • This new dataframe returned, call it "multi_factor_data", will be the core source/data structure providing the necessary data for the factors_interaction_tearsheet computations.
2. Create an associated test module.
3. Modify perf.mean_return_by_quantile to take an additional parameter so that it can group by multiple factor quantiles.
4. Add first plotting function, plot_multi_factor_quantile_returns, to create an annotated heatmap of mean returns by two-factor quantile bins.
5. Create the tears.create_factors_interaction_tear_sheet as the entry point to the multi-factor tearsheet.

Requesting Feedback

1. Comments and suggestions on the utils.join_factor_with_factor_and_forward_returns function
   1. Should there be a wrapper that builds the multi_factor_data dataframe in one step. (i.e. wrap this function with get_clean_factor_and_forward_returns?
2. I'm not too familiar with creating effective unit tests, so any feedback on this module is appreciated.
3. In regards to Change 3 above:
   1. My first thought, following suggestion of @luca-s, was to create a separate performance module which would contain all functions for this sort of computation.
   2. Since the existing performance module already contains a lot of the needed functionality, I thought maybe I would create a wrapper function in this new module that added the necessary functionality.
   3. However, in perf.mean_return_by_quantile, I needed to add a parameter to this function to make it work in a clean manner. Not sure how I could have done that with a wrapper.
   4. So I guess my question is, what are the community's thoughts on how I dealt with this particular issue, and also what are thoughts on related considerations going forward?
4. Any other comments/guidance on path of development going forward is greatly appreciated.
5. Also, let me know if there are too many changes in this pull request for efficient/easy review.

I am working on a sector neutral factor and I discovered that Alphalens analysis on a group neutral factor is currently limited. With group neutral factor I mean a factor intended to rank stocks across the same group, so that it makes sense to compare performance of top vs bottom stocks in the same group but it doesn't make sense to compare performance of a stock in one group with performance of another group.

The main shortcoming is the return analysis: as there is no way to demean the returns by group, the statistics shown are of little use. Also when the plots are broken down by group, the results are not useful either as there are 2 bugs:

• API documentation claims that perf.mean_return_by_quantile was performing is performing the demeaning at group level when splitting the plots by group, but even in that case it is not true
• The same goes for perf.mean_information_coefficient

Also changed the API arguments names in a consistent way:

• the tears.* functions use 'long_short' and 'group_neutral' all around, as those functions are intended to be the top level ones. 'by_group' is used if the function support multiple plots output, one for each group
• the remaining API (mostry performance.*) use 'demeaned' and 'group_adjust' as they used to be

Issue #225

Added performance.create_pyfolio_input, which create input suitable for pyfolio. Intended use:

factor_data = alphales.utils.get_clean_factor_and_forward_returns(factor, prices)

pf_returns = alphales.performance.create_pyfolio_input(factor_data,'1D',
                     long_short=True,
                     group_neutral=False,
                     quantiles=None,
                     groups=None)

pyfolio.tears.create_returns_tear_sheet(pf_returns)

Also, I greatly improved the function that computes the cumulative returns as that is the base on which the pyfolio integration feature is built on. Mainly I removed the legacy assumptions which required the factor to be computed at specific frequency (daily, weekly etc) and also the periods had to be multiple of this frequency (2 days, 4 days etc). The function is now able to properly compute returns when there are gaps in the factor data or when we analyze an intraday factor.

Compute mean return by date. If by_date flag is false, then compute and return the average of the daily mean returns (and also the standard error of these daily mean returns).

Resolves: Issue #309

alphalens is awesome! I have been used alphalens to filter several effective factors from many factors in stock market for some time. However, by the previous step I just got several effective factors independently. In practice, the more common scenario is to generate a multi-factor linear model and regression the multi-factor model (for example Fama-French 3-factor model) other than single-factor models and do hypothesis testing in this multi-factor model. Will this multi-factor model be considered into adding up to alphalens in the future?

When invoke the function alphalens.tears.create_turnover_tear_sheetalphalens.tears.create_turnover_tear_sheet() without allocating the param turnover_period, may cause the AttributeError: 'Index' object has no attribute 'get_values'.It is because the utils.get_forward_returns_columns() returns columns as an object of Index instead of pd.Series.Hence, Index object hasn't have function get_values().

Problem Description

I've tried importing alphalens but encountered the issue of "No module named 'pandas.util._decorators'" right the first command of "import alphalens" Please provide a minimal, self-contained, and reproducible example:

import alphalens

Please provide the full traceback:

ModuleNotFoundError                       Traceback (most recent call last)
<ipython-input-21-6e4fa055c088> in <module>
----> 1 import alphalens

e:\temp\Python36\lib\site-packages\alphalens\__init__.py in <module>
----> 1 from . import performance
      2 from . import plotting
      3 from . import tears
      4 from . import utils
      5 

e:\temp\Python36\lib\site-packages\alphalens\performance.py in <module>
     20 from pandas.tseries.offsets import BDay
     21 from scipy import stats
---> 22 from statsmodels.regression.linear_model import OLS
     23 from statsmodels.tools.tools import add_constant
     24 from . import utils

e:\temp\Python36\lib\site-packages\statsmodels\regression\__init__.py in <module>
----> 1 from .linear_model import yule_walker
      2 
      3 from statsmodels.tools._testing import PytestTester
      4 
      5 __all__ = ['yule_walker', 'test']

e:\temp\Python36\lib\site-packages\statsmodels\regression\linear_model.py in <module>
     34 
     35 from statsmodels.compat.python import lrange, lzip
---> 36 from statsmodels.compat.pandas import Appender
     37 
     38 import numpy as np

e:\temp\Python36\lib\site-packages\statsmodels\compat\__init__.py in <module>
----> 1 from statsmodels.tools._testing import PytestTester
      2 
      3 from .python import (
      4     PY37,
      5     asunicode, asbytes, asstr,

e:\temp\Python36\lib\site-packages\statsmodels\tools\__init__.py in <module>
      1 from .tools import add_constant, categorical
----> 2 from statsmodels.tools._testing import PytestTester
      3 
      4 __all__ = ['test', 'add_constant', 'categorical']
      5 

e:\temp\Python36\lib\site-packages\statsmodels\tools\_testing.py in <module>
      9 
     10 """
---> 11 from statsmodels.compat.pandas import assert_equal
     12 
     13 import os

e:\temp\Python36\lib\site-packages\statsmodels\compat\pandas.py in <module>
      3 import numpy as np
      4 import pandas as pd
----> 5 from pandas.util._decorators import deprecate_kwarg, Appender, Substitution
      6 
      7 __all__ = ['assert_frame_equal', 'assert_index_equal', 'assert_series_equal',

ModuleNotFoundError: No module named 'pandas.util._decorators'

Please provide any additional information below: I'm using VScode Win10. I tried updating pip, pandas, np, alphalens to newer versions, still no hope. Please give me a hand on that, thanks in advance

Versions

• Alphalens version: 0.3.6
• Python version: 3.6.8
• Pandas version: 0.18.1
• Matplotlib version: 3.3.4
• Numpy: 1.17.0
• Scipy: 1.0.0
• Statsmodels: 0.12.2
• Zipline: 1.2.0

I am getting the MissingDataError: exog contains inf or nans when I am trying to get the returns tearsheet. The input data from get_clean_factor_and_forward_returns does not have any nans or infs in it. I saw mentions of this error on the Quantopian forum (https://quantopian-archive.netlify.app/forum/threads/alphalens-giving-exog-contains-inf-or-nans.html) and a couple of other places, but no solution. Any thoughts? Thank you!

Problem Description

UnboundLocalError: local variable 'period_len' referenced before assignment, line 319

days_diffs = []
        for i in range(30):
            if i >= len(forward_returns.index):
                break
            p_idx = prices.index.get_loc(forward_returns.index[i])
            if p_idx is None or p_idx < 0 or (
                    p_idx + period) >= len(prices.index):
                continue
            start = prices.index[p_idx]
            end = prices.index[p_idx + period]
            period_len = diff_custom_calendar_timedeltas(start, end, freq)
            days_diffs.append(period_len.components.days)

        delta_days = period_len.components.days - mode(days_diffs).mode[0]
        period_len -= pd.Timedelta(days=delta_days)
        label = timedelta_to_string(period_len)

Please provide the full traceback:

[Paste traceback here]

Please provide any additional information below:

Versions

• Alphalens version:
• Python version: 3.7
• Pandas version:
• Matplotlib version:

Problem Description

When I use the alphalens.tears.create_event_returns_tear_sheet, it shows one error: unsupported operand type(s) for -: 'slice' and 'int', besides other functions work well. Looking forwards someone could help me. Thank you.

Please provide a minimal, self-contained, and reproducible example:

[Paste code here]
**alphalens.tears.create_event_returns_tear_sheet(data,
                                                returns,
                                                avgretplot=(5, 15),
                                                long_short=True,
                                                group_neutral=False,
                                                std_bar=True,
                                                by_group=False)**



**Please provide the full traceback:**
```python
[Paste traceback here]
```---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
D:\Anaconda\lib\site-packages\pandas\core\groupby\groupby.py in apply(self, func, *args, **kwargs)
    734             try:
--> 735                 result = self._python_apply_general(f)
    736             except TypeError:

D:\Anaconda\lib\site-packages\pandas\core\groupby\groupby.py in _python_apply_general(self, f)
    750     def _python_apply_general(self, f):
--> 751         keys, values, mutated = self.grouper.apply(f, self._selected_obj, self.axis)
    752 

D:\Anaconda\lib\site-packages\pandas\core\groupby\ops.py in apply(self, f, data, axis)
    205             group_axes = group.axes
--> 206             res = f(group)
    207             if not _is_indexed_like(res, group_axes):

D:\Anaconda\lib\site-packages\pandas\core\groupby\groupby.py in f(g)
    718                     with np.errstate(all="ignore"):
--> 719                         return func(g, *args, **kwargs)
    720 

D:\Anaconda\lib\site-packages\alphalens\performance.py in average_cumulative_return(q_fact, demean_by)
    802     def average_cumulative_return(q_fact, demean_by):
--> 803         q_returns = cumulative_return_around_event(q_fact, demean_by)
    804         q_returns.replace([np.inf, -np.inf], np.nan, inplace=True)

D:\Anaconda\lib\site-packages\alphalens\performance.py in cumulative_return_around_event(q_fact, demean_by)
    798             mean_by_date=True,
--> 799             demean_by=demean_by,
    800         )

D:\Anaconda\lib\site-packages\alphalens\performance.py in common_start_returns(factor, returns, before, after, cumulative, mean_by_date, demean_by)
    701 
--> 702         starting_index = max(day_zero_index - before, 0)
    703         ending_index = min(day_zero_index + after + 1,

TypeError: unsupported operand type(s) for -: 'slice' and 'int'

During handling of the above exception, another exception occurred:

TypeError                                 Traceback (most recent call last)
<ipython-input-46-6fc348201897> in <module>
      5                                                 group_neutral=False,
      6                                                 std_bar=True,
----> 7                                                 by_group=False)

D:\Anaconda\lib\site-packages\alphalens\plotting.py in call_w_context(*args, **kwargs)
     43             with plotting_context(), axes_style(), color_palette:
     44                 sns.despine(left=True)
---> 45                 return func(*args, **kwargs)
     46         else:
     47             return func(*args, **kwargs)

D:\Anaconda\lib\site-packages\alphalens\tears.py in create_event_returns_tear_sheet(factor_data, returns, avgretplot, long_short, group_neutral, std_bar, by_group)
    573         periods_after=after,
    574         demeaned=long_short,
--> 575         group_adjust=group_neutral,
    576     )
    577 

D:\Anaconda\lib\site-packages\alphalens\performance.py in average_cumulative_return_by_quantile(factor_data, returns, periods_before, periods_after, demeaned, group_adjust, by_group)
    858         elif demeaned:
    859             fq = factor_data['factor_quantile']
--> 860             return fq.groupby(fq).apply(average_cumulative_return, fq)
    861         else:
    862             fq = factor_data['factor_quantile']

D:\Anaconda\lib\site-packages\pandas\core\groupby\generic.py in apply(self, func, *args, **kwargs)
    222     )
    223     def apply(self, func, *args, **kwargs):
--> 224         return super().apply(func, *args, **kwargs)
    225 
    226     @Substitution(

D:\Anaconda\lib\site-packages\pandas\core\groupby\groupby.py in apply(self, func, *args, **kwargs)
    744 
    745                 with _group_selection_context(self):
--> 746                     return self._python_apply_general(f)
    747 
    748         return result

D:\Anaconda\lib\site-packages\pandas\core\groupby\groupby.py in _python_apply_general(self, f)
    749 
    750     def _python_apply_general(self, f):
--> 751         keys, values, mutated = self.grouper.apply(f, self._selected_obj, self.axis)
    752 
    753         return self._wrap_applied_output(

D:\Anaconda\lib\site-packages\pandas\core\groupby\ops.py in apply(self, f, data, axis)
    204             # group might be modified
    205             group_axes = group.axes
--> 206             res = f(group)
    207             if not _is_indexed_like(res, group_axes):
    208                 mutated = True

D:\Anaconda\lib\site-packages\pandas\core\groupby\groupby.py in f(g)
    717                 def f(g):
    718                     with np.errstate(all="ignore"):
--> 719                         return func(g, *args, **kwargs)
    720 
    721             elif hasattr(nanops, "nan" + func):

D:\Anaconda\lib\site-packages\alphalens\performance.py in average_cumulative_return(q_fact, demean_by)
    801 
    802     def average_cumulative_return(q_fact, demean_by):
--> 803         q_returns = cumulative_return_around_event(q_fact, demean_by)
    804         q_returns.replace([np.inf, -np.inf], np.nan, inplace=True)
    805 

D:\Anaconda\lib\site-packages\alphalens\performance.py in cumulative_return_around_event(q_fact, demean_by)
    797             cumulative=True,
    798             mean_by_date=True,
--> 799             demean_by=demean_by,
    800         )
    801 

D:\Anaconda\lib\site-packages\alphalens\performance.py in common_start_returns(factor, returns, before, after, cumulative, mean_by_date, demean_by)
    700             continue
    701 
--> 702         starting_index = max(day_zero_index - before, 0)
    703         ending_index = min(day_zero_index + after + 1,
    704                            len(returns.index))

TypeError: unsupported operand type(s) for -: 'slice' and 'int'

<Figure size 432x288 with 0 Axes>
​

**Please provide any additional information below:**


## Versions

* Alphalens version: 0.4.0
* Python version: 3.7.6
* Pandas version: 1.0.1
* Matplotlib version: 3.1.3