Implementing a Multi-Factor Risk Model in DolphinDB

The MAD method uses the median. Compared with the traditional mean-standard deviation method, it is robust and not affected by extreme outliers. It is an improvement over the approach that subtracts the mean and uses the standard deviation. The advantage of the MAD method over other outlier detection methods is its strong robustness to outliers. The function corresponding to the MAD method in this article is winsorized.

/* winsorized
Winsorize the factor table.
The factor table must contain three columns: record date, stock code, and raw factor, with the raw factor as the third column.
Input:
         tbName
Output:  
         factor table after winsorized 
*/

The MAD method is implemented as follows:

1. Calculate the median of the dataset as the measure of central tendency.

2. For each data point, calculate its absolute deviation from the median.

3. Calculate the median of all absolute deviations, i.e., the median absolute deviation (MAD).

   MAD = median(|X_i -median(X)| )

4. Determine the threshold for identifying outliers. Typically, a data point is considered an outlier if its deviation from the median exceeds a specified multiple of the MAD, such as 3 times the MAD.

   $\sigma =\frac{1}{{\Phi }^{-1}\left(\frac{3}{4}\right)}\times \mathrm{MAD}\approx 1.4826\times \mathrm{MAD}$

5. Identify outliers. Data points exceeding the threshold can be marked as outliers or subjected to further analysis.

   $\mathrm{median}\left(X\right)\pm 3\sigma$

Market-cap-weighted standardization is intended to remove the impact of extreme market capitalization on factor calculation contributions (CNLT). This method brings the factor scales to a comparable level. For the n-th stock and its k-th raw factor exposure $x_{n,k}^{\mathrm{Raw}}$ , the standardization process is $x_{n,k}=\frac{{x_{n,k}}^{\text{Raw}}-{\mu }_k}{{\sigma }_k}$ ,

where μ_k and σ_k are, respectively, the market-cap-weighted mean and the equal-weighted standard deviation of factor k.

The standardized function implements market-cap-weighted standardization. Set adjusted=true to apply market-cap neutralization.

/* standardized
Standardize and market-neutralize the factor table.
The factor table must contain three columns: record date, stock code, and raw factor, with the raw factor as the third column.
Input:
         tbName
         adjusted    Market-neutralize or not
Output:  
         factor table after standardized
*/

The two functions winsorized and standardized are integrated into the getAllFactors function. getAllFactors performs standardization and outlier removal through the parameters normlizing and scaling, respectively. In addition, after obtaining the industry and style factors, the getAllFactors function returns a wide table that combines all the above factors and can be further used for single-factor effectiveness testing.

/* getAllFactors
Get all factors.
Input:   normlizing: true (Default) Standardization
         scaling: true (Default) Outlier removal
         decap: true (Default) Market-neutralization
         industry_weighted: true (Default) Industry market-cap weighting
         industry_method: 'CITIC' (Default), 'SW_2021'
         startTime: 2022.01.03 (Default)
         endTime: 2023.01.02 (Default)
Output:
         factor table
*/

Factors = getAllFactors(st=st,et =et, normlizing = true,
                        scaling = true,decap = false,industry_method = 'CITIC',
                        industry_weighted = false)
select * from Factors limit 100

Before building the factor regression model, missing factor values must be further processed to avoid their impact on the regression results. In this article, the function for handling missing values of all raw factors is getRegTable, and mean imputation is used to fill missing values.

/* getRegTable
Get a processed regression factor table for regression, including stock returns, factor exposures, industry factors, industry variables, and regression weights.
Input:
         factorsTable: false (Default) Whether to use the provided initial factor table
         tbName: NULL (Default) Initial factor table
         normlizing: true (Default) Standardization
         scaling: true (Default) Outlier removal
         decap: true (Default) Market-neutralization for regression
         industry_weighted: true (Default) Industry factor weighting
         industry_method: 'CITIC' (Default), 'SW_2021'
         st: 2022.01.03 (Default)
         et: 2023.01.02 (Default)
Output:
         regression table
*/

Note:

The initial factor table tbName is required only when factorsTable is true. In this case, you must pass a full factor table that has already been standardized, winsorized, market-neutralized, and industry-weighted using the getAllFactors function (or a partial factor table after filtering stocks). Consequently, the parameters normlizing, scaling, decap, and industry_weighted have no effect on the result whether they are false or true. That is, tmpReg = getRegTable(factorsTable = true,tbName = Factors,st= st,et = et).

fTable = getRegTable(factorsTable = true,tbName = Factors,st= st,
                     et = et,normlizing = normlizing ,scaling = scaling,
                     decap = decap, industry_method = industry_method, 
                     industry_weighted = industry_weighted)

After running the command above, the comparison of data before and after processing is as follows:

Before processing, the raw Level-3 factor wide table generated by getAllFactors:

After processing, the Level-3 factor wide table cleaned (e.g., missing values filled) by getRegTable:

$r_{n,t}=x_{n,s,t}\times f_{s,t}+\sum _{i=1}^S{x}_{n,i,t}\times f_{i,t}+u_{n,t}$

Here, weighted least squares (WLS) is used with r_n,t as the dependent variable and the factor exposure x_n,s,t of the style factor s as the independent variable to predict f_s.t (the return of the style factor).

$r_{n,t}=x_{n,i,t}\times f_{i,t}+\sum _{s=1}^S{x}_{n,s,t}\times f_{s,t}+u_{n,t}$

Here, WLS is used with r_n,t as the dependent variable and the factor exposure x_n,i,t of the industry factor i as the independent variable to predict f_i.t (the return of the industry factor).

The regression model is implemented via the getOneFactorValidate, which is integrated into the style factor validation function styleValidate and the industry factor validation function industryValidate.

/* getOneFactorValidate
Aggregate function for computing moving WLS single-factor regression result statistics.
Input:   y: Dependent variable
         x: Independent variable
         w: Weight
Output:
         wls stat: "beta", "tstat", "R2", "AdjustedR2", "Residual"
*/

The t-value test examines whether the factor return of the corresponding variable is significantly different from 0 and can be used to measure the effectiveness and consistency of the factor. It is calculated as follows: $\frac{\widehat{f_{i,t}}}{\text{SE}\left(\widehat{f_{i,t}}\right)}$ , where $\text{SE}\left(\widehat{f_{i,t}}\right)$ is the standard error of the estimated factor return $\widehat{f_{i,t}}$ .

The t-test is mainly based on the t-statistics obtained from the regression model of the getOneFactorValidate interface.

When building a multi-factor model, the stability of factor exposures must be considered. If the factor exposure matrix varies greatly from one calculation to the next, the model has poor robustness. Therefore, this article introduces the Factor Stability Coefficient (FSC), defined as the correlation between the current month's factor exposure matrix and the next month's factor exposure matrix.

Typically, the FSC is calculated by comparing factor loadings obtained from two independent factor analyses on different datasets or at different time points. In this article, the getFactorsValidation function calculates the FSC based on Spearman's rank correlation coefficient. Let dt be the difference in rank values of the factor exposure x_n,i,t between period t and period t+1: $d_t=\mathrm{rank}\left(x_{n,i,t}\right)-\mathrm{rank}\left(x_{n,i,t+1}\right)$ , the FSC is calculated as:

${\rho }_t=1-\frac{6\sum _{}^{}{d}^2}{n(n^2-1)}$ .

Researchers typically use thresholds to interpret the Factor Stability Coefficient. For example, an FSC greater than 0.8 is generally considered to indicate good stability or consistency, while a value below 0.5 may indicate poor stability.

The Information Coefficient (IC) is the correlation between a factor's predicted next-period returns and the actual next-period returns. IC represents the correlation between predicted and realized values and is commonly used to evaluate predictive ability (i.e., stock selection ability). In practice, the IC of factor k is generally the correlation coefficient between a stock's exposure to factor k in period T and its return in period T+1. The IC value of a factor reflects the degree of linear correlation between a stock's next-period return and its current-period factor exposure, indicating the robustness of using the factor for return prediction. IC can be calculated in two ways: normal IC and rank IC. In this article, the getFactorsValidation function calculates the Rank IC based on the Spearman correlation coefficient.

${\mathrm{IC}}_i=\mathrm{correlation}({\tilde{f}}_{i,t+1},f_{i,t+1})\approx \mathrm{correlation}(x_{i,t},f_{i,t+1})$

An IC value above 0.03 is considered to indicate that the factor has consistent or inverse fluctuation patterns with the market, and thus the factor has some effectiveness.

The corresponding function for the single-factor validity test in this article is getFactorsValidation. Taking the computed full factor table as input, this function outputs the single-factor returns, t-statistics, goodness of fit, FSC metric, and IC values for each single-factor model. These values make it possible to analyze all factors comprehensively and systematically.

Input:
         factorsTable         false (Default)    Whether to use the provided factor table
         tbName               NULL  (Default)    Regression factor table
         normlizing           true  (Default)    Standardization
         scaling              true  (Default)    Winsorization
         decap                true  (Default)    Market capitalization neutralization
         industry_weighted    true  (Default)    Industry factor weighting
         industry_method      'CITIC' (Default), 'SW_2021'
         st                   2022.01.03 (Default)
         et                   2023.01.02 (Default)
Output:
         Factor test table    factor_return, tstat, R2, fsc, IC

• Step 1: Obtain the test metrics for all factors.

  // Obtain validity, consistency, and stability checks for single-style factors.
  factorsValid = getFactorsValidation(factorsTable = true,tbName = out,st=2022.01.03,
                                      et =2023.01.02, normlizing = true,scaling = true,
                                      decap = true,industry_method = 'CITIC',
                                      industry_weighted = true)

• Step 2: Plot the monthly FSC time series to evaluate factor stability.

  tmp = select record_date,valueType.regexReplace("_stat","") as valueType,
               fsc from factorsValid 
  tmppivot = select fsc from tmp pivot by record_date,valueType
  tbfsc = sql(select = sqlCol(tmppivot.columnNames()[11:20]),from = tmppivot).eval()
  plot(tbfsc,tmppivot.record_date,extras={multiYAxes: false},title = "Monthly Time Series of Factor FSC")

  

  Factors whose FSC remains above 0.8 most of the time are generally considered to have high stability. In the figure above, all factors except em, dastd, and dtoa exhibit good stability.

• Step 3: Plot the monthly IC time series to evaluate factor consistency. An IC value above 0.03 is considered to indicate that the factor has consistent or inverse fluctuation patterns with the market, and thus the factor has some effectiveness.

  tmp1 = select record_date,valueType.regexReplace("_stat","") as valueType,
                abs(ic) as ic from factorsValid 
  tmppivot1 = select ic from tmp1 pivot by record_date,valueType
  tbic = sql(select = sqlCol(tmppivot1.columnNames()[2:10]),from = tmppivot1).eval()
  baseline = take(0.03,(shape tbic)[0])
  plot(table(tbic,baseline),tmppivot1.record_date,
      extras={multiYAxes: false},title = "Monthly Time Series of Factor IC")

  

  It can be observed that the atvr (Annualized Traded Value Ratio) factor maintained a strong correlation before 2017, while from 2018 to 2022 the eight factors exhibited periodic fluctuations.

• Step 4: Plot the factor t-statistics to evaluate factor effectiveness.

  tmp2 = select record_date,valueType.regexReplace("_stat","") as valueType,
                tstat from factorsValid 
  tmppivot2 = select tstat from tmp2 pivot by record_date,valueType
  tbstat = sql(select = sqlCol(tmppivot2.columnNames()[11:20]),from = tmppivot2).eval()
  
  baseline_neg = take(-0.03,(shape tbstat)[0])
  baseline_pos = take(0.03,(shape tbstat)[0])
  plot(table(tbstat,baseline_neg,baseline_pos),tmppivot2.record_date,
      extras={multiYAxes: false},title = "Monthly Time Series of Factor t-statistics")

  

  In the figure, the t-values of most factors are far from the baselines of 0.03 and -0.03. For example, dastd and cmra: one is significantly above 0.03, and the other is significantly below -0.03. It can therefore be concluded that before 2018, these two factors exhibited significant positive and negative correlations with the market, respectively.

