Внутри нашего «фирменного» алгоритма: HRP + long/short + CVaR по Халлу–Уайту

В обзоре «12 алгоритмов оптимизации портфеля» мы прогнали дюжину методов аллокации бок о бок. Одиннадцать из них — классика из литературы. Двенадцатый, Pipeline, — наш собственный, и в обзоре ему досталась всего одна строчка. Эта статья — подробный разбор: что у него внутри, откуда берётся каждая формула и как спецификация превращается в код на Rust.

Pipeline не изобретает новый способ считать веса. Он берёт самый устойчивый из известных приёмов — Hierarchical Risk Parity (HRP) — и оборачивает его двумя слоями, которые нужны на реальном торговом счёте, но которых нет в чистом HRP: направленностью (long/short по сигналам стратегии) и жёстким бюджетом риска (CVaR с поправкой на текущий режим волатильности). Получается четыре стадии.

Четыре стадии

• I — лог-доходности всех активов.
• II — базовые веса по HRP.
• III — разбиение на long/short по сигналам агента, с долями риска по уверенности.
• IV — коррекция через CVaR с волатильностью по Халлу–Уайту; излишек риска уходит в кэш.

Разберём по порядку.

Стадия I. Лог-доходности

Всё начинается с перехода от цен к логарифмическим доходностям:

$r_{i,t} = \ln\!\left(\frac{S_{i,t}}{S_{i,t-1}}\right)$

где $i$ — актив, $t$ — момент времени. Лог-ретёрны складываются во времени и симметричнее обычных процентных изменений — стандартный вход для любой ковариационной математики.

Стадия II. HRP как фундамент

HRP, предложенный Маркосом Лопесом де Прадо в 2016 году, обходит главную болезнь Mean-Variance Optimization — обращение плохо обусловленной ковариационной матрицы. Он вообще её не обращает. Вместо этого работает со структурой корреляций.

Ковариация и корреляция

Из доходностей строим ковариационную матрицу $\Sigma$ и нормируем её до корреляционной $C$:

$\Sigma_{i,j} = \mathrm{Cov}(r_i, r_j), \qquad C_{i,j} = \rho_{i,j} = \frac{\mathrm{Cov}(r_i, r_j)}{\sigma_i \sigma_j}$

Матрица расстояний

Корреляцию превращаем в метрику расстояния — так, чтобы сильно скоррелированные активы оказались «близко»:

$d_{i,j} = \sqrt{\frac{1 - \rho_{i,j}}{2}}$

Чем ближе $\rho_{i,j}$ к 1, тем ближе $d_{i,j}$ к 0 — и тем вероятнее активы попадут в один кластер.

Дендрограмма и порядок листьев

По матрице расстояний строим иерархию кластеров через average linkage и снимаем с дендрограммы порядок листьев $\pi = (\pi_1, \ldots, \pi_N)$ — перестановку активов, в которой похожие стоят рядом.

Опциональный шаг: оптимальное число кластеров можно подбирать по коэффициенту силуэта $s_i = \dfrac{b_i - a_i}{\max(b_i, a_i)}$, где $a_i$ — среднее расстояние внутри кластера, $b_i$ — до ближайшего соседнего. В базовом проходе он не нужен — рекурсивное деление само уважает иерархию.

Квазидиагонализация

Переставляем строки и столбцы $\Sigma$ в порядке $\pi$, собирая большие значения вдоль диагонали:

$\Sigma^{q}_{i,j} = \Sigma_{\pi_i, \pi_j}$

Рекурсивное деление

Дальше — рекурсия сверху вниз. На каждом шаге кластер делится пополам на $L$ и $R$, и капитал между половинами распределяется обратно пропорционально их дисперсиям:

$w_L = \frac{1/\sigma_L^2}{\dfrac{1}{\sigma_L^2} + \dfrac{1}{\sigma_R^2}}, \qquad w_R = 1 - w_L$

Дисперсия кластера считается на его подматрице ковариаций как $\sigma_C^2 = \tfrac{1}{m^2}\sum_{i,j \in C}\Sigma^{q}_{i,j}$. Спуск продолжается, пока в каждом узле не останется один актив. Веса только длинные, неотрицательные, в сумме 1.0.

В нашей реализации это функция hrp_from_cov(cov) -> Vec<f64>: корреляция → расстояние → average linkage → порядок листьев → квазидиагонализация → рекурсивное деление. Именно её Pipeline вызывает как базу — и она же является публичным optimize() для случая без сигналов.

Стадия III. Long/short-оверлей

Чистый HRP — портфель «только купить». Но стратегия часто говорит не только сколько, но и в какую сторону. Стадия III принимает от агента сигналы (Long/Short) по каждому активу и строит два подпортфеля.

