Analyser le ratio de Sharpe, le drawdown maximum, le taux de rendement et d’autres algorithmes indicateurs dans le backtesting de stratégie

Les membres du groupe discutent souvent de certains algorithmes d’indicateurs de performance des stratégies, et un algorithme est également divulgué dans la documentation de l’API FMZ. Cependant, il est un peu difficile à comprendre sans commentaires. Dans cet article, je vais vous emmener analyser cet algorithme. Je pense qu’après avoir lu cet article, vous devriez avoir une meilleure compréhension des concepts et de la logique de calcul du ratio de Sharpe, du maximum drawdown et taux de rendement. Tout le monde a une compréhension plus claire.

Nous allons directement au code source, qui est écrit en JavaScript. Le système de backtesting de FMZ utilise également cet algorithme pour générer automatiquement des données de performance de backtesting.

fonction returnAnalyze

function returnAnalyze(totalAssets, profits, ts, te, period, yearDays)

https://www.fmz.com/api#%E5%9B%9E%E6%B5%8B%E7%B3%BB%E7%BB%9F%E5%A4%8F%E6%99%AE%E7%AE%97%E6%B3%95

Puisqu’il s’agit d’une fonction de calcul, elle doit avoir une entrée et une sortie. Regardons d’abord l’entrée de la fonction :

totalAssets, profits, ts, te, period, yearDays

• totalAssets Ce paramètre correspond au total des actifs initiaux lorsque la stratégie commence à fonctionner.