• Preprocess the existing factor data by calling functions such as winsorized and standardized to winsorize and standardize the style factors.

• Handle missing values in the preprocessed factor data to prevent missing factor values from affecting the results of the regression model.

Assuming the final factor table is Factors, you can call the getRegTable function to handle missing values.

fTable= getRegTable(factorsTable = true,tbName = Factors,st= st,et = et)

Assuming the final factor table is Factors, you can call the getFactorsValidation function to perform single-factor model testing and further screen for effective factors.

factorsValid= getFactorsValidation(factorsTable = true,tbName = Factors,st= st,et = et)

After mapping the user-defined factors to their corresponding Level-1 and Level-2 factors, use the getFSLevelFactor function to synthesize the Level-1 and Level-2 factors from the user-defined factors.

getFSLevelFactor(fTable,factorsValid,firstFactors,secondFactors,false , "ir",level = "F")
getFSLevelFactor(fTable,factorsValid,firstFactors,secondFactors,false , "ir",level = "S")

Bayesian shrinkage is a common technique for combining prior information with sample estimates. The main reason for applying Bayesian shrinkage adjustment is that idiosyncratic volatility computed from in-sample data using a multi-factor risk model has poor out-of-sample persistence. Extremely high or low individual stock volatility may exhibit mean reversion, causing volatility to be overestimated or underestimated.

The BayesShrinkage function implements the Bayesian shrinkage described in this section. It is called by getRetTable when shrink=true.

/* BayesShrinkage
BayesShrinkage adjusts idiosyncratic volatility
Input:
         cov                    idiosyncratic return covariance matrix
         weight                 market capitalization weight
         q                      λ_F shrinkage coefficient

Output:
         cov                    covariance matrix adjusted by BayesShrinkage
*/

The implementation steps of the above interface are as follows:

1. Calculate the sample estimate—the idiosyncratic return risk $\widehat{{\sigma }_n}$ obtained from WLS predictions.

2. Calculate the prior-first select all stocks in the same market-capitalization group as the target stock, and then calculate the market-capitalization-weighted average of the idiosyncratic return volatility.

   $\overline{\sigma }\left(s_n\right)=\sum _{n\in s_n}{w}_n\widehat{{\sigma }_n}$

   Here, the multi-factor risk model divides all stocks into ten market-capitalization buckets. s_n denotes the corresponding market-capitalization bucket, $\widehat{{\sigma }_n}$ is the idiosyncratic return volatility of the n stocks in the same market-capitalization bucket s_n, and w_n denotes the market-capitalization weight of the n stocks.

3. Apply Bayesian shrinkage (shrinking the sample estimate toward the prior) to compute the posterior estimate.

   ${\sigma }_n^{\mathrm{SH}}={\nu }_n\overline{\sigma }\left(s_n\right)+(1-{\nu }_n)\widehat{{\sigma }_n}$

   v_n is the weight assigned to the prior during shrinkage (called the shrinkage intensity coefficient). The specific formula is as follows:

   ${\nu }_n=\frac{q\left|\widehat{{\sigma }_n}-\overline{\sigma }\left(s_n\right)\right|}{\sqrt{\frac{1}{N\left(s_n\right)}\sum _{n\in s_n}{\widehat{{\sigma }_n}-\overline{\sigma }\left(s_n\right)}^2}+q\left|\widehat{{\sigma }_n}-\overline{\sigma }\left(s_n\right)\right|}$

   where N(s_n) is the total number of stocks in the current market capitalization bucket, $\left|\widehat{{\sigma }_n}-\overline{\sigma }\left(s_n\right)\right|$ is the degree of deviation between the sample idiosyncratic volatility and the prior, $\frac{1}{N\left(s_n\right)}\sum _{n\in s_n}{\widehat{{\sigma }_n}-\overline{\sigma }\left(s_n\right)}^2$ is the standard deviation of that deviation within the bucket s_n, and q is the empirical shrinkage coefficient, which controls whether more weight is placed on the within-bucket standard deviation or on the deviation of a stock from the bucket mean. As $\left|\widehat{{\sigma }_n}-\overline{\sigma }\left(s_n\right)\right|$ increases, indicating a greater deviation in the volatility of the target stock’s idiosyncratic returns, the sample estimate becomes less reliable. Therefore, a higher prior weight v_n is assigned.

