Empyrical Module for Risk and Performance Metrics

Place the attached Empyrical.dos file in the [home]/modules directory. The [home] directory is set by the system configuration parameter home, which can be viewed using the getHomeDir() function.

For details on module usage, see Tutorial > Modules.

Call the sharpeRatio function on a vector:

use Empyrical
ret = 0.072 0.0697 0.08 0.74 1.49 0.9 0.26 0.9 0.35 0.63
x = sharpeRatio(ret);

To perform grouped calculations, we can call the function in the SQL statement.

For example, the table t contains data for 2 stocks:

close = 7.2 6.97 7.08 6.74 6.49 5.9 6.26 5.9 5.35 5.63 3.81 3.935 4.04 3.74 3.7 3.33 3.64 3.31 2.69 2.72
date = (2023.03.02 + 0..4 join 7..11).take(20)
symbol = take(`F,10) join take(`GPRO,10)
t = table(symbol, date, close)

Calculate the return for each stock:

update t set ret = simpleReturns(close) context by symbol

Functions such as alphaBeta return multiple columns of results. For example:

use Empyrical

ret = 0.072 0.0697 0.08 0.74 1.49 0.9 0.26 0.9 0.35 0.63
factorret = 0.702 0.97 0.708 1.74 0.49 0.09 1.26 0.59 1.35 0.063
alpha, beta = alphaBeta(ret, factorret);

Use in a SQL statement:

use Empyrical

ret = 0.072 0.0697 0.08 0.74 1.49 0.9 0.26 0.9 0.35 0.63 0.702 0.97 0.708 1.74 0.49 0.09 1.26 0.59 1.35 0.063 
factorret = 0.702 0.97 0.708 1.74 0.49 0.09 1.26 0.59 1.35 0.063 0.072 0.0697 0.08 0.74 1.49 0.9 0.26 0.9 0.35 0.63
symbol = take(`F,10) join take(`GPRO,10)
date = (2022.03.02 + 0..4 join 7..11).take(20)
t = table(symbol as sym, date as dt, ret, factorret) 
select sym,alphaBeta(ret, factorret) as `alpha`beta from t context by sym

/*
sym  alpha                beta              
---- -------------------- ------------------
F    2.936093190579921E62 -0.276883617899559
F    2.936093190579921E62 -0.276883617899559
...   
*/

use Empyrical

ret= 0.072 0.0697 0.08 0.74 1.49 0.9 0.26 0.9 0.35 0.63
ret = take(ret, 10000000)
timer x = rollSharpeRatio(ret, windows =10)

Applying the rollSharpeRatio function from the Empyrical module directly on a vector of length 10,000,000 took 300.135 ms.

The corresponding Python code is as follows:

import numpy as np
import empyrical as em
import time
ret = np.array([0.072, 0.0697, 0.08, 0.74, 1.49, 0.9, 0.26, 0.9, 0.35, 0.63])
ret = np.tile(ret,10000000)
start_time = time.time()
x = em.roll_sharpe_ratio(ret, 10)
print("--- %s seconds ---" % (time.time() - start_time))

The roll_sharpe_ratio function from the Python Empyrical library took 25,965.46 ms, which is 86 times longer than the rollSharpeRatio function in the DolphinDB Empyrical module.

The performance test data consists of daily return data for all stocks in market from January 3, 2019, to July 1, 2022, along with simulated factor data and portfolio weights (for testing computeExposure and perfAttrib functions), totaling 3,452,106 records. Sample data from the test files are provided in the appendix. After extraction, place them under the [home] directory.

The computation logic involves grouping by stock code to calculate each metric. To evaluate the function performance, both the DolphinDB and Python test codes are executed in single-threaded mode.

The test result is as shown in the table:

The test results show that the function performance of the DolphinDB Empyrical module surpasses that of the Python Empyrical library in most cases, with the maximum performance gap reaching 70 times, and an average gap of around 9 times.

Python pandas test code:

grouped = returns.groupby('SecurityID')
cum_returns = grouped['ret'].apply(lambda x: em.cum_returns(x))

DolphinDB test code:

cumReturns = 
    select SecurityID, DateTime, cumReturns(ret) as cumReturns
    from returns
    context by SecurityID

If the input vector in Python Empyrical contains null values, the nulls are passed into the function and included in the calculation. The Empyrical module adopts the same strategy. The results produced by DolphinDB Empyrical are closely aligned with those of the Python Empyrical library, with only minor differences due to floating-point precision.

Note: While DolphinDB retains null values at the first (k–1) positions for strict window alignment, the Python Empyrical library skips initial nan values and begins computation as soon as a valid window is available.

DolphinDB Example

ret = NULL NULL 0.08 0.74 1.49 0.9 0.26 0.9 0.35 0.63 0.702 0.97 0.708 1.74
0.49 0.09 1.26 0.59 1.35 0.063 
rollAnnualVolatility(ret, windows =10)

/*
[,,,,,,,,,7.107626186006128,6.650903096572676,6.445987651244765,5.4412961691126505,
7.3080574710383885,6.603612950499143,7.349681897878303,7.448075187590415,
7.475411961892134,7.649430305584855,8.584637604465316]
*/

Python Example

ret = np.array([np.nan, np.nan, 0.08, 0.74, 1.49, 0.9, 0.26,
0.9, 0.35, 0.63, 0.702, 0.97, 0.708, 1.74, 0.49, 0.09, 1.26, 0.59, 1.35, 0.063])
print(em.roll_annual_volatility(ret,10))

/*
[7.10762619 6.6509031  6.44598765 5.44129617 7.30805747 6.60361295
 7.3496819  7.44807519 7.47541196 7.64943031 8.5846376 ]
 */

The following functions generate different results from Python: alphaBeta, upAlphaBeta, downAlphaBeta, gpdRiskEstimates.

In Python Empyrical, the results of alphaBeta, upAlphaBeta, and downAlphaBeta combine alpha and beta into a two-dimensional array, requiring further post-processing.

In DolphinDB, alpha and beta can be directly separated into two columns using SQL query statements.

select SecurityID, alphaBeta(ret, factorRet) as `alpha`beta
from return1
group by SecurityID

While for the function gpdRiskEstimates, all the estimates are output in one column in Python:

In DolphinDB, the estimates are displayed in separate columns: