Измеряем главное (Часть 2): Ковариационная матрица в MQL5 — построение, спектральное разложение и анализ факторов риска
Введение
В Части 1 этой серии мы создали PortfolioRiskAnalyzer.mq5 — скрипт, который выявил разрыв в оценке риска, остающийся незамеченным большинством трейдеров, работающих с несколькими торговыми инструментами. Вычислив полную ковариационную матрицу с помощью встроенного метода OpenBLAS .Cov() , а затем рассчитав фактическую дисперсию портфеля с помощью матричного умножения — wᵀ Σ w — мы показали, что фактический риск одновременного удержания позиций по EURUSD, GBPUSD и XAUUSD может быть существенно выше, чем предполагает упрощенная оценка на основе волатильности отдельных инструментов.
Результатом Части 1 стало одно число — скрытый разрыв в оценке риска. Этот показатель был конкретным, понятным и сразу пригодным для использования. Он сводил информацию о ковариации к одному числу. Матрица размером 3 × 3 вычислялась методом all_returns.Cov() и использовалась для расчета wᵀ Σ w, но не сохранялась и не выводилась. Читатель видел этот разрыв в оценке риска, но пока не мог заглянуть внутрь матрицы, на основе которой он был рассчитан.
Часть 2 меняет эту ситуацию. Мы представляем класс CCovarianceMatrix — объектно-ориентированную обертку над методом OpenBLAS .Cov(). Он сохраняет ковариационную матрицу, проверяет ее симметричность и выводит ее в виде таблицы с подписями. Затем он вызывает встроенный метод MQL5 .Eig(), чтобы получить собственные значения и собственные векторы и показать, какие факторы определяют риск и какова нагрузка каждого торгового инструмента по каждому фактору.
Практический проект Части 2 — CovarianceMatrixPrinter.mq5. Он строит ковариационную матрицу размером 3 × 3, проверяет ее симметричность, выводит ее в виде таблицы с подписями и формирует отчет по факторам риска, раскрывающий факторную структуру портфеля.
Что было создано в Части 1 — и чего она не могла показать
Чтобы понять, что добавляет Часть 2, нужно точно разобраться, что именно было сделано в Части 1. В PortfolioRiskAnalyzer.mq5 ковариационная матрица вычислялась в трех строках кода:
//---From PortfolioRiskAnalyzer.mq5 — Part 1 matrix all_returns; all_returns.Init(3, LookbackBars); all_returns.Row(returns1, 0); all_returns.Row(returns2, 1); all_returns.Row(returns3, 2); matrix cov_matrix = all_returns.Cov();
Активы были расположены в строках, а наблюдения — в столбцах: именно такое расположение требуется методу .Cov() в MQL5 для получения корректной ковариационной матрицы [Актив × Актив]. Полученная матрица cov_matrix имела размер 3 × 3, а каждый ее элемент [i][j] содержал ковариацию между активом i и активом j. Это правильный подход, использующий ускорение OpenBLAS.
Однако сразу после построения матрицы в Части 1 она использовалась только для одной цели:
//---From PortfolioRiskAnalyzer.mq5 — Part 1 vector intermediate = cov_matrix.MatMul(w); // Step A: Cov * w double true_variance = w.Dot(intermediate); // Step B: w^T * (Cov * w)
Матрица была умножена на вектор весов, в результате чего получилось одно скалярное значение — true_variance. После этого вычисления матрица больше не использовалась. Ее внутренняя структура (какие торговые инструменты коррелируют друг с другом, насколько сильно и в каких направлениях) так и не была раскрыта читателю.
Именно это структурное ограничение устраняется в Части 2. Инкапсулировав матрицу в классе, мы можем хранить ее между операциями, выводить каждый элемент с обозначениями соответствующих торговых инструментов, проверять ее симметрию и выполнять разложение на собственные значения и собственные векторы. Каждый из этих этапов раскрывает то, чего не могло показать единственное число, характеризующее разрыв в оценке риска в Части 1.
Модернизация архитектуры: зачем нужен класс
Функция OnStart() данного скрипта должна построить, сохранить, проверить, вывести в журнал и разложить матрицу. В следующих частях мы будем передавать матрицу индикаторам и советникам для постоянного использования. Линейная структура скрипта без разделения на компоненты плохо масштабируется при таком количестве задач.
Класс подходит для этой задачи, поскольку объединяет три взаимосвязанных элемента: данные матрицы, названия торговых инструментов, которыми обозначены ее строки и столбцы, и методы для работы с ней. После создания экземпляра CCovarianceMatrix и построения матрицы любая операция (вывод, проверка симметрии, спектральное разложение) сводится к вызову метода этого объекта. Код OnStart() остается лаконичным. Сам класс становится компонентом для повторного использования, который мы будем напрямую импортировать в Частях 3-10 этой серии статей.
Настройка скрипта: свойства и входные параметры
Откройте MetaEditor и создайте новый файл скрипта с именем CovarianceMatrixPrinter.mq5. Объявления свойств и входные параметры просты — входные параметры для весов инструментов в портфеле нам не нужны, поскольку цель этого скрипта — исследовать структуру матрицы, а не вычислить взвешенный показатель риска:
#property copyright "Measuring What Matters Series — Part 2" #property link "" #property version "1.01" #property script_show_inputs input string Symbol1 = "EURUSD"; input string Symbol2 = "GBPUSD"; input string Symbol3 = "XAUUSD"; input ENUM_TIMEFRAMES TF = PERIOD_H1; input int LookbackBars = 100;
Для работы этого скрипта требуются лишь три торговых инструмента, таймфрейм и период ретроспективного анализа. Веса инструментов в портфеле намеренно не указаны, поскольку задача больше не заключается в вычислении взвешенной дисперсии портфеля. Вместо этого скрипт анализирует саму ковариационную матрицу, исследуя ее структуру и выполняя спектральное разложение. Эти операции зависят исключительно от взаимосвязей между инструментами, а не от того, как распределяется капитал между ними.