Assume that the idiosyncratic return of each stock in the portfolio is uncorrelated with the common factor returns, and that the idiosyncratic returns of individual stocks are also uncorrelated with each other. Therefore, if w represents the weights of the stocks in the portfolio, the risk matrix of portfolio P can be

expressed as: ${\sigma }_P^2=w^T(X{V}_f{X}^T+\Delta )w$ .

• Industry Neutrality

  Industry neutrality means that the industry allocation of the long portfolio is consistent with that of the hedging benchmark. The purpose of industry-neutral allocation is to eliminate the influence of industry factors on strategy returns and to focus only on the excess returns of individual stocks within industries. Let H be the industry factor dummy matrix of the sample stocks, and h be the corresponding weights of the 30 industries in the CSI 300. Then the industry-neutral weight w satisfies: $w^{T}H=h^T;w\ge 0$ .

• Style Factor Neutrality

  Style factor neutrality means that the style factor risk exposure of the long portfolio relative to the hedging benchmark is zero. The purpose of style-factor-neutral allocation is to eliminate the portfolio's risk exposure to market style factors, so that the portfolio's returns come mainly from alpha returns rather than from a specific market style. Let X be the cross-section of factor loadings for the k-th factor in the sample, and wbench be the corresponding CSI 300 index weight. Then the style-neutral weight w for factor k satisfies: $\forall k^{\prime }(w^T-{w_{\text{bench}}}^T)X_{k^{\prime }}=0$ .

• Cash Neutrality

  Cash neutrality means that the long and short market values are equal, leaving no directional exposure. Then the cash-neutral weight w satisfies: $\sum _{i=1}^N{w}_i=1$ .

• Minimum Predicted Return

  Imposing a minimum predicted return is one of the constraints in multi-factor portfolio weight optimization. Its purpose is to ensure a minimum return level, help control risk, avoid irrational allocations, and maintain model consistencyThis makes the portfolio more consistent with investment objectives and risk preferences, and improves the overall stability and predictability of the portfolio. Suppose r_min is the benchmark return. Then the portfolio weight w should satisfy: $w^{T}r\ge r_{\min }$ .

This section presents an optimization method that minimizes predicted returns and portfolio risk subject to industry and style neutrality constraints. The corresponding function getOptimizeWeights implements the following optimization objective. The deIndustry and deStyle parameters can be used to specify whether to impose industry and style neutrality constraints, respectively.

$\begin{array}{cc}\text{Min}& w^T(X{V}_f{X}^T+\Delta )w\\ \text{s.t.}& \forall k^{\prime }(w^T-{w_{\text{bench}}}^T)X_{k^{\prime }}=0\\ & w^{T}H=h^T\\ & w^{T}r\ge r_{\min }\\ & w\ge 0\\ & \sum _{i=1}^N{w}_i=1\end{array}$

/* getOptimizeWeights
Aggregate function in portfolio weight optimization
Input:
         covf              Factor return covariance matrix
         delta             Idiosyncratic return covariance matrix
         st                2022.01.03(Default)
         et                2023.01.02(Default)
         ret               Expected return
         r                 0.05                              Set minimum predicted return
         tbName            Factor exposures
         deIndustry        true                             Industry neutrality
         deStyle           true                             Style neutrality

Output:
         weightTable       Returns the predicted asset allocation weights
*/

Using the getOptimizeWeights function, the following script implements risk minimization subject to a minimum return:

optionCode = exec stock_code from getPredicOut(facTable1).predict_ret 
             order by return_day desc limit 20           
