Нейросети в трейдинге: AlphaGen — поиск торговых факторов (реализация пула)
Введение
Когда рынок закрывается выше скользящей средней, это ещё не означает продолжения роста. Отклонение цены от средней может быть полезным признаком, но рядом с другими индикаторами его вклад меняется. AlphaGen позволяет искать такие признаки в виде формул и оценивать не каждый из них отдельно, а результат их совместной работы. Именно поиск дополняющих друг друга факторов составляет основу авторского фреймворка.
В первой статье мы рассмотрели авторский алгоритм и начали перенос его компонентов в MetaTrader 5: задали словарь токенов, правила построения формул и маску допустимых продолжений. Во второй статье реализовали генерацию и расчёт выражений средствами OpenCL. На закрытых барах получили пятибарную среднюю и отклонение цены закрытия от неё, а также научились отличать действительный ноль фактора от пропуска из-за нехватки истории.
Следующий этап — пул факторов: он хранит отобранные формулы, оценивает предложения генератора и передаёт торговой модели историю взвешенного сигнала. Состоянием управляет класс MQL5 CAlphaGenPool, а повторяющиеся расчёты по барам выполняются в OpenCL. Здесь реализуем пул; обучение политик и исполнение сделок рассмотрим отдельно.

Устройство пула факторов
Возьмём два фактора: в пуле уже есть пятибарная средняя, а генератор предлагает отклонение закрытия от неё. Оба опираются на одни и те же цены и могут дублировать информацию. Даже высокий индивидуальный IC не показывает, улучшит ли кандидат общий прогноз: веса комбинации нужно подбирать заново. Пока идёт поиск, торговая модель получает сигнал от прежнего состава. Поэтому в нашей адаптации подготовленный пул для поиска и действующий пул для наблюдений разделены.
В составном слое CNeuronAlphaGenOCL объект пула хранится в поле m_cPool. Слой передаёт ему рынок и предложения генератора. Рыночное окно состоит из пяти рядов одинаковой длины: Open, High, Low, Close и тикового объёма. MQL5 отвечает за состояние компонента и порядок вызовов. OpenCL многократно вычисляет формулы на барах, не перекладывая управление торговыми событиями на кернелы.
class CAlphaGenPool { protected: COpenCLMy *OpenCL; CBufferFloat m_cConfig,m_cBanks,m_cWork,m_cRings,m_cControl; //--- Transient per-batch formula cache; deliberately not serialized. CBufferFloat m_cEvaluationWork,m_cEvaluated; CBufferFloat m_cSignal,m_cContext,m_cPreparedSignal,m_cPreparedContext,m_cDummy; int m_iWindow,m_iTokens,m_iCapacity,m_iIC,m_iNorm,m_iContext; int m_iBankSize,m_iRingSize,m_iWorkSize,m_iLookback;
Размер рабочего окна задаёт метод Configure. Некоторые целочисленные параметры помещены в общий конфигурационный буфер типа float. Поэтому перед выделением памяти проверяем их диапазон и отсутствие дробной части. Иначе некорректная длина окна превратится в адрес элемента.
for(int i=AG_CFG_W;i<=AG_CFG_CONTEXT;i++) if(config[i]!=(float)(int)config[i]) ReturnFalse; m_iLookback=(int)config[AG_CFG_LOOKBACK]; m_iWindow=(int)config[AG_CFG_W];m_iTokens=(int)config[AG_CFG_MAX_TOKENS]; m_iCapacity=(int)config[AG_CFG_POOL]+1;m_iIC=(int)config[AG_CFG_IC_WINDOW]; m_iNorm=(int)config[AG_CFG_NORM_WINDOW];m_iContext=(int)config[AG_CFG_CONTEXT];
Для оценки кандидатов нужны бары предыстории, участок сопоставления факторов с будущей доходностью и горизонт прогноза. Для действующего сигнала — предыстория и окно нормировки совокупного ряда. Часть этих данных общая. Поэтому длину выбираем по большей потребности после добавления предыстории, а не суммируем два окна.
if(m_iLookback<0 || m_iWindow<1 || m_iTokens<2 || m_iCapacity<2 || m_iIC<2 || m_iNorm<2 || m_iContext<1 || config[AG_CFG_HORIZON]<1 || config[AG_CFG_RIDGE]<=0 || config[AG_CFG_SIGNAL_CLIP]<=0 || config[AG_CFG_EPS_VAR]<=0 || m_iWindow<config[AG_CFG_LOOKBACK]+MathMax(m_iIC+config[AG_CFG_HORIZON],m_iNorm) || bank*4>INT_MAX || ring*2>INT_MAX || work>INT_MAX) ReturnFalse;
В рабочей конфигурации формуле разрешено обращаться на 120 баров назад. Оценку выполняем по 256 наблюдениям, а целевую доходность рассчитываем через один бар. Минимально нужны 377 закрытых баров: 120 + 256 + 1. Окно рынка из 512 баров удовлетворяет этому условию. Происхождение и назначение размеров сведём в таблицу: они задают расчёт, но сами по себе не подтверждают оптимальность выбора.
| Параметр | Значение | Роль и происхождение |
|---|---|---|
| AG_CFG_W | 512 баров | Размер окна котировок; степень двойки, выбранная для рабочей конфигурации, а не найденный оптимум. |
| AG_CFG_LOOKBACK | 120 баров | Технический предел глубины истории для формул, не горизонт прогноза. |
| AG_CFG_IC_WINDOW, AG_CFG_HORIZON | 256 баров, 1 бар | Количество пар фактор–цель и горизонт последующей доходности; параметры статистической постановки. |
| AG_CFG_NORM_WINDOW, AG_CFG_CONTEXT | 256, 256 | Длина нормировки общего сигнала и последовательность входов модели. Размеры — степени двойки, но алгоритм не требует считать их оптимальными. |
| AG_CFG_POOL, AG_CFG_MAX_TOKENS | 20, 20 | Предел числа опубликованных факторов и длины формулы; технические ограничения поиска и памяти. |
| AG_CFG_RIDGE | Из config, строго > 0 | Коэффициент λ регуляризации весов. Не задан в тексте кернела; выбранное значение нужно фиксировать в настройках опыта. |
| AG_CFG_EPS_VAR | Из config, строго > 0 | Порог непригодной дисперсии после численного масштабирования. Его выбирают с учётом FP32 и фиксируют вместе с λ. |
Последовательности токенов достаточно, чтобы снова вычислить формулу. Но у признаков разные единицы измерения: средняя выражена в цене, отклонение — также в цене, а другие формулы могут возвращать относительные величины. Применять к ним найденные веса без согласованного масштаба нельзя. Поэтому вместе с формулой храним идентификатор, её длину, статистику стандартизации, статус, число пригодных наблюдений и коэффициент в общей сумме. На новом баре используем сохранённое преобразование, не заглядывая в будущую доходность.
Место под токены резервируем по предельной длине выражения. Поэтому адрес записи можно найти по номеру фактора. При перестановке записи вес и параметры стандартизации перемещаются вместе с формулой.
long bank=10+(long)m_iCapacity*(13+m_iTokens); long ring=11+(long)m_iNorm+m_iContext; long stack=(long)m_iWindow*m_iTokens; long work=stack+MathMax(stack,3*(m_iTokens+1))+4*(long)m_iWindow+m_iIC+7+ (long)m_iCapacity*m_iIC+(long)m_iCapacity*(m_iCapacity+1)+m_iCapacity+3+m_iWindow;
Заголовок каждого банка содержит число формул, следующий идентификатор, версию и признак готовности весов. Идентификаторы разбиваем на части, которые точно представимы типом float. Так при перестановке записи коэффициент остаётся связан с нужной формулой, а публикация не путает действующую версию с подготовленной.
Если пул содержит 20 факторов, для оценки нового предложения нужен временный 21-й слот. Поэтому внутренняя ёмкость m_iCapacity на единицу больше ограничения опубликованного состава. Для предела в 20 токенов одна запись занимает 13 + 20 = 33 элемента float. Заголовок банка занимает ещё 10 элементов, поэтому полный банк содержит 10 + 21 × 33 = 703 элемента. Это расчёт адресов буфера, а не результат подбора торговых параметров.
Четыре области буфера m_cBanks имеют одинаковый размер. При указанной конфигурации их границы легко проверить по смещениям в таблице. Они отсчитываются от начала буфера, с нуля, в элементах типа float.
| Смещение | Содержимое | Назначение области |
|---|---|---|
| 0 | Подготовленный пул | Формулы и веса, с которыми начнётся оценка следующего кандидата. |
| 703 | Действующий пул | Опубликованный набор для расчёта наблюдений торговой модели. |
| 1406 | Рабочая копия | Пробное добавление формулы, подбор весов и удаление записи при переполнении. |
| 2109 | Состав для публикации | Зафиксированный набор, для которого отдельно подготавливается история сигнала. |
У действующего банка число формул находится по смещению 703, у подготовленного — по смещению 0. Во время поиска эти значения могут различаться: новая формула ещё оценивается, а торговый сигнал строится по прежнему составу. Адреса областей задаём при настройке.
m_iBankSize=(int)bank;m_iRingSize=(int)ring;m_iWorkSize=(int)work; if(!m_cConfig.AssignArray(config) || !m_cConfig.BufferCreate(OpenCL) || !Allocate(m_cBanks,4*m_iBankSize) || !Allocate(m_cRings,2*m_iRingSize) || !Allocate(m_cWork,m_iWorkSize) || !Allocate(m_cControl,AG_POOL_CONTROL_SIZE) || !Allocate(m_cSignal,1) || !Allocate(m_cContext,m_iContext) || !Allocate(m_cPreparedSignal,1) || !Allocate(m_cPreparedContext,m_iContext) || !Allocate(m_cDummy,1)) ReturnFalse;
Для каждой версии отдельно храним кольцевое окно взвешенных сумм для нормировки и историю готовых входов модели. История новой версии заполняется при подготовке состава. Это расширение AlphaGen для событийной работы советника: оно не повышает IC само по себе, но не позволяет смешивать наблюдения с разными весами.
Интерфейс класса следует этой последовательности. Candidate получает одну формулу, CommitSearchBatch — пакет; Prepare и PrepareAppend рассчитывают историю следующей версии, после чего Commit делает её действующей. Signal возвращает последнее значение, Context — историю для торговой модели. До публикации подготовленные результаты можно читать отдельно через StagedSignal и StagedContext.
bool Observe(CBufferFloat *market) {return(SignalStep(market,0));} bool Warmup(CBufferFloat *market,const bool first=false) {return(SignalStep(market,1,first));} CBufferFloat *Control(void) {return(GetPointer(m_cControl));} CBufferFloat *Signal(void) {return(GetPointer(m_cSignal));} CBufferFloat *Context(void) {return(GetPointer(m_cContext));} CBufferFloat *StagedContext(void) {return(GetPointer(m_cPreparedContext));} CBufferFloat *StagedSignal(void) {return(GetPointer(m_cPreparedSignal));}
При сохранении модели метод Save записывает размеры и содержимое банков, кольцевых историй и управляющих полей. Промежуточные значения формул последнего пакета к модели не относятся: они зависят от конкретного окна и при необходимости рассчитываются снова. Поэтому временные буферы не раздувают сохраняемый файл.
При загрузке Load сверяет размеры областей, восстанавливает банки и кольцевые буферы и затем проверяет записи формул: длины, завершающий AG_STOP и уникальность идентификаторов. Приведённый фрагмент иллюстрирует чтение областей.
uint bank=0,ring=0; dFileReadUInt(file_handle,bank) dFileReadUInt(file_handle,ring) if(bank!=(uint)m_iBankSize || ring!=(uint)m_iRingSize) ReturnFalse;
Обработка пакета кандидатов
Пакет законченных формул поступает в CommitSearchBatch. Каждый кандидат оценивается вместе с уже отобранными факторами. В исходном AlphaGen IC рассчитывали по акциям одной даты, а затем усредняли по датам. Для одного инструмента поперечного среза нет: мы сопоставляем факторы с последующей доходностью по времени на закрытых барах. Поэтому временной IC не эквивалентен исходному поперечному IC по акциям.
Все кандидаты получают одно рыночное окно market. В candidates лежат длины формул и их токены, а также сведения, которые позднее понадобятся при обучении генератора: логарифм вероятности выбранного действия, энтропия, оценка и маска допустимых токенов. Кернел вычисления читает операции из этой записи с учётом полного шага токена.

Для будущего обучения генератора сохраняем префиксы формул, маски, выбранные токены и переходы. Параметр first_row указывает следующую свободную строку. Перед запуском проверяем границы буферов, чтобы переходы разных эпизодов не перезаписывали друг друга.
long capacity_check=samples.Total(); if(first_row>=capacity_check || (long)market.Total()<5*(long)m_iWindow || (long)candidates.Total()<(long)count*(1+(long)m_iTokens*(4+AG_VOCABULARY)) || (long)prefixes.Total()<capacity_check*(m_iTokens+1) || (long)masks.Total()<capacity_check*AG_VOCABULARY || (long)metadata.Total()<capacity_check*7 || (long)gae.Total()<capacity_check*AG_GAE_FIELDS || (long)summary.Total()<4+AG_POOL_CONTROL_SIZE+(long)count*m_iTokens) ReturnFalse;
Поскольку формулы независимо вычисляются по одним барам, каждой отводим отдельный стек. После вычисления сохраняем два ряда на кандидата: значения и статусы. Без статусов нулевой результат допустимой формулы легко спутать с отсутствием истории и исказить IC.
Размер рабочей группы OpenCL выбираем по ограничениям устройства и двух кернелов. В этой реализации для редукции требуется степень двойки, не более 64 рабочих элементов. Это техническое ограничение параллельного расчёта, а не результат поиска наиболее быстрого размера. Ускорение относительно других вариантов без измерений не утверждаем.
long kernel_limit=OpenCL.GetKernelInfoInteger(def_k_AGPoolEvaluateBatch,CL_KERNEL_WORK_GROUP_SIZE); long commit_limit=OpenCL.GetKernelInfoInteger(def_k_AGPoolCommitBatch,CL_KERNEL_WORK_GROUP_SIZE); long lane_limit=MathMin(OpenCL.GetMaxWorkGroupSize(),OpenCL.GetMaxLocalSize(0)); lane_limit=MathMin(lane_limit,MathMin(kernel_limit,commit_limit)); if(lane_limit<1) ReturnFalse; //--- Tree reductions in commit use a power-of-two group, at most 64 lanes. uint lanes=1; while(lanes<64 && 2*(long)lanes<=lane_limit) lanes*=2; if((long)count*lanes>UINT_MAX) ReturnFalse; uint eval_offset[]={0},eval_global[]={(uint)count*lanes},eval_local[]={lanes};
В AGPoolEvaluateBatch одна рабочая группа обрабатывает одну формулу в собственном стеке. Результат получает отдельные места под значения и статусы. Внутри используем AGFormulaEvaluate из предыдущей статьи. Мы не меняем вычислительный примитив — лишь запускаем его для кандидатов параллельно.
int candidate=(int)get_group_id(0); if(candidate>=batch) return; // Uniform for the whole group, before barriers. int w=(int)cfg[AG_CFG_W],t=(int)cfg[AG_CFG_MAX_TOKENS]; int stride=4+AG_VOCABULARY; size_t work_stride=(size_t)w*t+max(w*t,3*(t+1)); __global const float *packed=candidates+(size_t)candidate*(1+(size_t)t*stride); __global float *stack=workspace+(size_t)candidate*work_stride; __global float *result=evaluated+(size_t)candidate*2*w; __local int syntax; AGFormulaEvaluate(market,packed+1,(int)packed[0],cfg,stack,stack+w*t, result,result+w,stride,&syntax);
Ряды для всех формул уже рассчитаны. Но применять кандидатов одновременно нельзя: принятие первой формулы меняет набор, с которым сравниваем вторую. Поэтому AGPoolCommitBatch обрабатывает предложения по очереди, а перед следующим вызовом дожидаемся завершения предыдущего. Идея оценки фактора в составе набора принадлежит AlphaGen; параллельный расчёт рядов и последовательная фиксация решений — способ выполнить этот этап в OpenCL без повторного вычисления каждой формулы.
uint offset[] = { 0 }, global[] = { lanes }, local[] = { lanes }; for(int candidate=0; candidate<count; candidate++) { offset[0]=(uint)candidate*lanes;
Вызов Execute только ставит кернел в очередь. Метод WaitAlphaGenKernel подтверждает его завершение до начала следующей операции. Затем читаем summary: общий статус сообщает, завершился ли пакет штатно, а summary[1] содержит число действительно рассмотренных кандидатов. Оно может быть меньше размера пакета, если достигнута ёмкость учебных переходов. Параллельно вычислить все ряды ещё не значит рассмотреть все формулы.
bool queued=OpenCL.Execute(def_k_AGPoolCommitBatch,1,offset,global,local); int enqueue_error=GetLastError(); ulong enqueue_us=GetMicrosecondCount()-started; bool complete=queued && OpenCL.WaitAlphaGenKernel(def_k_AGPoolCommitBatch);
Прежде чем добавлять новую формулу, подбираем веса уже подготовленного пула на текущем историческом окне. AGPoolCandidateGroup копирует его в рабочую область, а AGPoolFitGroup рассчитывает базовый IC — baseline_ic. Сравнивать кандидата с оценкой прежнего окна было бы ошибкой: рыночная история сдвигается и сама меняет корреляцию.
Для расчёта задаём длину окна W, число наблюдений N и горизонт доходности H. Начальная строка равна offset = W − H − N. При W = 512, N = 256 и H = 1 значения факторов берём на барах 255–510. Закрытие бара 511 используется как последующая цена для последнего наблюдения, но не как вход его формулы. Для самого бара 511 будущей цены в этом окне нет.
for(int i=offset+lane;i<w-h;i+=lanes) { float p=market[3*w+i],q=market[3*w+i+h]; if(!(p>0.0f) || !(q>0.0f) || !isfinite(p) || !isfinite(q)) invalid=1.0f; target[i]=q/p-1.0f; tv[i]=isfinite(target[i])?AG_OK:AG_TECHNICAL; } invalid=AGPoolReduce(invalid,reduce,1); barrier(CLK_GLOBAL_MEM_FENCE); if(invalid>0.0f) return AG_TECHNICAL; AGPoolStandardizeGroup(target,tv,offset,n,cfg,y,yst,reduce); if(yst[5]!=AG_OK) return AG_SKIP;
Делим цену закрытия через H баров на закрытие исходного бара и вычитаем единицу. Обе цены должны быть конечными и строго положительными. При нарушении условия прерываем расчёт с техническим статусом. Стандартизируем полученные доходности по выбранным N наблюдениям. Если весь ряд постоянен, оценить корреляцию с ним нельзя. Функция возвращает AG_SKIP ещё до подбора весов.
Затем собираем значения всех факторов на тех же барах. Для кандидатов, чьи ряды уже рассчитаны, читаем evaluated. Остальные формулы вычисляем через AGFormulaEvaluate. Совпадение ищем по токенам, поскольку положение формулы в пакете не обязано совпадать с её местом в пуле.
int cached=shared[1]; if(cached>=0) { __global const float *values=evaluated+(size_t)cached*2*w; for(int i=lane;i<w;i+=lanes) { raw[i]=values[i]; status[i]=values[w+i]; } barrier(CLK_GLOBAL_MEM_FENCE); } else { AGFormulaEvaluate(market,record+5,(int)record[0],cfg,stack,valid,raw,status,1,shared); barrier(CLK_GLOBAL_MEM_FENCE); } AGPoolStandardizeGroup(raw,status,offset,n,cfg,z+j*n,record+5+t,reduce);
Пригодность проверяем для каждого значения на общих N барах. Нельзя выкинуть пропуски в одном столбце отдельно: нарушится соответствие по времени и корреляция потеряет смысл. Старые бары служат запасом для скользящих операций и в оценку не входят.
Ценовые и объёмные формулы имеют разный масштаб. AGPoolStandardizeGroup приводит ряд к удобному численному диапазону, затем рассчитывает среднее и дисперсию. Если дисперсия не превышает AG_CFG_EPS_VAR, фактор получает AG_SKIP. У авторов AlphaGen нормировка выполнялась по акциям на одну дату; здесь — по времени одного инструмента. Сохранённые параметры позволяют обработать следующий закрытый бар, но не делают оба способа статистически эквивалентными.
variance=AGPoolReduce(variance,reduce,0); if(!isfinite(variance) || variance<=cfg[AG_CFG_EPS_VAR]) return; float sd=sqrt(variance); for(int i=lane;i<count;i+=lanes) normalized[i]=((input[offset+i]/a-origin)/b-mean)/sd; if(lane==0) { statistics[AG_STAT_SCALE]=a; statistics[AG_STAT_ORIGIN]=origin; statistics[AG_STAT_DIFF_SCALE]=b; statistics[AG_STAT_MEAN]=mean; statistics[AG_STAT_STD]=sd; statistics[AG_STAT_STATUS]=AG_OK; statistics[AG_STAT_VALID]=(float)count; }
В записи формулы сохраняются параметры преобразования, которые понадобятся для следующей свечи. В буфере z каждый фактор занимает отдельный столбец длиной N. Номер бара полного окна i и номер наблюдения внутри столбца k различаются: k = i − offset. Поэтому значение фактора j читаем по адресу z[j × N + k]. В нашем примере бар 255 — элемент 0 первого столбца, а бар 510 — элемент 255; для второго фактора те же бары находятся по адресам 256 и 511.
Для подбора весов в исходном AlphaGen применяли итеративную оптимизацию с L1-регуляризацией; при нулевой L1-части предусмотрено решение методом наименьших квадратов. В адаптации MQL5/OpenCL используем небольшую ridge-систему с L2-регуляризацией. Положительное диагональное слагаемое уменьшает неустойчивость весов похожих факторов. В отличие от L1, L2 обычно не обнуляет отдельные коэффициенты. Это отличие от авторского оптимизатора.
(ZTZ / N + λI)w = ZTy / N
Похожие индикаторы могут дать почти одинаковые ряды, из-за чего отдельные коэффициенты становятся неустойчивыми. Параметр AG_CFG_RIDGE задаёт положительное λ в диагональном слагаемом ridge-системы. AGPoolRidgeGroup вычисляет матрицу и правую часть. Отрицательный вес обозначает обратный вклад фактора, но не команду продать.
Индексы параметров объявлены в AlphaGen_Contract.mqh. Численные значения AG_CFG_RIDGE и AG_CFG_EPS_VAR поступают из конфигурационного массива MQL5, передаваемого в CAlphaGenPool::Configure; кернелы читают их из cfg. Метод проверяет, что оба значения положительны. Для повторения опыта необходимо сохранить их вместе с периодами, весами и условиями проверки. Выбор λ и порога дисперсии следует выполнять на обучающей и валидационной истории, не используя итоговый тест для настройки.
int i=cell/columns,j=cell%columns; if(j>i) continue; float r=0.0f; for(int t=0;t<count;t++) r+=z[i*count+t]*z[j*count+t]/(float)count; scratch[cell]=r+(i==j?cfg[AG_CFG_RIDGE]:0.0f); } } barrier(CLK_GLOBAL_MEM_FENCE); if(lane==0) shared[0]=AGPoolSolveGroupLeader(scratch,rhs,weights,columns); barrier(CLK_LOCAL_MEM_FENCE | CLK_GLOBAL_MEM_FENCE); if(shared[0]!=AG_OK) return;
После заполнения системы решение поручаем одному рабочему элементу. В AGPoolSolveGroupLeader строим нижний треугольник разложения Холецкого. На диагонали проверяем, что остаток под квадратным корнем конечен и положителен. Потом выполняем прямую подстановку с полученным треугольником и обратную с транспонированным треугольником. Обе операции читают те же элементы матрицы в памяти. В weights остаётся по одному весу на формулу. Неконечное значение прерывает оценку состава.
for(int i=0;i<columns;i++) { for(int j=0;j<=i;j++) { float r=matrix[i*columns+j]; for(int k=0;k<j;k++) r-=matrix[i*columns+k]*matrix[j*columns+k]; if(i==j) { if(!(r>0.0f) || !isfinite(r)) return AG_TECHNICAL; matrix[i*columns+j]=sqrt(r); } else matrix[i*columns+j]=r/matrix[j*columns+j]; } }
Теперь складываем стандартизованные факторы с найденными весами и рассчитываем корреляцию суммы с последующей доходностью. AGPoolFitGroup получает IC для всего набора. В оригинале итоговая оценка опиралась на корреляции по акциям на разные даты; здесь это временная корреляция одного инструмента на том же отрезке, где подбирались веса. При постоянной сумме корреляция не определена, и признак её пригодности снимается. Полученный IC характеризует обучение на данном окне, а не доходность торговой стратегии.
AGPoolStandardizeGroup(raw,status,0,n,cfg,target,yst,reduce); float ic=0.0f; if(yst[5]==AG_OK) for(int i=lane;i<n;i+=lanes) ic+=target[i]*y[i]/(float)n; ic=AGPoolReduce(ic,reduce,0); if(lane==0) { metric[1]=ic; metric[2]=yst[5]==AG_OK?1.0f:0.0f; }
Два состава сравниваем на одном историческом окне при одинаковом горизонте доходности. Веса подобраны на тех же барах, поэтому высокий IC отражает качество подгонки на обучении. Он не доказывает, что сигнал улучшит прогноз или торговый результат на будущих котировках. Для этого потребуется отдельный период OOS или последовательная walk-forward-проверка с учётом торговых издержек.
Если генератор снова предлагает уже находящуюся в пуле пятибарную среднюю, сравнение длины и токенов предотвращает дублирование записи. В исходном AlphaGen дополнительно проверяли высокую взаимную корреляцию факторов. Здесь сопоставляем только точные формулы: близкие по значениям выражения остаются кандидатами и проходят совместную подгонку весов. Поэтому фильтр удаляет дубли записей, но не всю статистическую избыточность.
В записи пула токены лежат подряд. В пакете генератора между ними расположены данные о выборе каждого действия. Поэтому проверяем длину, а затем читаем токены кандидата с шагом token_stride. Сравнение заканчивается при первом различии. Порядок операндов существенен. Перестановка двух цен в выражении с вычитанием меняет знак результата. На свече с одинаковыми ценами открытия и закрытия оба порядка вычитания дадут ноль. Сравнение по токенам различает их и здесь.
for(int j=0;j<count;j++) { __global float *r=scratch+10+j*stride; int same=(int)r[0]==length; for(int k=0;k<length && same;k++) same=r[5+k]==tokens[k*token_stride]; if(same) shared[1]=1; }
При полном совпадении новую запись не создаём, но базовые веса уже пересчитаны на свежем окне. Поэтому сохраняем их вместе с прежними формулами. На завершающий токен повторного кандидата записывается baseline_ic текущего состава, а не нулевая награда. Так генератор получает фактическую оценку набора, который пытался дополнить, хотя его состав не изменился.
if(shared[1]) { AGPoolCopyGroup(scratch,prepared,size); if(lane==0) { control[0]=AG_OK; control[1]=baseline_ic; control[2]=1.0f; } barrier(CLK_GLOBAL_MEM_FENCE); return;
Если кандидат новый, добавляем его токены и идентификатор в рабочую копию. Затем подбираем заново все веса. В нашем примере включение отклонения цены от средней может изменить и коэффициент самой средней. Иначе мы оценивали бы новую формулу отдельно, вопреки идее совместного поиска AlphaGen.
__global float *candidate=scratch+10+count*stride; if(lane==0) { candidate[0]=(float)length; AGPoolCopyValues(scratch+1,candidate+1,4); scratch[0]=(float)(count+1); } for(int k=lane;k<t;k+=lanes) candidate[5+k]=k<length?tokens[k*token_stride]:AG_PAD; barrier(CLK_GLOBAL_MEM_FENCE); int result=AGPoolFitGroup(market,cfg,scratch,work,candidates,batch,evaluated,reduce,shared);
Пул можно начать заполнять с первой пригодной формулы. Для этого на выбранном интервале должны поддаваться стандартизации и целевая доходность, и сам фактор. Начального набора индикаторов в конфигурации не требуется.
Различаем ошибки исходного пула и нового кандидата. Если AG_INVALID возник при пересчёте уже отобранных формул, обработчик возвращает статус AG_TECHNICAL и восстанавливает рабочую копию. Награда не записывается, поскольку вклад нового предложения ещё не оценён.
Если исходный набор пригоден, а AG_INVALID появился после добавления кандидата, сохраняем прежний состав. Последнему токену назначается AG_CFG_INVALID_TOKEN_REWARD. Например, синтаксически допустимое деление может оказаться недопустимым из-за нулевого знаменателя. Обычный AG_SKIP сам по себе не означает назначения этого штрафа.
if(result!=AG_OK) { AGPoolCopyGroup(prepared,scratch,size); if(lane==0) { control[0]=result; if(result==AG_INVALID) { control[1]=cfg[AG_CFG_INVALID_TOKEN_REWARD]; control[2]=1.0f; } } barrier(CLK_GLOBAL_MEM_FENCE); return;
Пока в пуле есть свободное место, пригодная формула добавляется без вытеснения. При заполненном пуле временно рассматриваем двадцать одну формулу, совместно подбираем веса и удаляем запись с наименьшим абсолютным коэффициентом. Это сохраняет идею отбора факторов по их роли в общей комбинации. Отрицательный коэффициент не делает фактор слабым: важен его модуль.
if(lane==0) { int remove=count; for(int j=0;j<count;j++) { float a=fabs(scratch[10+j*stride+12+t]),b=fabs(scratch[10+remove*stride+12+t]); if(a<b || (a==b && remove!=count && AGPoolIDGreater(scratch+11+j*stride,scratch+11+remove*stride))) remove=j; } shared[2]=remove; }
Начальное значение remove указывает на кандидата. Меняем его, если у прежнего фактора модуль веса меньше. Так задано и правило при равенстве. Если кандидат делит минимальный модуль веса с прежней формулой, выбывает кандидат. Если наименьшее значение одинаково у двух прежних формул, а у кандидата больше, удаляем прежнюю формулу с большим идентификатором.
Если наименьший модуль у кандидата, восстанавливаем исходный подготовленный пул: его веса остаются прежними, а награда равна пересчитанному baseline_ic. При точном дубле иначе — сохраняются обновлённые базовые веса. Эти ветви важно различать.
int remove=shared[2]; if(remove==count) { AGPoolCopyGroup(prepared,scratch,size); if(lane==0) { control[0]=AG_OK; control[1]=baseline_ic; control[2]=1.0f; } barrier(CLK_GLOBAL_MEM_FENCE); return;
Когда выбывает прежний фактор, следующие записи сдвигаются, чтобы в банке не осталось пустого места. Области памяти перекрываются, поэтому рабочая группа переносит целые записи последовательно, сохраняя вместе токены, параметры преобразования и вес. После сдвига в наборе снова двадцать формул.
//--- Overlapping records must move in order, with a barrier between records. for(int j=remove;j<count;j++) AGPoolCopyGroup(scratch+10+(j+1)*stride,scratch+10+j*stride,stride); if(lane==0) scratch[0]=(float)count; barrier(CLK_GLOBAL_MEM_FENCE); result=AGPoolFitGroup(market,cfg,scratch,work,candidates,batch,evaluated,reduce,shared); if(result!=AG_OK) { AGPoolCopyGroup(prepared,scratch,size); if(lane==0) control[0]=AG_TECHNICAL; barrier(CLK_GLOBAL_MEM_FENCE); return; }
Новый набор должен иметь свои согласованные коэффициенты. Поэтому после вытеснения прежнего фактора снова запускаем подгонку и лишь затем фиксируем результат в подготовленном пуле. Следующая предложенная формула будет оцениваться именно относительно него, а не относительно набора с чужими весами.
После пригодной подгонки сохраняем состав, число формул, итоговый IC и признак готовой награды. Этот вариант реализации не требует обязательного роста IC относительно baseline_ic: кандидат отбирается по пригодности и правилу отбора по весам. На его последний токен записывается IC принятого состава, а не разница двух оценок. Следовательно, само принятие формулы не доказывает улучшения прогноза вне обучающего окна.
AGPoolCopyGroup(scratch,prepared,size); if(lane==0) { control[6]=prepared[0]; control[0]=AG_OK; control[1]=work[mi+1]; control[2]=1.0f; }
Завершение пакета ограничено ещё и местом для учебных переходов генератора. Один кандидат занимает столько записей, сколько токенов в его эпизоде, включая AG_STOP. Когда резерв исчерпан, следующие предложения могут не рассматриваться, даже если их ряды уже вычислены. Поэтому статус штатного завершения пакета нужно читать вместе с summary[1] — числом реально обработанных кандидатов.
Для каждого шага генерации сохраняются префикс формулы, маска и параметры выбранного токена. На промежуточных шагах награда равна нулю, а на AG_STOP появляется оценка всего набора. Так результат совместного отбора становится учебным сигналом генератора. Обновление его нейросетевой политики с PPO рассмотрим в следующей статье.
transition[AG_GAE_REWARD]=terminal?control[AG_POOL_REWARD]:0.0f; transition[AG_GAE_DELTA]=1.0f; transition[AG_GAE_VALUE]=token[3]; transition[AG_GAE_NEXT]=terminal?0.0f:token[token_stride+3]; transition[AG_GAE_BOOTSTRAP]=terminal?0.0f:1.0f; transition[AG_GAE_CONTINUE]=terminal?0.0f:1.0f; transition[AG_GAE_READY]=1.0f; summary[4+AG_POOL_CONTROL_SIZE+row-first_row]=(float)(k+1);
В результате пакет меняет подготовленный пул и пополняет историю действий генератора. Торговая модель пока использует прежний опубликованный набор. Чтобы увидеть, что именно она получает на следующем баре, перейдём от исторической оценки к расчёту совокупного сигнала.
Формирование сигнала действующего пула
При отборе факторов мы знали последующую доходность каждого исторического бара. На только что закрывшейся свече её ещё нет. Поэтому действующий пул не подбирает коэффициенты заново: он рассчитывает знакомые формулы и применяет к ним сохранённые параметры. Полученное число — входной признак торговой модели, а не приказ открыть позицию.

На обычном шаге CNeuronAlphaGenOCL::Observe проверяет, что опубликованный состав готов и закрытый бар ещё не обработан. Повторное событие для той же свечи не добавит в контекст вторую точку. Затем CAlphaGenPool::Observe получает окно котировок от старых баров к новым. В советнике такой контроль не позволяет повторному вызову исказить временную историю модели.
Пул передаёт окно методу SignalStep в режиме 0. Тот выбирает выходные буферы для последнего сигнала и его истории. В обычном вызове начальная строка расчёта равна индексу последнего бара. Кернел получает весь массив котировок, поскольку отдельной формуле может понадобиться длинная история. Если значения факторов и статистики окна пригодны, историю сигнала пополнит одна новая точка. Для первого вызова при подготовке истории SignalStep допускает обработку нескольких строк за раз.
int signal_index=mode==2?m_cPreparedSignal.GetIndex():m_cSignal.GetIndex(); int context_index=mode==2?m_cPreparedContext.GetIndex():m_cContext.GetIndex(); setBuffer(def_k_AGPoolSignal,def_ag_AGPoolSignal_signal,signal_index) setBuffer(def_k_AGPoolSignal,def_ag_AGPoolSignal_context,context_index) setArgument(def_k_AGPoolSignal,def_ag_AGPoolSignal_mode,mode) int start=first?(mode==2?m_iLookback:MathMax(m_iLookback,m_iWindow-m_iContext)):m_iWindow-1; setArgument(def_k_AGPoolSignal,def_ag_AGPoolSignal_start,start)
Кернел AGPoolSignal вычисляет значения всех формул действующего пула на нужном участке истории и складывает их вклады. Для пятибарной средней первые четыре бара не дают готового значения. На обычном шаге требуется результат только по последнему закрытому бару. Если для него хотя бы одна формула вернула ошибку или пропуск, совокупный сигнал также не считается готовым.
Значение каждого фактора приводим к масштабу, сохранённому при подборе весов. Функция AGPoolAffine использует параметры из записи формулы; кернел умножает результат на соответствующий коэффициент и прибавляет его к сумме. Например, движение цены на одну условную единицу и изменение процентного индикатора на ту же числовую величину нельзя складывать без согласованной нормировки. При расчёте текущего сигнала сохранённые параметры не подстраиваются по ещё неизвестной доходности.
for(int row=start+lane;row<w;row+=lanes) scores[row]+=record[12+t]*AGPoolAffine(raw[row],record+5+t); barrier(CLK_GLOBAL_MEM_FENCE); }
Допустим, средняя и отклонение закрытия от неё одновременно положительны, а их веса имеют разные знаки. В общей сумме вклады частично компенсируются. Следовательно, модель получает не две отдельные команды, а оценку необычности их совместного значения относительно последних баров.
В рабочем режиме история суммы хранится в кольцевом буфере. На закрытии очередной свечи кернел записывает значение в текущую позицию и переводит указатель на следующую. После заполнения окна новая запись вытесняет самую старую. В статистику для текущей точки уже входит результат текущего бара. Для нескольких входных строк порядок тот же. Кернел добавляет более старую сумму, проверяет готовность сигнала и лишь затем переходит к следующей строке.
if(lane==0) { int pos=(int)ring[1]; ring[11+pos]=score; ring[1]=(float)((pos+1)%nw); ring[0]=fmin((float)nw,ring[0]+1.0f); } barrier(CLK_GLOBAL_MEM_FENCE); int full=ring[0]>=(float)nw;
Кольцо нормировки хранит 256 последних взвешенных сумм, а отдельная история — готовые входы модели. Пока окно не заполнено, сигнал отсутствует. Постоянные или почти одинаковые суммы дают AG_SKIP; корректный ноль при достаточном разбросе остаётся пригодным. Если при обычном вызове Observe приходит AG_SKIP, составной слой выставляет AG_INVALID, и советник запрашивает нулевую целевую позицию. Исполнение проверяется отдельно. Это защитное поведение относится к торговой адаптации, а не к исходному AlphaGen.
Перед подачей в нейросеть стандартизованную сумму ограничиваем параметром AG_CFG_SIGNAL_CLIP и делим на величину ограничения. При границе 10 отклонение на два стандартных отклонения превращается в значение 0,2, а на −2 — в −0,2. Это дополнительная нормировка входа торговой модели, принятая в нашей реализации. Значение 0,2 не означает ни вероятность роста, ни ожидаемую доходность 0,2 %, ни размер позиции.
float g=AGPoolAffine(score,ring+3),clip=cfg[AG_CFG_SIGNAL_CLIP]; if(!isfinite(g) || !(clip>0.0f)) return; g=clamp(g,-clip,clip)/clip;
Теперь Signal возвращает последнее готовое значение, а Context — хронологическую последовательность таких значений. После заполнения контекста старые точки вытесняются новыми. Два контекста могут заканчиваться одним числом 0,2, но отражать разные траектории: в одном сигнал рос, в другом снижался. Поэтому модель получает историю, а не только последнее значение.
if(lane==0) { signal[0]=g; ring[11+nw+count]=g; ring[2]=(float)(count+1); } barrier(CLK_GLOBAL_MEM_FENCE); AGPoolCopyGroup(ring+11+nw,context,count+1); if(lane==0) { control[0]=AG_OK; control[4]=(mode==2 && count+1<nc)?0.0f:1.0f; }
Когда поиск подготовил новый состав, торговой модели нужна не только последняя оценка, но и последовательность входов, рассчитанная с одинаковыми формулами и весами. Советник фиксирует закрытые бары и границу будущей публикации. Затем начинает прогрев подготовленного пула.
В выбранной конфигурации прогрев требует 631 закрытого бара. Это больше обычного рыночного окна из 512 баров. Торговой модели необходимы 256 последовательных значений сигнала. Для расчёта самого раннего значения нужны 120 баров предыстории и окно нормировки из 256 наблюдений: всего 120 + 256 + 256 − 1 = 631 бар.
По мере продвижения по истории вычисляем очередное значение сигнала. Если нормировка на каком-либо шаге непригодна, полный контекст приходится накапливать заново. До публикации действует прежний пул; во время прогрева советник не пополняет его историю параллельно.
Успешный Commit одновременно переключает состав и контекст. На границе публикации торговое действие пропускается. Начиная со следующих баров советник возвращается к обычной обработке.
AGPoolCopyGroup(pinned,active,size); AGPoolCopyGroup(rings+rs,rings,rs); int nw=(int)cfg[AG_CFG_NORM_WINDOW], nc=(int)cfg[AG_CFG_CONTEXT]; AGPoolCopyGroup(rings+11+nw,context,nc); if(lane==0) { signal[0]=context[nc-1]; control[7]=active[0]; pinned[9]=0.0f; control[0]=AG_PUBLISHED; control[3]=1.0f; control[5]=1.0f;
Метод Warmup также позволяет заново рассчитать контекст действующей версии по закрытым барам с сохранёнными параметрами нормировки. Это не гарантирует побитового совпадения с ранее записанной историей: во время обычной работы статистика кольцевого окна обновлялась на каждом баре.
После подготовки Observe проверяет готовность нового входа и передаёт контекст кодировщику торговой модели. На следующей разрешённой границе Act вызывает Forward. Помимо ряда от пула, политика использует данные счёта и рекуррентное состояние. Она выбирает торговое действие; само вычисленное число не становится автоматически командой Buy или Sell.
if(!Slice(source.getOutput(), (int)m_fConfig[AG_CFG_W] * 5, GetPointer(m_cAccount), 0, AG_ACCOUNT)) ReturnFalse; if(!m_cTrading.Forward(m_cPool.Context(), (int)m_fConfig[AG_CFG_CONTEXT], GetPointer(m_cWorkAnchor), GetPointer(m_cAccount), bTrain && m_iPhase == AG_ACT ? 0 : 1)) ReturnFalse;
Класс CAlphaGenPool завершает работу на формировании входного признака и истории. Он не размещает заявки: правила управления позицией и исполнение остаются за другими компонентами советника.
Заключение
На закрытии бара действующий пул вычисляет выражения и применяет сохранённые параметры стандартизации. Затем складывает значения с весами и, если результат пригоден, дополняет контекст торговой модели. Корректный ноль остаётся наблюдением, а отсутствие пригодного сигнала передаётся отдельным статусом и не подменяется нулевой оценкой рынка.
Класс CAlphaGenPool объединил пакетную оценку кандидатов, последовательное обновление состава, ridge-подбор общих весов и подготовку сигнала для торговой модели. От авторского AlphaGen сохранён принцип совместного отбора, но вместо поперечного IC по акциям используем временной IC одного инструмента. Раздельные версии пула предотвращают смешивание сигналов при смене весов. Влияние этих решений на скорость расчёта и торговые показатели ещё нужно измерить.
Для следующего этапа получены две связанные величины: оценка готовой формулы для поисковой политики и история совокупного сигнала для торговой модели. Реализация пула завершает очередной технический этап, но сама по себе не подтверждает прибыльность стратегии. Проверка OOS или walk-forward, а также учёт издержек необходимы для оценки практической пригодности найденных факторов. К обучению поисковой политики вернёмся в следующей статье.
Ссылки
- Generating Synergistic Formulaic Alpha Collections via Reinforcement Learning.
- Proximal Policy Optimization Algorithms.
- Другие статьи автора.
Файлы проекта
| # | Имя | Тип | Описание |
|---|---|---|---|
| 1 | AlphaGen_Contract.mqh | Общий контракт | Идентификаторы токенов и параметры общего контракта |
| 2 | AlphaGen.cl | OpenCL-программа | Вычислительные кернелы |
| 3 | Trajectory.mqh | Общий модуль | Общие настройки, подготовка данных, финансовая среда, исполнение и завершение |
| 4 | Study.mq5 | Советник | Советник предварительного офлайн-обучения |
| 5 | StudyOnline.mq5 | Советник | Советник обучения в тестере стратегий |
| 6 | Test.mq5 | Советник | Исполнение торговой политики с фиксированными весами |
| 7 | NeuroNet.mqh | Библиотека классов | Подключение модулей нейронной библиотеки |
| 8 | NeuroNet.cl | OpenCL-программа | Вычислительные кернелы нейронной библиотеки |
| 9 | AlphaGen_Pool.cl | OpenCL-программа | Пакетная обработка кандидатов и вычисление факторов пула |
Исходные файлы доступны в репозитории проекта.
Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.
Данная статья написана пользователем сайта и отражает его личную точку зрения. Компания MetaQuotes Ltd не несет ответственности за достоверность представленной информации, а также за возможные последствия использования описанных решений, стратегий или рекомендаций.