Menganalisis rasio Sharpe, penarikan maksimum, tingkat pengembalian, dan algoritma indikator lainnya dalam pengujian ulang strategi

Anggota grup sering mendiskusikan beberapa algoritma indikator kinerja strategi, dan algoritma tersebut juga diungkapkan dalam dokumentasi API FMZ. Namun, agak sulit untuk memahaminya tanpa komentar. Dalam artikel ini, saya akan mengajak Anda untuk menganalisis algoritma ini. Saya yakin bahwa setelah membaca artikel ini, Anda akan memiliki pemahaman yang lebih baik tentang konsep dan logika perhitungan rasio Sharpe, maksimum penarikan, dan tingkat pengembalian. Semua orang memiliki pemahaman yang lebih jelas.

Kita langsung ke kode sumber, yang ditulis dalam JavaScript. Sistem pengujian ulang FMZ juga menggunakan algoritma ini untuk secara otomatis menghasilkan data kinerja pengujian ulang.

fungsi 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

Karena merupakan fungsi komputasi, ia harus mempunyai masukan dan keluaran. Mari kita lihat dulu input fungsinya:

totalAssets, profits, ts, te, period, yearDays

• totalAssets Parameter ini adalah total aset awal saat strategi mulai berjalan.

• profits Parameter ini merupakan parameter yang relatif penting karena serangkaian perhitungan indikator kinerja didasarkan pada data mentah ini. Parameter ini adalah array dua dimensi, formatnya adalah sebagai berikut:[[timestamp1, profit1], [timestamp2, profit2], [timestamp3, profit3], ....., [timestampN, profitN]], kita dapat melihat bahwa fungsi returnAnalyze memerlukan struktur data yang mencatat urutan kronologis pengembalian pada setiap momen. timestamp1 hingga timestampN diurutkan dari yang terjauh hingga yang dekat dalam waktu. Ada nilai keuntungan pada setiap titik waktu. Jadi, misalnya, titik waktu ketiga dalam catatan pendapatan adalah[cap waktu3, laba3]. Dalam sistem pengujian ulang pada jalur FMZ, data array keuntungan disediakan untuk fungsi ini oleh sistem pengujian ulang. Tentu saja, jika Anda merekam sendiri data keuntungan untuk membentuk struktur array seperti itu, Anda juga dapat menyediakannya ke fungsi perhitungan ini untuk hitung hasilnya.

• ts Cap waktu mulai pengujian ulang.

• te Stempel waktu akhir pengujian ulang.

• period Siklus komputasi dalam milidetik.

• yearDays Hari perdagangan dalam setahun.

Selanjutnya, mari kita lihat output dari fungsi ini:

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

• totalAset: Kekayaan bersih awal
• yearDays: hari perdagangan
• totalReturns: tingkat pengembalian kumulatif
• annualizedReturns: pengembalian tahunan
• sharpeRatio: Rasio Sharpe
• Volatilitas: volatilitas
• maxDrawdown: Penarikan kembali maksimum
• maxDrawdownTime: Cap waktu penarikan maksimum
• maxAssetsTime: stempel waktu nilai bersih maksimum
• maxDrawdownStartTime: Waktu mulai retracement maksimum
• winningRate: tingkat kemenangan

Mengetahui input dan output, sekarang kita mengerti untuk apa fungsi ini digunakan. Sederhananya, berikan fungsi ini beberapa catatan mentah, seperti serangkaian statistik pendapatan. Fungsi ini akan menghitung hasil untuk menunjukkan kinerja uji ulang.

Selanjutnya, mari kita lihat bagaimana kode tersebut dihitung:

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
    }
}

Algoritmanya tidak rumit secara keseluruhan, tetapi mungkin ada beberapa konsep yang perlu dipahami terlebih dahulu.

• perbedaan: Ini dapat dipahami sebagai sekumpulan data pendapatan: Rata-rata dari kumpulan sampel 1, 2, 3, 4, 5 adalah (1+2+3+4+5)/5=3, dan variansnya adalah jumlah kuadrat selisih antara setiap titik data dan titik data lainnya. rata-rata. Rata-rata dari adalah:[(1-3)^2+(2-3)^2+(3-3)^2+(4-3)^2+(5-3)^2]/5=2, dan variansnya adalah 2 .

• Deviasi Standar: Ambil akar kuadrat dari varians, yang merupakan deviasi standar.

• Keriangan: Bila skala perhitungannya ditahunan, volatilitas adalah deviasi standar.

Setelah Anda memahami konsep dan rumus perhitungan ini, bagian perhitungan Sharpe dari fungsi tersebut akan jelas sekilas. Rumus perhitungan rasio Sharpe: (pengembalian tahunan - tingkat bebas risiko) / deviasi standar

Sudahkah Anda mempelajarinya?