// Preliminary screening of stock1
optionCode = exec stock_code from getPredicOut(facTable2).predict_ret 
             order by return_day desc limit 20  

// Model with return constraint and risk minimization
portWeight1 = getOptimizeWeights(facTable = facTable1,retOut = retOut1,
                                 st = st,et = et, method ="minRiskControlRet",
                                 r = 0.05,optionCode = optionCode)      
// Get portfolio weights
portWeight2 = getOptimizeWeights(facTable = facTable2,retOut = retOut2,
                                 st = st,et = et, method ="minRiskControlRet",
                                 r = 0.05, optionCode = optionCode)

index_code = '000300'
CodePre = set(exec stock_code from getPredicOut(facTable1).predict_ret 
              order by return_day desc limit 200)          
 // Preliminary screening of stock2
CodeWeight = set(exec stock_code 
                from getBenchMark(st=st,et=et,code = index_code) 
                where i_weight != 0)
CodeFac =set(exec stock_code from facTable1 )
optionCode = (CodePre&CodeWeight&CodeFac).keys()
portWeight3 = getOptimizeWeights(facTable = facTable1,retOut = retOut1,
                                 st = st,et = et, method ="minRiskControlRet",
                                 r = 0.005,deStyle = true,optionCode = optionCode)  
// Obtain the weight combination and achieve zero exposure to style risk.
portWeight3 = getOptimizeWeights(facTable = facTable1,retOut = retOut1,st = st,
                                 et = et, method ="minRiskControlRet",r = 0.005,
                                 deIndustry = true,optionCode = optionCode)  
// Obtain the weight combination and achieve zero exposure to industry risk.
portWeight4 = getOptimizeWeights(facTable = facTable2,retOut = retOut2,st = st,
                                 et = et, method ="minRiskControlRet",r = 0.05,
                                 optionCode = optionCode)

Ex-post asset allocation refers to the allocation of assets based on actual historical return data after those returns become available. This process occurs after investment decisions are made and reallocates assets based on the observed historical return data. Therefore, by evaluating the bias of an existing index using the market-capitalization or equal-weight method, the bias statistic and Q statistic of a specified portfolio can be calculated to evaluate the ex-post asset allocation.

• Factor (portfolio) Bias

• Asset (portfolio) Bias

Use the getFacSpecialBias function to calculate the bias statistics of the ex-post asset allocation to evaluate it.

/*
Get the time-series Bias statistics of factors and the idiosyncratic return statistics of individual stocks
Input:
         retOut   The result returned by the getRetTable() function
         index_name   Index code
         method   Equal-weight or float market-capitalization method: 'equal', 'float_market'
Output:
         Bias statistics
*/

// Factor portfolio
retOut = getRetTable(facTable1,adjust = true,shrink = false ,eigenfactor = false)  

// Get the time-series Bias statistic values of all factors and all individual stocks.
biasOut = getFacSpecialBias(retOut)

// Factor Bias
tmpfBias = select bias_stat from biasOut.fac_bias pivot by record_date,valueType
tmpfBias = tmpfBias[23:]
tbfBias = sql(select = sqlCol(tmpfBias.columnNames()[1:9]),from = tmpfBias).eval()

plot(tbfBias,tmpfBias.record_date,extras={multiYAxes: false},
     title = "Time Series of Factor Model Factor Bias Statistics")
plot(tbfBias,tmpfBias.record_date,extras={multiYAxes: false})

code0 = parseExpr("rowAvg("+ concat(tmpfBias.columnNames()[1:],',') + ")")
avgfBias =  sql(select = sqlColAlias(code0,'avg_bias_stat'),from = tmpfBias ).eval()
plot(avgfBias,tmpfBias.record_date,extras={multiYAxes: false},
     title = "Time Series of Factor Mean Bias Statistics")
plot(avgfBias,tmpfBias.record_date,extras={multiYAxes: false})

// Idiosyncratic  Bias
tmpsBias = select mean(bias_stat) from biasOut.stock_bias group by record_date
tmpsBias = tmpsBias[23:]