1. Активы делятся на long- и short-корзины по сигналам.
2. Внутри каждой корзины веса считаются тем же HRP (на подматрице ковариаций соответствующих активов), сумма по корзине — 1.
3. Если агент выдаёт ещё и уверенность $p_i$, доли риска между сторонами задаются суммарной уверенностью:

$\xi_L = \sum_{i \in L} p_i, \quad \xi_S = \sum_{i \in S} p_i, \qquad \lambda_L = \frac{\xi_L}{\xi_L + \xi_S}, \quad \lambda_S = \frac{\xi_S}{\xi_L + \xi_S}$

Без уверенности доли падают обратно на количество активов в каждой корзине. Итоговый знаковый вес: $w_i = \lambda_L \cdot w_i^{\text{HRP}}$ для long и $w_i = -\lambda_S \cdot w_i^{\text{HRP}}$ для short, после чего вся валовая экспозиция нормируется к 1.

Честная пометка о коде. В исходной спецификации фигурируют поправочные коэффициенты $\alpha_L = \sqrt{\lambda_L}/\sigma_L$, $\alpha_S = \sqrt{\lambda_S}/\sigma_S$ — но там же стоит вопрос «нужен ли этот шаг?». В реализации мы их не применяем: стороны комбинируются напрямую через доли риска $\lambda$, что держит валовую экспозицию ровно на 1 и не создаёт скрытого плеча. Это сознательное упрощение спеки, а не недосмотр.

Стадия IV. CVaR с поправкой Халла–Уайта

HRP балансирует риск структурно, но ничего не знает про абсолютный уровень риска в деньгах. Последняя стадия ставит жёсткий потолок на хвостовой риск — и делает его чувствительным к смене рыночного режима.

Доходность портфеля и EWMA-волатильность

Сначала сворачиваем веса в доходность портфеля и оцениваем условную волатильность по EWMA:

$r_{p,t} = \sum_{i=1}^{n} w_i\, r_{i,t}, \qquad \sigma_{p,t}^2 = \lambda\, \sigma_{p,t-1}^2 + (1 - \lambda)\, r_{p,t-1}^2$

с $\lambda = 0.94$ (классическое значение RiskMetrics). EWMA даёт «сегодняшнюю» волатильность, а не усреднённую по всей истории.

Перешкалирование по Халлу–Уайту

Ключевая идея: прошлые доходности нельзя брать как есть — они получены при другой волатильности. Метод Халла–Уайта масштабирует каждую прошлую доходность к текущему уровню:

$\widetilde{r}_{p,s} = \frac{\sigma_{p,t+1}}{\sigma_{p,s}}\, r_{p,s}, \qquad s = t - N + 1, \ldots, t$

Спокойный месяц «растягивается», бурный — «сжимается», и распределение приводится к текущему режиму.

VaR и CVaR

По перешкалированному распределению берём квантиль убытков и средний убыток в хвосте:

$VaR_\alpha^{HW} = -q_{1-\alpha}(\widetilde{r}_p)$

$CVaR_\alpha^{HW} = -\mathbb{E}\!\left[\widetilde{r}_p \mid \widetilde{r}_p \le q_{1-\alpha}(\widetilde{r}_p)\right]$

CVaR (он же Expected Shortfall) отвечает не «насколько плохо в типичный плохой день», а «насколько плохо в среднем по худшим $\alpha$ процентам» — то есть видит толщину хвоста, а не только его край.

Бюджет риска и кэш

Если CVaR превышает допустимый порог, все рискованные позиции ужимаются одним коэффициентом, а высвободившийся капитал уходит в кэш:

$w_i^{new} = \gamma\, w_i, \quad \gamma = \frac{CVaR_{\max}}{CVaR_\alpha^{HW}}, \qquad w_{cash} = 1 - \sum_{i=1}^{n} |w_i^{new}|$

Так портфель сам себя «обналичивает» при росте хвостового риска и снова входит в рынок, когда тот успокаивается.

От спецификации к коду

Весь алгоритм живёт в одном Rust-крейте portfolio-pipeline и подчиняется общему контракту воркспейса:

pub fn optimize(prices: &[Vec<f64>]) -> Vec<f64>

Это long-only-проекция (стадии I, II, IV без сигналов) — ровно тот же интерфейс цены -> веса, что и у остальных одиннадцати алгоритмов, поэтому Pipeline взаимозаменяем с ними в любом коде. Полная версия со всеми стадиями — отдельная функция:

pub fn run(
    prices: &[Vec<f64>],
    signals: Option<&[Side]>,      // Long / Short по каждому активу
    confidence: Option<&[f64]>,    // уверенность агента → доли риска λ
    cfg: &PipelineConfig,          // параметры CVaR/Hull-White
) -> PipelineResult                // знаковые веса + cash + cvar + σ