• profits Ce paramètre est un paramètre relativement important car une série de calculs d’indicateurs de performance sont basés sur ces données brutes. Ce paramètre est un tableau bidimensionnel, le format est le suivant :[[timestamp1, profit1], [timestamp2, profit2], [timestamp3, profit3], ....., [timestampN, profitN]], nous pouvons voir que la fonction returnAnalyze nécessite une structure de données qui enregistre l’ordre chronologique des retours à chaque instant. Les horodatages 1 à horodatage N sont classés du plus éloigné au plus proche dans le temps. Il y a une valeur de profit à chaque instant. Ainsi, par exemple, le troisième point temporel dans l’enregistrement des revenus est[[horodatage3, profit3]. Dans le système de backtesting sur la ligne FMZ, les données du tableau des bénéfices sont fournies à cette fonction par le système de backtesting. Bien entendu, si vous enregistrez vous-même les données de bénéfices pour former une telle structure de tableau, vous pouvez également les fournir à cette fonction de calcul pour calculer le résultat.

• ts L’horodatage de début du backtest.

• te L’horodatage de fin du backtest.

• period Cycle de calcul en millisecondes.

• yearDays Jours de bourse dans une année.

Ensuite, examinons la sortie de cette fonction :

return {
        totalAssets: totalAssets,
        yearDays: yearDays,
        totalReturns: totalReturns,
        annualizedReturns: annualizedReturns,
        sharpeRatio: sharpeRatio,
        volatility: volatility,
        maxDrawdown: maxDrawdown,
        maxDrawdownTime: maxDrawdownTime,
        maxAssetsTime: maxAssetsTime,
        maxDrawdownStartTime: maxDrawdownStartTime,
        winningRate: winningRate
    }

• totalAssets : valeur nette initiale
• yearDays : jours de bourse
• totalReturns : taux de rendement cumulé
• annualizedReturns : rendement annualisé
• sharpeRatio : Ratio de Sharpe
• Volatilité : volatilité
• maxDrawdown : Retracement maximal
• maxDrawdownTime : Horodatage du drawdown maximal
• maxAssetsTime : horodatage de la valeur nette maximale
• maxDrawdownStartTime : Heure de début de retracement maximale
• Taux de gain : taux de gain

Connaissant l’entrée et la sortie, nous comprenons maintenant à quoi sert cette fonction. En termes simples, donnez à cette fonction des enregistrements bruts, tels qu’un tableau de statistiques sur les revenus. La fonction calculera un résultat pour vous montrer les performances du backtest.

Ensuite, voyons comment le code est calculé :

function returnAnalyze(totalAssets, profits, ts, te, period, yearDays) {
    // force by days
    period = 86400000                  // 一天的毫秒数，即 60 * 60 * 24 * 1000
    if (profits.length == 0) {         // 如果参数profits数组长度为0，无法计算直接返回空值
        return null
    }
    var freeProfit = 0.03              // 无风险利率 ，也可以根据需求设置，例如国债年化3%
    var yearRange = yearDays * 86400000          // 一年所有累计的交易日的毫秒数
    var totalReturns = profits[profits.length - 1][1] / totalAssets      // 累计收益率
    var annualizedReturns = (totalReturns * yearRange) / (te - ts)       // 年华收益率，把收益统计的时间缩放到一年的尺度上得出的预期收益率

    // MaxDrawDown
    var maxDrawdown = 0           // 初始化最大回撤变量为0
    var maxAssets = totalAssets   // 以初始净值赋值初始化最大资产变量
    var maxAssetsTime = 0         // 初始化最大资产时刻的时间戳
    var maxDrawdownTime = 0       // 初始化最大回撤时刻的时间戳
    var maxDrawdownStartTime = 0  // 初始化最大回撤开始时刻的时间戳
    var winningRate = 0           // 初始化胜率为0
    var winningResult = 0         // 记录赢的次数
    for (var i = 0; i < profits.length; i++) {      // 遍历收益数组
        if (i == 0) {
            if (profits[i][1] > 0) {                // 如果第一个收益记录点，收益大于0，表示盈利
                winningResult++                     // 赢的次数累加1 
            }
        } else {                                    // 如果不是第一个收益记录点，只要当前的点的收益，大于前一个时刻（收益点）的收益，表示盈利，赢的次数累加1 
            if (profits[i][1] > profits[i - 1][1]) {
                winningResult++
            }
        }
        if ((profits[i][1] + totalAssets) > maxAssets) {    // 如果该时刻的收益加初始净值大于记录出现过的最大资产，就更新最大资产数值，记录这个时刻的时间戳
            maxAssets = profits[i][1] + totalAssets
            maxAssetsTime = profits[i][0]
        }
        if (maxAssets > 0) {                                // 当记录的最大资产数值大于0时，计算回撤
            var drawDown = 1 - (profits[i][1] + totalAssets) / maxAssets
            if (drawDown > maxDrawdown) {                   // 如果当前回撤大于记录过的最大回撤，更新最大回撤、最大回撤时间等
                maxDrawdown = drawDown
                maxDrawdownTime = profits[i][0]
                maxDrawdownStartTime = maxAssetsTime
            }
        }
    }
    if (profits.length > 0) {                            // 计算胜率
        winningRate = winningResult / profits.length
    }
    // trim profits
    var i = 0
    var datas = []
    var sum = 0
    var preProfit = 0
    var perRatio = 0
    var rangeEnd = te
    if ((te - ts) % period > 0) {
        rangeEnd = (parseInt(te / period) + 1) * period     // 把rangeEnd处理为period的整倍数
    }
    for (var n = ts; n < rangeEnd; n += period) {
        var dayProfit = 0.0
        var cut = n + period
        while (i < profits.length && profits[i][0] < cut) {    // 确保当时间戳不越界，数组长度也不越界
            dayProfit += (profits[i][1] - preProfit)           // 计算每天的收益
            preProfit = profits[i][1]                          // 记录昨日的收益
            i++                                                // 累加i用于访问下一个profits节点
        }
        perRatio = ((dayProfit / totalAssets) * yearRange) / period   // 计算当时年华的收益率
        sum += perRatio                                               // 累计
        datas.push(perRatio)                                          // 放入数组 datas
    }

    var sharpeRatio = 0                    // 初始夏普比率为0
    var volatility = 0                     // 初始波动率为0
    if (datas.length > 0) {
        var avg = sum / datas.length;      // 求均值
        var std = 0;
        for (i = 0; i < datas.length; i++) {
            std += Math.pow(datas[i] - avg, 2);      // std用于计算后面的方差，后面的std / datas.length就是方差，求算数平方根就是标准差
        }
        volatility = Math.sqrt(std / datas.length);  // 当按年时，波动率就是标准差
        if (volatility !== 0) {
            sharpeRatio = (annualizedReturns - freeProfit) / volatility   // 夏普计算公式计算夏普率：（年华收益率 - 无风险利率） / 标准差 
        }
    }

    return {
        totalAssets: totalAssets,
        yearDays: yearDays,
        totalReturns: totalReturns,
        annualizedReturns: annualizedReturns,
        sharpeRatio: sharpeRatio,
        volatility: volatility,
        maxDrawdown: maxDrawdown,
        maxDrawdownTime: maxDrawdownTime,
        maxAssetsTime: maxAssetsTime,
        maxDrawdownStartTime: maxDrawdownStartTime,
        winningRate: winningRate
    }
}

L’algorithme n’est pas compliqué dans son ensemble, mais il peut y avoir quelques concepts qui doivent être compris à l’avance.

• variance: Il peut être compris comme un ensemble de données sur les revenus : La moyenne de l’ensemble d’échantillons 1, 2, 3, 4, 5 est (1+2+3+4+5)/5=3, et la variance est la somme des carrés des différences entre chaque point de données et son moyenne. La moyenne de est :[(1-3)^2+(2-3)^2+(3-3)^2+(4-3)^2+(5-3)^2]/5=2, et la variance est 2 .

• Écart type : Prenez la racine carrée de la variance, qui est l’écart type.

• Volatilité: Lorsque l’échelle de calcul est annualisée, la volatilité est l’écart type.

Une fois que vous aurez compris ces concepts et formules de calcul, la partie calcul de Sharpe de la fonction sera claire en un coup d’œil. Formule de calcul du ratio de Sharpe : (rendement annualisé - taux sans risque) / écart type

L’as-tu appris ?