Функция ComputeLogReturns
Первая функция в скрипте — ComputeLogReturns. Она собирает цены закрытия, преобразует их в логарифмические доходности и формирует векторы доходностей, используемые на всех этапах анализа ковариации. Вместо того чтобы размещать сопутствующие матричные операции непосредственно в основной логике скрипта, мы организуем их в классе MQL5, что упрощает повторное использование и расширение общей архитектуры.
//+------------------------------------------------------------------+ //| Helper: Compute log returns | //+------------------------------------------------------------------+ bool ComputeLogReturns(const string symbol, ENUM_TIMEFRAMES tf, int bars, vector &log_returns) { vector prices; if(!prices.CopyRates(symbol, tf, COPY_RATES_CLOSE, 0, bars + 1)) { PrintFormat("ERROR: Could not copy rates for %s. Error: %d", symbol, GetLastError()); return false; } log_returns.Init(bars); for(int i = 0; i < bars; i++) { if(prices[i] <= 0.0 || prices[i + 1] <= 0.0) { log_returns[i] = 0.0; continue; } log_returns[i] = MathLog(prices[i] / prices[i + 1]); } return true; }
Каждое проектное решение здесь продумано: для получения N значений доходностей считывается bars + 1 значений цены, формула MathLog(prices[i] / prices[i+1]) вычисляет логарифмическую доходность, проверка на нулевую цену предотвращает появление недопустимых значений, а при ошибке функция досрочно завершает работу. Эта функция служит неизменной основой подготовки данных в этой серии статей и будет использоваться без изменений во всех последующих частях.
Также включена вспомогательная функция PrintDivider:
//+------------------------------------------------------------------+ //| Helper: Print a formatted divider line | //+------------------------------------------------------------------+ void PrintDivider(string ch = "-", int len = 55) { string line = ""; for(int i = 0; i < len; i++) line += ch; Print(line); }
Создание класса CCovarianceMatrix
Объявление класса начинается с трех закрытых членов:
//+------------------------------------------------------------------+ //| CLASS: CCovarianceMatrix | //| Encapsulates the full covariance matrix workflow: | //| - Stores symbol names and scales matrix dimensions dynamically | //| - Builds the covariance matrix natively using OpenBLAS | //| - Verifies structural matrix symmetry | //| - Provides eigenvalue decomposition via native .Eig() | //| - Prints formatted matrix grids and risk factor loading spectra| //+------------------------------------------------------------------+ class CCovarianceMatrix { private: int m_size; string m_symbols[]; matrix m_cov;
m_size хранит количество торговых инструментов — размерность квадратной матрицы. m_symbols[] — это динамический массив строк с именами торговых инструментов, которые используются для обозначения строк и столбцов выводимой таблицы. m_cov — это объект встроенного типа matrix в MQL5, который будет хранить все значения ковариации после вызова Build().
Префикс "m_" во всех трех членах класса — это соглашение об именовании, которое позволяет сразу же определить внутри любого метода, является ли переменная членом класса или локальной переменной. Эту практику стоит внедрить в любом проекте MQL5, в котором используются классы.
Конструктор//--- Constructor CCovarianceMatrix(const string &symbols[], int size) { m_size = size; ArrayResize(m_symbols, m_size); for(int i = 0; i < m_size; i++) m_symbols[i] = symbols[i]; m_cov.Init(m_size, m_size); }
Конструктор принимает массив строк с именами торговых инструментов и целое число, обозначающее размер. Он копирует имена торговых инструментов в m_symbols — вызов ArrayResize перед циклом копирования необходим, поскольку в MQL5 перед записью в динамический массив нужно задать его размер. Затем вызывается метод m_cov.Init(m_size, m_size) для выделения памяти под матрицу размером m_size × m_size, инициализированную нулями и готовую к заполнению методом Build().
В нашем случае с тремя торговыми инструментами получается нулевая матрица размером 3 × 3. Класс рассчитан на любой размер: при передаче size = 5 и названий пяти торговых инструментов создается матрица размером 5 × 5 без структурных изменений в коде.
Метод Build: OpenBLAS в основе
В методе Build происходит собственно вычисление ковариации:
//--- Build the matrix from return vectors via OpenBLAS structures bool Build(const vector &returns[], int n_vectors) { if(n_vectors != m_size || n_vectors < 1) { Print("ERROR: Number of return vectors must match matrix size."); return false; } //--- Collect number of columns/observations from the first asset vector ulong columns = returns[0].Size(); matrix all_returns; all_returns.Init(m_size, columns); //--- Systematically populate rows (Assets as Rows, Observations as Columns) for(int i = 0; i < m_size; i++) all_returns.Row(returns[i], i); //--- Compute full N x N matrix via OpenBLAS engine m_cov = all_returns.Cov(); return true; }
Цикл по m_size позволяет работать с любым количеством торговых инструментов без изменения кода: передача четырех инструментов вместо трех не требует изменений в самом методе Build(). Базовая операция OpenBLAS проста: активам соответствуют строки, наблюдениям — столбцы, а метод .Cov() возвращает ковариационную матрицу размером [Актив × Актив].
Именно из-за ключевого требования к расположению данных — активы в строках, бары в столбцах — в вызове all_returns.Init(m_size, columns) число строк задается значением m_size, а число столбцов — значением returns[0].Size(). Метод .Cov() в MQL5 рассматривает каждую строку как отдельную переменную (актив), а каждый столбец — как одно наблюдение (бар). Если транспонировать эту структуру данных — разместить активы в столбцах, а бары в строках, — метод .Cov() вернет матрицу размером [Бары × Бары], а это не то, что нам нужно://--- MQL5's Cov() treats each ROW as a variable (asset), so we lay out //--- assets as rows and bars as columns
Любой объект CCovarianceMatrix гарантирует такое расположение данных, поэтому вызывающему коду не нужно заботиться о его правильной организации.
Проверка симметрии: метод IsSymmetric
Перед выполнением спектрального разложения проверяется симметричность ковариационной матрицы. Симметричность — это и математическое свойство ковариационных матриц, и практическое требование для надежного выполнения спектрального разложения.
//--- Verify matrix symmetry (computational requirement) bool IsSymmetric(double tol = 1e-10) const { for(int i = 0; i < m_size; i++) for(int j = i + 1; j < m_size; j++) if(MathAbs(m_cov[i][j] - m_cov[j][i]) > tol) return false; return true; }
Ковариационная матрица по определению должна быть симметричной: Cov(X,Y) всегда равна Cov(Y,X). Если метод .Cov() правильно вычисляет матрицу, это свойство будет выполняться всегда. Однако для получения действительных собственных значений при последующем спектральном разложении методом .Eig() необходима симметричная матрица. Если матрица станет несимметричной из-за ошибки в расположении данных, особого случая при численных вычислениях или будущих изменений, метод .Eig() может завершиться с ошибкой или вернуть комплексные собственные значения, которые нельзя интерпретировать как дисперсии.
Проверка IsSymmetric() служит защитным барьером между вызовами Build() и PrintEigenSpectrum(). Она сравнивает все пары внедиагональных элементов [i][j] и [j][i] и возвращает false, если разность элементов хотя бы одной пары по модулю превышает допуск tol, по умолчанию равный 1e-10. Этот порог намного ниже любой значимой численной разницы, но выше уровня шума на масштабе машинного эпсилона при вычислениях с плавающей точкой.
Квалификатор const в сигнатуре метода играет важную роль: он сообщает компилятору, что данный метод не изменяет никаких членов класса. Объявление методов, не изменяющих состояние объекта, с помощью ключевого слова const является правильным подходом при проектировании классов на языке MQL5 и позволяет вызывать такие методы для экземпляров класса, объявленных как const.
В функции OnStart() проверка IsSymmetric() сообщает, пройден ли тест на симметричность:
//--- Validate structural symmetry properties from outline requirements if(cov_matrix.IsSymmetric()) Print(" Computational Verification: Matrix symmetry test PASSED."); else Print(" WARNING: Structural asymmetry detected.");
Если проверка пройдет успешно — а для корректно вычисленных ковариационных матриц так и будет, — в журнале появится строка с подтверждением. Это не просто защитное программирование. В этом есть и учебный смысл: такая проверка показывает, что симметричность ковариационной матрицы — проверяемый факт, а не просто математическое предположение, и формирует привычку проверять структурные свойства перед выполнением операций, которые от них зависят.
Вывод матрицы в табличном виде: PrintMatrix
После построения и проверки матрицы PrintMatrix выводит ее в виде удобной для чтения таблицы с подписями строк и столбцов:
//--- Print a clean, formatted N x N matrix grid to the journal void PrintMatrix() { PrintDivider("="); Print(" COVARIANCE MATRIX (OPENBLAS ACCELERATED)"); PrintDivider(); string header = StringFormat(" %12s", ""); for(int col = 0; col < m_size; col++) header += StringFormat(" %-14s", m_symbols[col]); Print(header); PrintDivider(); for(int row = 0; row < m_size; row++) { string line = StringFormat(" %-12s", m_symbols[row]); for(int col = 0; col < m_size; col++) line += StringFormat(" %+.8f ", m_cov[row][col]); Print(line); } PrintDivider("="); }
При формировании строки заголовка цикл перебирает элементы m_symbols для создания подписей столбцов. Формат %-14s выравнивает название каждого торгового инструмента по левому краю в поле шириной 14 символов, сохраняя выравнивание столбцов независимо от длины названия. При формировании строк данных внешний цикл перебирает торговые инструменты, задавая подпись каждой строки, а внутренний — столбцы, добавляя значения ячеек матрицы.
Использование спецификатора формата %+.8f обусловлено двумя причинами. Требуется восемь знаков после запятой, поскольку значения ковариации между валютными инструментами представляют собой очень малые числа — как правило, в диапазоне от 1e-7 до 1e-8. Без достаточного количества знаков после запятой они будут отображаться как ноль. Явно указанный знак + означает, что положительные значения выводятся со знаком + перед числом, а отрицательные — со знаком -, благодаря чему знак значения в каждой ячейке сразу виден. Внедиагональные ковариации могут быть отрицательными, когда цены торговых инструментов движутся в противоположных направлениях, и этот знак несет важную информацию.
При запуске скрипта с входными параметрами по умолчанию вывод матрицы на вкладке "Эксперты" будет иметь примерно такой вид:

Изучите это изображение, чтобы понять взаимосвязи между активами. Диагональные элементы — +0,00000064 для EURUSD, +0,00000054 для GBPUSD и +0,00001204 для XAUUSD — представляют собой дисперсии отдельных активов (собственную волатильность каждого актива). Таблица позволяет сопоставить индивидуальную дисперсию каждого актива с его взаимосвязями с другими активами.
Внедиагональные элементы показывают, как активы движутся относительно друг друга:
-
EURUSD и GBPUSD (+0,00000047): это значение велико относительно обоих диагональных элементов, что сразу указывает на сильную положительную корреляцию между этими двумя валютными парами.
-
GBPUSD и XAUUSD (-0,00000015): обратите внимание на отрицательный знак. Это означает, что за данный период ретроспективного анализа между GBPUSD и XAUUSD наблюдается слабая обратная зависимость: когда один инструмент растет, другой, как правило, немного снижается.
-
Независимая дисперсия XAUUSD (+0,00001204): это значение значительно превосходит все внедиагональные элементы в своей строке, что подтверждает: динамика цен на золото в значительной степени определяется собственными независимыми факторами, а не теми же факторами, которые влияют на валютные пары.
Представление ковариационной матрицы в виде таблицы с метками позволяет сразу увидеть эти взаимосвязи. Вместо того чтобы работать с абстрактным математическим объектом, мы можем изучить как отдельные дисперсии, так и парные ковариации непосредственно по выводу в журнале.
От общего риска к его составляющим: зачем нужно спектральное разложение
Теперь перейдем к тому, что составляет основной вклад Части 2 в эту серию статей.
В Части 1 ковариационная матрица использовалась для вычисления одного числа:
//--- Part 1 — the entire purpose of the matrix vector intermediate = cov_matrix.MatMul(w); double true_variance = w.Dot(intermediate);
Это дало ответ на вопрос: каков общий уровень риска портфеля? Один скаляр. Полезно, но при этом вся информация, содержащаяся в матрице, сжимается в один показатель.
Ковариационная матрица содержит гораздо больше информации, чем отражает это скалярное значение. Она отражает полную структуру взаимосвязей между инструментами — и в этой структуре заложены основные рыночные факторы, определяющие риск портфеля. Чтобы выделить эти факторы, нам потребуется спектральное разложение.
Спектральное разложение ковариационной матрицы дает два результата:
Собственные значения показывают величину дисперсии, приходящуюся на каждый независимый фактор риска. Каждое собственное значение — это число, показывающее, какая часть общей дисперсии портфеля приходится на данный фактор. Сумма всех собственных значений равна общей дисперсии портфеля — это то же число, которое в Части 1 было вычислено по формуле wᵀ Σ w. Разложение не приводит к появлению новой дисперсии. Оно перераспределяет существующую дисперсию между независимыми ортогональными факторами.
Собственные векторы показывают факторную нагрузку каждого торгового инструмента по каждому фактору. Собственный вектор представляет собой набор коэффициентов, по одному на каждый торговый инструмент, определяющих направление данного фактора в пространстве торговых инструментов. Большая положительная факторная нагрузка EURUSD по фактору 1 означает, что EURUSD сильно изменяется при изменении фактора 1. Близкая к нулю факторная нагрузка означает, что EURUSD практически не участвует в этом факторе.
Практический вывод для торговли здесь очевиден. Предположим, что собственное значение фактора 1 объясняет 75% общей дисперсии портфеля. Предположим, что факторная нагрузка EURUSD по фактору 1 составляет +0,61, а факторная нагрузка GBPUSD по тому же фактору — +0,65. Это точно показывает: три четверти риска вашего портфеля обусловлены одним основным фактором — общей динамикой курса доллара США — и обе ваши позиции по валютным парам в значительной степени подвержены его влиянию. Эти риски не являются независимыми. Это два варианта одной и той же ставки.
Величина скрытого разрыва в оценке риска показывала, что портфель был более рискованным, чем ожидалось. Спектральное разложение точно показывает, почему это происходит и какие торговые инструменты служат причиной. Это различие знаменует переход от измерения совокупного риска к анализу его компонентов и лежит в основе всего, что будет рассмотрено в Частях с 3 по 10 этой серии.
Метод PrintEigenSpectrum: вызов .Eig()
Спектральное разложение выполняется внутри метода PrintEigenSpectrum. Ключевая операция — вызов встроенного метода .Eig() языка MQL5:
//--- Performs Eigendecomposition and generates organized risk factor spectrums void PrintEigenSpectrum() { matrix eigenvectors; vector eigenvalues; //--- Executing native MQL5 OpenBLAS decomposition (Eigenvectors first, then Eigenvalues) if(!m_cov.Eig(eigenvectors, eigenvalues)) { Print("ERROR: Eigenvalue decomposition failed."); return; }
Метод .Eig() вызывается непосредственно для объекта m_cov — того же объекта матрицы, который был создан методом Build() и проверен методом IsSymmetric(). Метод принимает два выходных параметра: матрицу для собственных векторов и вектор для собственных значений. Порядок параметров имеет решающее значение: сначала указываются собственные векторы, затем — собственные значения. Этот порядок определяется встроенным методом .Eig() языка MQL5. Если поменять их местами, код скомпилируется без ошибок, но результат будет бессмысленным: сохранение собственных значений в матрице, а собственных векторов в векторе приведет к несоответствию типов или незаметному повреждению данных.
После успешного вызова eigenvectors представляет собой матрицу, каждый столбец которой содержит один собственный вектор. Столбец с индексом k содержит собственный вектор, соответствующий eigenvalues[k]. Вектор eigenvalues содержит по одному собственному значению на каждый фактор. В совокупности они полностью описывают спектральное разложение m_cov.
Метод .Eig() доступен для симметричных матриц, а правильно вычисленная ковариационная матрица всегда симметрична, что подтверждает наша проверка IsSymmetric(). Он появился с интеграцией OpenBLAS в сборке 4570 MetaTrader 5 и доступен во всех актуальных версиях терминала. Если версия вашего терминала ниже 4570, метод возвращает значение false, и в журнале появится сообщение об ошибке. Обновление MetaTrader 5 до текущей версии сразу же устраняет эту проблему.
Сортировка собственных значений: сначала самый значимый фактор риска
Метод .Eig() не гарантирует какого-либо порядка собственных значений. Чтобы отчет всегда был удобен для чтения и доминирующий фактор риска выводился первым, мы выполняем сортировку с помощью массива индексов:
//--- Initialize index array for sorting risk shares from largest to smallest int idx[]; ArrayResize(idx, n); for(int i = 0; i < n; i++) idx[i] = i; //--- Simple sorting loop (Bubble sort variant for sorting index mappings) for(int i = 0; i < n - 1; i++) for(int j = i + 1; j < n; j++) if(eigenvalues[idx[j]] > eigenvalues[idx[i]]) { int tmp = idx[i]; idx[i] = idx[j]; idx[j] = tmp; }
Мы сортируем массив индексов, а не сам вектор eigenvalues, поскольку собственные векторы и собственные значения связаны: столбец с индексом k матрицы eigenvectors соответствует eigenvalues[k]. Прямая сортировка вектора собственных значений нарушила бы это соответствие — собственное значение в позиции 0 больше не соответствовало бы собственному вектору в столбце 0. Сортируя вместо этого массив индексов, мы обращаемся к eigenvalues[idx[f]] и eigenvectors[s][idx[f]] с использованием одного и того же индекса f, сохраняя связь между каждым собственным значением и соответствующим собственным вектором на всех итерациях цикла вывода отчета.
Вывод отчета о факторах риска
Используя отсортированные индексы, цикл формирует отчет по каждому фактору:
double total_variance = 0.0; for(int i = 0; i < n; i++) total_variance += eigenvalues[i]; PrintDivider("="); Print(" EIGENVALUE SPECTRUM — RISK FACTOR DECOMPOSITION"); PrintDivider(); PrintFormat(" Total Portfolio Variance: %.8f", total_variance); PrintDivider(); //--- Print sorted factors alongside their respective asset loadings for(int f = 0; f < n; f++) { int k = idx[f]; double ev = eigenvalues[k]; double pct = (total_variance > 0) ? (ev / total_variance) * 100.0 : 0.0; PrintFormat(" Factor %d | Eigenvalue: %+.8f | Risk Share: %.2f%%", f + 1, ev, pct); for(int s = 0; s < m_size; s++) PrintFormat(" Loading on %-10s : %+.6f", m_symbols[s], eigenvectors[s][k]); PrintDivider(); }
total_variance — это сумма всех собственных значений. Это математическое свойство спектрального разложения: сумма всех собственных значений ковариационной матрицы равна следу матрицы, который, в свою очередь, равен сумме всех отдельных дисперсий. На практике это означает, что сумма процентных показателей по всем факторам всегда равна 100%, что обеспечивает внутреннюю согласованность отчета. Если сумма процентных значений доли риска (Risk Share) в выводе не равна 100%, значит, при численных расчетах произошла ошибка.
Для каждого фактора f внешний цикл извлекает индекс k из отсортированного массива индексов и вычисляет процентную долю собственного значения в общей дисперсии. Затем внутренний цикл выводит факторную нагрузку каждого торгового инструмента по данному фактору — доступ к ней осуществляется через eigenvectors[s][k], где s — строка торгового инструмента, а k — столбец собственного вектора, соответствующий данному фактору.
Значения факторных нагрузок представляют собой исходные компоненты собственных векторов. Их знак и величина имеют определенное значение. Факторная нагрузка, близкая к +1,0 или -1,0, означает, что торговый инструмент тесно связан с направлением данного фактора. Факторная нагрузка, близкая к 0,0, означает, что торговый инструмент практически ортогонален данному фактору — он почти не участвует в этом направлении риска. Когда два торговых инструмента имеют большие по модулю факторные нагрузки одного знака по одному и тому же фактору, оба инструмента в значительной степени подвержены влиянию одной и той же движущей силы рынка.
И, наконец, проверка концентрации:
//--- Check dominant variance concentration metrics double factor1_pct = (total_variance > 0) ? (eigenvalues[idx[0]] / total_variance) * 100.0 : 0.0; if(factor1_pct > 70.0) PrintFormat(" WARNING: Factor 1 holds %.2f%% of total variance. " "Portfolio is CONCENTRATED.", factor1_pct); else PrintFormat(" RESULT: Risk distributed. Factor 1 = %.2f%% of variance.", factor1_pct);
Порог в 70% — это практическое эмпирическое правило. Когда один фактор объясняет более семидесяти процентов общей дисперсии, портфель по сути является одномерным — все позиции в основном отражают одно и то же базовое движение рынка. Три отдельных показателя волатильности, приведенных в Части 1, создавали видимость независимости. Спектральное разложение устраняет эту видимость и показывает фактическую картину.
Сборка функции OnStart()
Теперь, когда класс готов, функция OnStart() получается лаконичной и понятной:
//+------------------------------------------------------------------+ //| Script entry point | //+------------------------------------------------------------------+ void OnStart() { PrintDivider("="); Print(" COVARIANCE MATRIX PRINTER — Part 2 Script"); Print(" Measuring What Matters: Portfolio Risk Decomposition"); PrintDivider("="); PrintFormat(" Symbols : %s | %s | %s", Symbol1, Symbol2, Symbol3); PrintFormat(" Timeframe: %s", EnumToString(TF)); PrintFormat(" Lookback : %d bars", LookbackBars); PrintDivider(); vector returns[]; ArrayResize(returns, 3); string symbols[3]; symbols[0] = Symbol1; symbols[1] = Symbol2; symbols[2] = Symbol3; //--- 1. Compute return data Print("Step 1: Computing log return series..."); for(int i = 0; i < 3; i++) { if(!ComputeLogReturns(symbols[i], TF, LookbackBars, returns[i])) return; } PrintFormat(" Log returns computed: %d bars per symbol.", LookbackBars); PrintDivider(); //--- 2. Build and verify matrix Print("Step 2: Building covariance matrix..."); CCovarianceMatrix cov_matrix(symbols, 3); if(!cov_matrix.Build(returns, 3)) { Print("ERROR: Could not build covariance matrix. Exiting."); return; } Print(" Matrix built successfully."); //--- Validate structural symmetry properties from outline requirements if(cov_matrix.IsSymmetric()) Print(" Computational Verification: Matrix symmetry test PASSED."); else Print(" WARNING: Structural asymmetry detected."); cov_matrix.PrintMatrix(); //--- 3. Execute decomposition Print("Step 3: Performing eigenvalue decomposition..."); cov_matrix.PrintEigenSpectrum(); PrintDivider("="); Print(" Script complete. See article Part 2 for full breakdown."); PrintDivider("="); } //+------------------------------------------------------------------+
Готовая функция OnStart() сосредоточена на координации операций, а не на их реализации. Она собирает данные о доходности, строит ковариационную матрицу, проверяет ее структуру, выводит матрицу и выполняет спектральное разложение. Каждая основная операция делегируется специальному методу класса, благодаря чему точка входа остается лаконичной и понятной. В функции OnStart() из Части 2 реализован цикл по массиву. Если завтра потребуется добавить четвертый торговый инструмент, достаточно изменить размер массива с 3 до 4 и добавить один входной параметр. Больше ничего не меняется.
Последовательность из трех вызовов методов — Build(), PrintMatrix(), PrintEigenSpectrum() — полностью отражает содержание Части 2 всего в трех строках. Каждый метод выполняет одну задачу. Каждый из них позволяет глубже понять матрицу, полученную с помощью .Cov().
Интерпретация результатов: что означают эти числа
При запуске скрипта CovarianceMatrixPrinter.mq5 на реальном или демо-счете с параметрами по умолчанию в разделе EIGENVALUE SPECTRUM — RISK FACTOR DECOMPOSITION (спектр собственных значений и разложение по факторам риска) будет отображаться информация, по структуре похожая на следующую:

Воспринимайте эти данные как историю — весьма впечатляющую.
Фактор 1 объясняет 91,24% общей дисперсии портфеля. Это не просто предупреждение о некоторой концентрации риска — это означает, что девять десятых всего риска в этом портфеле связаны с одним-единственным базовым фактором. Обратите внимание на факторные нагрузки: факторная нагрузка XAUUSD составляет +0,999938, что практически равно 1,0. Факторная нагрузка EURUSD составляет -0,008212, а GBPUSD — +0,007472; оба значения близки к нулю. Фактор 1 почти целиком связан с золотом. Преобладающая дисперсия XAUUSD, равная +0,00001204, которую мы видели в таблице матрицы выше, настолько велика по сравнению с дисперсиями двух валютных пар, что на нее приходится подавляющая часть бюджета риска портфеля. Эти две валютные пары почти не представлены в факторе 1.
Этот вывод можно сразу использовать на практике. Если трейдер держит равные позиции по EURUSD, GBPUSD и XAUUSD, полагая, что таким образом распределяет риск между тремя инструментами, то спектральное разложение ясно показывает: 91% дисперсии его портфеля приходится на золото. По сравнению с позицией по золоту позиции по этим двум валютным парам практически не влияют на общую картину риска.
Фактор 2 объясняет 7,82% дисперсии. Здесь соотношение факторных нагрузок меняется: для EURUSD факторная нагрузка составляет -0,744238, а для GBPUSD — -0,667914; обе нагрузки значительны и имеют одинаковый знак, тогда как для XAUUSD нагрузка близка к нулю (-0,001121). Фактор 2 — общий фактор движения валютных пар, отражающий общее направление движения доллара США. Можно было бы ожидать, что он будет доминировать, если исключить XAUUSD из портфеля. При наличии в портфеле золота с его гораздо большей дисперсией долларовый фактор отходит на второе место, объясняя менее 8% общего риска.
Фактор 3 объясняет лишь 0,93% дисперсии. Факторная нагрузка EURUSD составляет -0,667864, а GBPUSD — +0,744201: знаки противоположные, а абсолютные величины близки. Это дифференциал EUR/GBP: незначительное расхождение в направлении движения двух валютных пар, когда они не движутся абсолютно синхронно. На этот фактор приходится менее 1% общей дисперсии, поэтому на практике он пренебрежимо мал, но он существует, и спектральное разложение его выявляет.
В Части 2 объясняется, почему именно так происходит: не из-за корреляции между валютными парами, а потому, что волатильность одного инструмента (XAUUSD) настолько выше, чем у остальных, что он доминирует в структуре дисперсии всего портфеля. Это различие имеет огромное значение для определения размера позиции: правильное решение — не снижать корреляцию, а уменьшать размер позиции по золоту относительно позиций по валютным парам, пока распределение долей риска между факторами не станет приемлемым для трейдера.
Что это означает на будущее
Это имеет прямое практическое значение для определения размера позиции. Фактор 1 объясняет 91,24% дисперсии портфеля и почти полностью определяется XAUUSD, факторная нагрузка которого составляет +0,999938. Равные веса трех торговых инструментов означают, что вы неявно выделили более 91% своего фактического бюджета риска на один-единственный фактор, определяемый движением золота. Хотя две позиции по валютным парам выглядят как отдельные вложения, в совокупности на них приходится менее 9% общей дисперсии портфеля. XAUUSD не способствует диверсификации портфеля — он в нем доминирует. Правильное решение — значительно уменьшить размер позиции по золоту относительно позиций по валютным парам, пока доли риска факторов не достигнут баланса, который трейдер сможет осознанно обосновать.
В Частях 5 и 6 этой серии мы будем напрямую использовать собственные векторы для расчета весов позиций, распределяя риск по направлениям независимых факторов, а не поровну между торговыми инструментами. Класс CCovarianceMatrix, созданный в этой статье, станет компонентом, который мы будем импортировать в примерах из этих частей. Сохраненный здесь результат вызова .Eig() станет входными данными для расчета весов в тех частях.
На данный момент самый важный показатель в этом выводе — доля риска фактора 1. Значение выше 70% означает, что ваш портфель концентрирован: его диверсификация слабее, чем предполагается при определении размера позиции. Значение ниже 50% означает, что ваши торговые инструменты обеспечивают значимые независимые направления риска. Этот показатель — доля доминирующего собственного значения в общей дисперсии — является наиболее информативным показателем риска, получаемым в рамках данной серии, и он полностью обусловлен структурой матрицы, представленной в Части 2.
Заключение
Часть 2 развивает основы, заложенные в предыдущей статье, превращая ковариационную матрицу из промежуточного результата вычислений в объект, который можно изучать, проверять и подвергать разложению. С помощью класса CCovarianceMatrix матрица сохраняется, выводится в виде таблицы с подписями, проверяется на симметричность и анализируется с помощью встроенного метода .Eig() для выявления независимых факторов, определяющих риск портфеля.
Результат — это нечто большее, чем просто расчет ковариации. Матрица становится интерпретируемым представлением структуры портфеля, позволяя трейдерам увидеть вклад каждого независимого фактора в общую дисперсию и факторные нагрузки каждого торгового инструмента.
Функция ComputeLogReturns, перенесенная без изменений из Части 1, — это не просто удобный инструмент, а слой данных, на котором построена вся эта серия статей. Класс CCovarianceMatrix, представленный в Части 2, — это не просто более аккуратный код, а повторно используемый компонент, который будет напрямую импортироваться в Частях 3-10. Спектр собственных значений, выводимый PrintEigenSpectrum, — это не просто отчет в журнале: он впервые позволяет читателю увидеть названия и количественные оценки факторов, лежащих в основе риска его портфеля.
В Части 3 мы подвергнем полученные здесь собственные значения и собственные векторы строгой математической проверке. Используя спектральную теорему — A = V Λ Vᵀ, — мы пишем скрипт EigenRecomposer.mq5, который принимает собственные векторы и собственные значения, полученные при разложении в Части 2, строит диагональную матрицу Λ с помощью метода matrix.Diag(), вычисляет полное произведение трех матриц V × Λ × Vᵀ с помощью методов .MatMul() и .Transpose(), а затем вычитает результат из исходной ковариационной матрицы. Остаток должен равняться абсолютному нулю (ошибка восстановления на уровне 1×10⁻¹⁵), что доказывает, что три фактора, выделенные в Части 2, полностью отражают структуру риска портфеля без потери данных.
Прилагаемый файл: CovarianceMatrixPrinter.mq5
Далее: Часть 3 — Механизм восстановления: проверка "следов риска" с помощью матричной алгебры
Перевод с английского произведен MetaQuotes Ltd.
Оригинальная статья: https://www.mql5.com/en/articles/23314
Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.
Данная статья написана пользователем сайта и отражает его личную точку зрения. Компания MetaQuotes Ltd не несет ответственности за достоверность представленной информации, а также за возможные последствия использования описанных решений, стратегий или рекомендаций.