koros0111/Warrior_EA
Watch
1
0
Fork
You've already forked Warrior_EA
 0
forked from animatedread/Warrior_EA
Code Pull requests Activity
Warrior_EA/Expert/Persistence/AIBasePersistenceViewImpl.mqh
AnimateDread d9092a2408 fix(vote): persist the member's skill verdict - a converged model was ruled no-skill on every restart 
SP500 resumed converged at era 136 with its tier ladder correctly restored and still
swept 4999 bars reporting "0 had a snapshot, drew 0 arrow(s)" while the other five
charts drew 221-312.

HasDemonstratedEdge() - added with the no-skill exclusion - compares m_eraStatPrecPct
against m_eraStatChancePct. Both are written once per era by EnsembleStashEraStats. A
converged model runs no eras, so after a restart both sat at their -1 ctor defaults,
every member was ruled no-skill, ReconstructionWeight() returned 0 for all four, and
the overlay divisor was zero on every bar. Exactly the failure the WST7 ladder
persistence fixed one level down: the ladder says how much a member votes, this says
whether it may.

RankTiersFromOos already computes the pair (pooled holdout precision and the
zero-skill reference rate) and now records it as the CERTIFIED edge. That path is
reached by the era end AND by the deployed replay, which is the only measurement a
converged model will ever make. Persisted as WST8; HasDemonstratedEdge() prefers the
era pair and falls back to it.

The census line also had to be fixed: it reported "NOT ONE of those bars had a single
member snapshot ... no enrolled member has published m_overlaySigSnap" for a condition
that was purely a skill verdict. The snapshots were there. It now counts the two causes
separately and names the one that fired.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-26 16:53:16 -04:00

156 lines
11 KiB
MQL5
Raw Permalink Blame History