Параметры оверлея по умолчанию: хвост cvar_alpha = 0.05, бюджет cvar_max = 0.05, EWMA ewma_lambda = 0.94, окно Халла–Уайта hw_window = 0 (вся история). Реализация без внешних зависимостей и сознательно «защищённая»: на коротких историях (менее 4 точек цен) она отдаёт равные веса, а CVaR-оверлей включается только при ≥8 наблюдениях доходности — иначе хвост оценивать не на чем.

Почему Rust: единый детерминированный код для бэктеста и для продакшена, без расхождения «питон в ресёрче — что-то другое в бою», и достаточно быстрый, чтобы гонять все двенадцать алгоритмов на одном запросе через бэкенд сравнения.

Сколько это стоит по времени

«Достаточно быстрый» — это сколько? Мы вынесли ядро HRP (лог-ретёрны → ковариация → average linkage → квазидиагонализация → рекурсивные веса) в отдельный бенчмарк и прогнали одну и ту же математику на C, Rust и Node.js. Условия одинаковые: Apple Silicon, один поток, 365 дневных наблюдений на актив, синтетические цены. В таблице — полное время прохода (TOTAL) в зависимости от числа активов $N$.

Что отсюда видно:

• На реалистичных портфелях это бесплатно. Криптокорзина — это десятки активов, редко больше сотни. На $N \le 100$ полный проход HRP занимает единицы миллисекунд даже в Node и микросекунды в Rust/C. Пересчитывать веса хоть на каждом тике — не проблема.
• Rust в пределах ~1.3–1.6× от C — тот же порядок, оба компилируемые. C немного быстрее на «голой» арифметике, но Rust даёт ту же предсказуемость без сборщика мусора и без UB.
• Node удивительно держится. На малых $N$ он в ~30–50× медленнее C из-за интерпретации, но с ростом $N$ всё съедает $O(N^3)$-линкедж, и разрыв схлопывается: на $N = 2000$ Node (2.97 с) лишь вдвое медленнее C (1.53 с).
• Узкое место — average linkage, $O(N^3)$. Именно он, а не выбор языка, определяет масштабирование: на $N = 5000$ C считает ~20 с, Rust ~33 с (Node на таких размерах уже неуместен). Для портфелей реального размера это неважно, но для тысяч активов первым делом меняют не язык, а алгоритм кластеризации.

Вывод прагматичный: при наших размерах портфеля выбор Rust — это не про «обогнать C» (C тут чуть быстрее), а про один детерминированный код для ресёрча и продакшена, без GC-пауз и с запасом по скорости на годы вперёд. Сам бенчмарк (C / Rust / Node, и порт на Zig) лежит открыто в репозитории проекта.

Где Pipeline в общем зачёте

В нашем сравнении на одной (намеренно «подстроенной») корзине Pipeline вёл себя как HRP — потому что через long-only-вход optimize() он и есть HRP с CVaR-надстройкой. Его направленная машинерия оживает только тогда, когда его кормят сигналами стратегии. Это и есть главная мысль: Pipeline — не «ещё один оптимизатор для бэктеста весов», а исполнительный слой между сигналами стратегии и реальными ордерами: он берёт ваши «купить/продать», раскладывает капитал по HRP внутри каждой стороны, балансирует стороны по уверенности и обрезает хвостовой риск до заданного бюджета.

Полный контекст — какие ещё одиннадцать методов существуют и чем они отличаются — в обзорной статье «12 алгоритмов оптимизации портфеля». А пощупать всё вживую можно на portfolio-optimizer.marketmaker.cc.

Источники

1. López de Prado, M. (2016). Building Diversified Portfolios that Outperform Out of Sample. The Journal of Portfolio Management.
2. López de Prado, M. (2018). Advances in Financial Machine Learning. Wiley.
3. Hull, J., & White, A. (1998). Incorporating Volatility Updating into the Historical Simulation Method for Value at Risk. Journal of Risk.
4. Rockafellar, R. T., & Uryasev, S. (2000). Optimization of Conditional Value-at-Risk. Journal of Risk.
5. RiskMetrics Group (1996). RiskMetrics — Technical Document. J.P. Morgan.
6. Marketmaker.cc: marketmaker.cc

Citation

@article{soloviov2026pipeline,
  author = {Soloviov, Eugen and Zhuravleva, Marina and Kiselev, Kirill},
  title = {Inside Our House Algorithm: HRP + Long/Short + CVaR with Hull-White Adjustment},
  year = {2026},
  url = {https://marketmaker.cc/ru/blog/post/portfolio-pipeline-hrp-cvar},
  description = {A deep dive into Pipeline, a composite portfolio allocation algorithm built on Hierarchical Risk Parity with a signal-driven long/short overlay and a Hull-White CVaR risk-budget correction, with the full specification and its Rust implementation.}
}