plot(tmpsBias.avg_bias_stat,tmpsBias.record_date,
     extras={multiYAxes: false},title = "Time Series of Factor Model-Specific Risk Bias Statistics")

/*Simple asset allocation evaluation*/
// Calculate the Bias statistics of the index allocation.
tmpIndexbiasbn = getFacSpecialBias(retOut,'000300','equal').stock_bias
tmpIndexBias = select wavg(bias_stat,weight) from tmpIndexbiasbn group by record_date
plot(tmpIndexBias.wavg_bias_stat,tmpIndexBias.record_date,extras={multiYAxes: false})
tmpIndexbiasbn = getFacSpecialBias(retOut,'000300','float_market').stock_bias
tmpIndexBias = select wavg(bias_stat,weight) from tmpIndexbiasbn group by record_date

plot(tmpIndexBias.wavg_bias_stat,tmpIndexBias.record_date,extras={multiYAxes: false})

Ex-ante asset allocation refers to asset allocation based on model predictions and assumptions before actual return data becomes available. This process occurs before investment decisions are made and allocates assets based on model predictions, investor objectives, constraints, and other factors. Using portfolio weights derived from an optimization objective or given in advance, we can calculate the bias statistic and Q statistic of a specified portfolio to examine the rationality of the specified asset allocation weights or evaluate the quality of the optimized weights.

Use the getPortfolioAccuracy function to evaluate ex-ante asset allocation portfolios.

/* getPortfolioAccuracy
Calculate the time-series Bias statistic and Q-statistic of a portfolio
Input:
         facTable          NULL   (Default)   Full factor regression table (returned by the getFSLevelFactor function)
         retOut            NULL  (Default)   Full factor return table (returned by the getRetTable function)
         st                2022.01.03(Default)
         et                2023.01.02(Default)
         index_code        Specified portfolio       '000300', '399101'
         method            Weighting method       "float_value" for float market-capitalization weighting, "equal" for equal weighting
Output:
         accuracyTable
         */

Taking the equal-weighted portfolio of the CSI 300 Index as an example, the getPortfolioAccuracy function can be used to calculate the deviation of the ex-ante predicted portfolio. The mean Bn statistic is 0.335, which is less than 1. However, the bias result here is related to the portfolio weights obtained from the ex-ante prediction. This indicates that the equal-weighted portfolio of the CSI 300 Index has weak predictability of future risk, suggesting that the asset allocation should be reconsidered.

/* Calculate the Bias and Q statistics of the prediction model. */
index_code = '000300'
st = 2022.01.03 
et = 2023.01.02
outAccuracy = getPortfolioAccuracy(st,et,facTable1,retOut,index_code,'equal')
outAccuracy = outAccuracy[2:]
baseline = take(1,(shape outAccuracy)[0])
plot(table(outAccuracy.bias_statistic,baseline),outAccuracy.record_date, extras={multiYAxes: false})
mean(outAccuracy)

To calculate a style factor, call the function formed by `get` plus the style factor name. Taking the ABS factor as an example, it can be calculated by calling the getAbs() function as follows:

// Get raw style factors,some sample codes:
getAbs(startTime = 2022.01.03,endTime = 2023.01.02)

After calculating a single style factor, call functions such as getIndustry and getIndustryFactor to obtain industry factors. Taking the CITIC Level-1 industry classification as an example, the calculation method is as follows:

// Get raw industry factors,some sample codes:
getIndustry(startTime = 2022.01.01,endTime = 2023.01.02,method = 'CITIC')
// Get Industry Factor Weights,some sample codes:
getIndustryWeighted(startTime = 2022.01.03,endTime = 2023.01.02,method = 'CITIC')
// Get weighted industry factors
getIndustryFactor(startTime = 2022.01.03,endTime = 2023.01.02,method = 'CITIC')

The factor synthesis process in the RiskFactors module is relatively complex and must be handled step by step along the following pipeline:

1. Use getAllFactors to obtain all factors.

2. Use getRegTable to handle missing values in the raw factor table.

3. Use getFactorsValidation to validate all factor tables.

4. Use getFSLevelFactor to synthesize factors.