//+------------------------------------------------------------------+
//| Warrior_EA |
//| AnimateDread |
//| |
//| CAIBasePersistenceView bodies - needs the full signal |
//| declaration. Same doctrine as Chart\AIBaseChartViewImpl.mqh - |
//| every method is a forward, borrowed pointer checked on every |
//| call. |
//+------------------------------------------------------------------+
#ifndef WARRIOR_PERSISTENCE_AIBASEPERSISTENCEVIEWIMPL_MQH
#define WARRIOR_PERSISTENCE_AIBASEPERSISTENCEVIEWIMPL_MQH
string CAIBasePersistenceView::Id(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.DataId() : ""; }
string CAIBasePersistenceView::FileName(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.ChartFileName() : ""; }
int CAIBasePersistenceView::NeuronsCount(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.DataFeaturesPerBar() : 0; }
long CAIBasePersistenceView::CumIsCorrect(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.ChartCumIsCorrect() : 0; }
long CAIBasePersistenceView::CumIsTotal(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.ChartCumIsTotal() : 0; }
long CAIBasePersistenceView::CumOosCorrect(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.ChartCumOosCorrect() : 0; }
long CAIBasePersistenceView::CumOosTotal(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.ChartCumOosTotal() : 0; }
bool CAIBasePersistenceView::NetLoaded(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistNetLoaded() : false; }
bool CAIBasePersistenceView::UsesConvStage(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistUsesConvStage() : false; }
uint CAIBasePersistenceView::NetFirstConvWindow(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistNetFirstConvWindow() : 0; }
int CAIBasePersistenceView::ConvReceptiveFieldBars(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistConvReceptiveFieldBars() : 0; }
ENUM_ACTIVATION CAIBasePersistenceView::OutputLayerActivation(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistOutputLayerActivation() : TANH; }
bool CAIBasePersistenceView::NetEnforceOutputActivation(const ENUM_ACTIVATION intended, ENUM_ACTIVATION &stale)
{
stale = intended;
return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistNetEnforceOutputActivation(intended, stale) : false;
}
void CAIBasePersistenceView::SetTopologySuperseded(const bool v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetTopologySuperseded(v); }
double CAIBasePersistenceView::PriorBuy(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistPriorBuy() : 0.0; }
void CAIBasePersistenceView::SetPriorBuy(const double v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetPriorBuy(v); }
double CAIBasePersistenceView::PriorSell(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistPriorSell() : 0.0; }
void CAIBasePersistenceView::SetPriorSell(const double v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetPriorSell(v); }
double CAIBasePersistenceView::PriorNeutral(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistPriorNeutral() : 0.0; }
void CAIBasePersistenceView::SetPriorNeutral(const double v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetPriorNeutral(v); }
double CAIBasePersistenceView::ConfidenceCalScale(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistConfidenceCalScale() : 0.0; }
void CAIBasePersistenceView::SetConfidenceCalScale(const double v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetConfidenceCalScale(v); }
bool CAIBasePersistenceView::MqlInferenceValidated(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistMqlInferenceValidated() : false; }
void CAIBasePersistenceView::SetMqlInferenceValidated(const bool v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetMqlInferenceValidated(v); }
datetime CAIBasePersistenceView::OnlineLearnedUpToTime(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistOnlineLearnedUpToTime() : 0; }
void CAIBasePersistenceView::SetOnlineLearnedUpToTime(const datetime v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetOnlineLearnedUpToTime(v); }
double CAIBasePersistenceView::OnlineRollingAcc(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistOnlineRollingAcc() : 0.0; }
void CAIBasePersistenceView::SetOnlineRollingAcc(const double v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetOnlineRollingAcc(v); }
long CAIBasePersistenceView::OnlineSamples(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistOnlineSamples() : 0; }
void CAIBasePersistenceView::SetOnlineSamples(const long v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetOnlineSamples(v); }
int CAIBasePersistenceView::LastBuyFiredPrecPct(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistLastBuyFiredPrecPct() : -1; }
void CAIBasePersistenceView::SetLastBuyFiredPrecPct(const int v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetLastBuyFiredPrecPct(v); }
int CAIBasePersistenceView::LastSellFiredPrecPct(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistLastSellFiredPrecPct() : -1; }
void CAIBasePersistenceView::SetLastSellFiredPrecPct(const int v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetLastSellFiredPrecPct(v); }
int CAIBasePersistenceView::LastBuyRecallPct(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistLastBuyRecallPct() : -1; }
void CAIBasePersistenceView::SetLastBuyRecallPct(const int v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetLastBuyRecallPct(v); }
int CAIBasePersistenceView::LastSellRecallPct(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistLastSellRecallPct() : -1; }
void CAIBasePersistenceView::SetLastSellRecallPct(const int v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetLastSellRecallPct(v); }
int CAIBasePersistenceView::LastBuyFired(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistLastBuyFired() : 0; }
void CAIBasePersistenceView::SetLastBuyFired(const int v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetLastBuyFired(v); }
int CAIBasePersistenceView::LastSellFired(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistLastSellFired() : 0; }
void CAIBasePersistenceView::SetLastSellFired(const int v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetLastSellFired(v); }
void CAIBasePersistenceView::SetCumIsCorrect(const long v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetCumIsCorrect(v); }
void CAIBasePersistenceView::SetCumIsTotal(const long v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetCumIsTotal(v); }
void CAIBasePersistenceView::SetCumOosCorrect(const long v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetCumOosCorrect(v); }
void CAIBasePersistenceView::SetCumOosTotal(const long v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetCumOosTotal(v); }
int CAIBasePersistenceView::TierWeight(const int tier)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistTierWeight(tier) : 0; }
void CAIBasePersistenceView::SetTierWeight(const int tier, const int v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetTierWeight(tier, v); }
double CAIBasePersistenceView::ModuleTrustWeight(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.ModuleWeight() : 0.0; }
void CAIBasePersistenceView::SetModuleTrustWeight(const double v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetModuleTrustWeight(v); }
bool CAIBasePersistenceView::TiersSelfRanked(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.SelfRanked() : false; }
void CAIBasePersistenceView::SetTiersSelfRanked(const bool v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetTiersSelfRanked(v); }
double CAIBasePersistenceView::CertifiedPrecPct(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistCertifiedPrecPct() : -1.0; }
double CAIBasePersistenceView::CertifiedChancePct(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistCertifiedChancePct() : -1.0; }
void CAIBasePersistenceView::SetCertifiedEdge(const double precPct, const double chancePct)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetCertifiedEdge(precPct, chancePct); }
bool CAIBasePersistenceView::RunCpuInferenceSelfCheck(double &maxDiff)
{
maxDiff = DBL_MAX;
return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistRunCpuInferenceSelfCheck(maxDiff) : false;
}
void CAIBasePersistenceView::SetDirConfThreshold(const double v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetDirConfThreshold(v); }
double CAIBasePersistenceView::BestDirConfThreshold(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistBestDirConfThreshold() : 0.0; }
void CAIBasePersistenceView::SetBestDirConfThreshold(const double v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetBestDirConfThreshold(v); }
string CAIBasePersistenceView::CrossAssetPairsPinned(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistCrossAssetPairsPinned() : ""; }
void CAIBasePersistenceView::SetCrossAssetPairsPinned(const string v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetCrossAssetPairsPinned(v); }
void CAIBasePersistenceView::SetCrossAssetCfgSaved(const bool v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetCrossAssetCfgSaved(v); }
string CAIBasePersistenceView::AltDataNamesPinned(void)
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistAltDataNamesPinned() : ""; }
void CAIBasePersistenceView::SetAltDataNamesPinned(const string v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistSetAltDataNamesPinned(v); }
void CAIBasePersistenceView::ApplyAltDataPinnedNames(const string v)
{ if(CheckPointer(m_owner) != POINTER_INVALID) m_owner.PersistApplyAltDataPinnedNames(v); }
bool CAIBasePersistenceView::LoadNetOnce(double &indicatorParams[])
{ return (CheckPointer(m_owner) != POINTER_INVALID) ? m_owner.PersistLoadNetOnce(indicatorParams) : false; }
#endif // WARRIOR_PERSISTENCE_AIBASEPERSISTENCEVIEWIMPL_MQH
//+------------------------------------------------------------------+
View git blame Copy permalink