To facilitate further construction of the RiskFactors model, the workflow described above can be executed in a unified manner using the prepareModelData function. For example, to generate a Level-1 factor table for the period from January 3, 2022 to January 2, 2023, with the raw factors market-capitalization-weight standardized and winsorized, the CITIC Level-1 industry classification applied, and Level-1 factors synthesized using equal weighting, use the following script. If factor synthesis is not required, set merge_level=NULL:

st = 2022.01.03 
et = 2023.01.02
normlizing = true
scaling = true
decap = true
// also you can choose industry_method = 'SW_2021'
industry_method = 'CITIC'
industry_weighted = true
// Get ALL FIRST level of factors and factor Validation table
factorsValid,facTable1=prepareModelData(st,et,normlizing,scaling,decap,
                                        industry_method,industry_weighted,
                                        merge_method="equal",merge_level="F")

select * from facTable1 limit 100

In addition, using the factor validity metrics in factorsValid obtained above, you can further evaluate factor effectiveness. The usage is as follows:

x,y=plotFactorsValidation(factorsValid,"fsc")
plot(x,y,extras={multiYAxes: false},title = "Monthly Time Series of Factor FSC")

x,y=plotFactorsValidation(factorsValid,"ic")
plot(x,y,extras={multiYAxes: false},title = "Monthly Time Series of Factor IC")

x,y=plotFactorsValidation(factorsValid,"t")
plot(x,y,extras={multiYAxes: false},title = "Monthly Time Series of Factor t-statistics")

Use the getRetTable function to build a RiskFactors multi-factor model from factor tables. The following example assumes that market returns exhibit serial autocorrelation, market factors are closely correlated, and adjustment for idiosyncratic risk is required:

retOut1 = getRetTable(facTable1,adjust = true,shrink = true,eigenfactor = true)   

// the output of getRetTable function
// the idiosyncratic return covariance matrix for 12.30
retOut1.stock_risk[string(2022.12.30)] 
// risk factor covariance matrix for 12.30
retOut1.fac_risk[string(2022.12.30)] 
// R2
retOut1.R2 
// trait return
retOut1.res 
// t-statistics
retOut1.tstat 
// factor returns
retOut1.fac_ret 
// bias statistic
retOut1.bias 

// R2 Monthly Frequency Timing Chart
plot(retOut1.R2.stR2,retOut1.R2.record_date,"Monthly Time Series of Studentized R²")

With the objective of minimizing risk, assume the stock pool consists of the top 20 stocks by predicted next-period return, and the risk-free rate is 0.05. The following example shows how to obtain the optimal portfolio:

// Initial screening stock1
optionCode = exec stock_code from getPredicOut(facTable1).predict_ret 
             order by return_day desc limit 20         

// Controlled return, minimized risk model
// Obtaining weight combinations
portWeight1 = getOptimizeWeights(facTable = facTable1,retOut = retOut1,st = st,et = et, 
                                  method ="minRiskControlRet",r = 0.05,
                                  optionCode = optionCode)

For ex-post evaluation of factor portfolios, the following example can be used to calculate and plot the time series of factor model factor bias statistics and factor model-specific risk bias statistics:

x,y=FactorCombinationAssessment(retOut = retOut1,plot_index="bias_stat")
plot(x,y,title = "Time Series of Factor Model Factor Bias Statistics")

x,y = FactorCombinationAssessment(retOut = retOut1,plot_index="avg_bias_stat")
plot(x,y,extras={multiYAxes: false},title = "Time Series of Factor Mean Bias Statistics")   

x,y = FactorCombinationAssessment(retOut = retOut1,plot_index="stock_bias_stat")
plot(x,y,extras={multiYAxes: false},title = "Time Series of Factor Model-Specific Risk Bias Statistics")

Taking the CSI 300 Index as an example and constructing the index with the equal-weight method, the following example shows a simple asset allocation evaluation of the index:

x,y =AssetPortfolioAssessment(retOut = retOut1,index_code="000300",
                              index_weight="equal") 
plot(x,y,extras={multiYAxes: false})