| //+------------------------------------------------------------------+
|
| //| NeuroNet_InferenceSnapshot.mqh |
|
| //| Copyright 2026, DNG |
|
| //| https://www.mql5.com/ru/users/dng |
|
| //+------------------------------------------------------------------+
|
| #ifndef NEURONET_INFERENCE_SNAPSHOT_WORK_MQH
|
| #define NEURONET_INFERENCE_SNAPSHOT_WORK_MQH
|
| //--- Restricted native frozen-inference state path. Ordinary Load bytes/reset unchanged.
|
| //+------------------------------------------------------------------+
|
| //| InferenceRuntimeLoadActive |
|
| //+------------------------------------------------------------------+
|
| bool COpenCLMy::InferenceRuntimeLoadActive(void) const
|
| {
|
| return(CheckPointer(m_inference_owner) != POINTER_INVALID
|
| && m_inference_owner.InferenceRuntimeLoadActive(GetPointer(this)));
|
| }
|
| //+------------------------------------------------------------------+
|
| //| NNInferenceRemaining |
|
| //+------------------------------------------------------------------+
|
| bool NNInferenceRemaining(const int handle, const ulong required)
|
| {
|
| if(handle == INVALID_HANDLE)
|
| return(false);
|
| const ulong position=FileTell(handle);
|
| const ulong size=FileSize(handle);
|
| return(position <= size && required <= size - position);
|
| }
|
| //+------------------------------------------------------------------+
|
| //| NNInferenceHeader |
|
| //+------------------------------------------------------------------+
|
| bool NNInferenceHeader(const int handle, const bool restore, const uint value)
|
| {
|
| if(handle == INVALID_HANDLE)
|
| return(false);
|
| if(restore)
|
| return(NNInferenceRemaining(handle, 4) && (uint)FileReadInteger(handle) == value);
|
| return(FileWriteInteger(handle, (int)value) == 4);
|
| }
|
| //+------------------------------------------------------------------+
|
| //| NNInferenceFinite |
|
| //+------------------------------------------------------------------+
|
| bool NNInferenceFinite(CBufferFloat *buffer)
|
| {
|
| if(buffer == NULL)
|
| return(true);
|
| if(CheckPointer(buffer) == POINTER_INVALID)
|
| return(false);
|
| if(buffer.Total() == 0)
|
| return(true);
|
| if(buffer.Total() < 0)
|
| return(false);
|
| if(buffer.GetIndex() >= 0)
|
| {
|
| COpenCLMy *receiver = dynamic_cast<COpenCLMy*>(buffer.GetOpenCL());
|
| if(!receiver || receiver.GetBufferSize(buffer.GetIndex()) != (ulong)buffer.Total() * sizeof(float))
|
| return(false);
|
| if(!buffer.BufferRead())
|
| return(false);
|
| }
|
| for(int i = 0; i < buffer.Total(); i++)
|
| if(!MathIsValidNumber((double)(*buffer)[i]))
|
| return(false);
|
| return(true);
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Validate an optional finite buffer |
|
| //+------------------------------------------------------------------+
|
| //--- CNeuronBaseOCL::Load uses DeleteObj for absent parameter buffers but does not null the pointer.
|
| bool NNInferenceOptionalFinite(CBufferFloat *buffer)
|
| {
|
| return(buffer == NULL || CheckPointer(buffer) == POINTER_INVALID || NNInferenceFinite(buffer));
|
| }
|
| //+------------------------------------------------------------------+
|
| //| NNInferenceOmittedBuffer |
|
| //+------------------------------------------------------------------+
|
| bool NNInferenceOmittedBuffer(const int handle, const bool restore, CBufferFloat *buffer)
|
| {
|
| if(buffer == NULL || CheckPointer(buffer) == POINTER_INVALID || buffer.Total() <= 0 || !buffer.GetOpenCL() || buffer.GetIndex() < 0
|
| || !NNInferenceHeader(handle, restore, (uint)buffer.Total()))
|
| return(false);
|
| if(!restore)
|
| {
|
| if(!NNInferenceFinite(buffer))
|
| return(false);
|
| for(int i = 0; i < buffer.Total(); i++)
|
| if(FileWriteFloat(handle, (*buffer)[i]) != 4)
|
| return(false);
|
| return(true);
|
| }
|
| if(!NNInferenceRemaining(handle, (ulong)buffer.Total() * 4))
|
| return(false);
|
| float values[];
|
| if(ArrayResize(values, buffer.Total()) != buffer.Total())
|
| return(false);
|
| for(int i = 0; i < buffer.Total(); i++)
|
| {
|
| values[i] = FileReadFloat(handle);
|
| if(!MathIsValidNumber((double)values[i]))
|
| return(false);
|
| }
|
| for(int i = 0; i < buffer.Total(); i++)
|
| buffer.Update(i, values[i]);
|
| return(buffer.BufferWrite());
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Function NNInferenceRequired |
|
| //+------------------------------------------------------------------+
|
| bool NNInferenceRequired(CBufferFloat *buffer, COpenCLMy *receiver, const int count);
|
| //+------------------------------------------------------------------+
|
| //| InferenceRuntimeSidecar |
|
| //+------------------------------------------------------------------+
|
| bool CNeuronBaseOCL::InferenceRuntimeSidecar(const int handle, const bool restore)
|
| {
|
| return(NNInferenceHeader(handle, restore, (uint)bTrain) && NNInferenceHeader(handle, restore, (uint)Type())
|
| && NNInferenceHeader(handle, restore, (uint)Neurons()) && NNInferenceRequired(Output, OpenCL, Neurons())
|
| && NNInferenceRequired(PrevOutput, OpenCL, Neurons()) && CheckPointer(Gradient) != POINTER_INVALID
|
| && NNInferenceRequired(Gradient, OpenCL, Gradient.Total()) && NNInferenceOptionalFinite(Weights)
|
| && NNInferenceOptionalFinite(DeltaWeights) && NNInferenceOptionalFinite(FirstMomentum)
|
| && NNInferenceOptionalFinite(SecondMomentum));
|
| }
|
| //+------------------------------------------------------------------+
|
| //| InferenceRuntimeSidecar |
|
| //+------------------------------------------------------------------+
|
| bool CNeuronSpikeActivation::InferenceRuntimeSidecar(const int handle, const bool restore)
|
| {
|
| return(CNeuronBaseOCL::InferenceRuntimeSidecar(handle, restore) && NNInferenceHeader(handle, restore, 101)
|
| && cLevels.InferenceRuntimeSidecar(handle, restore) && NNInferenceHeader(handle, restore, 102)
|
| && cGates.InferenceRuntimeSidecar(handle, restore) && NNInferenceHeader(handle, restore, 103)
|
| && cHV.Neurons() == Neurons() && NNInferenceOmittedBuffer(handle, restore, cHV.getOutput())
|
| && NNInferenceOmittedBuffer(handle, restore, cHV.getPrevOutput()));
|
| }
|
| //+------------------------------------------------------------------+
|
| //| InferenceRuntimeSidecar |
|
| //+------------------------------------------------------------------+
|
| bool CNeuronSpikeConvBlock::InferenceRuntimeSidecar(const int handle, const bool restore)
|
| {
|
| return(CNeuronBaseOCL::InferenceRuntimeSidecar(handle, restore) && NNInferenceHeader(handle, restore, 201)
|
| && cActivation.InferenceRuntimeSidecar(handle, restore) && NNInferenceHeader(handle, restore, 202)
|
| && cConv.InferenceRuntimeSidecar(handle, restore) && NNInferenceHeader(handle, restore, 203)
|
| && cStack.InferenceRuntimeSidecar(handle, restore));
|
| }
|
| //+------------------------------------------------------------------+
|
| //| InferenceRuntimeSidecar |
|
| //+------------------------------------------------------------------+
|
| bool CNeuronCogDriverData::InferenceRuntimeSidecar(const int handle, const bool restore)
|
| {
|
| if(iWindow == 0 || iVariables == 0 || iQuantiles == 0 || (ulong)iStateStackSize < 10 * (ulong)iQuantiles
|
| || iQuantStackSize < 2 || !MathIsValidNumber((double)fRange) || fRange <= 0)
|
| return(false);
|
| const ulong raw = (ulong)iWindow * iVariables, bins = 2 * (ulong)iQuantiles + 1;
|
| if(raw > (ulong)INT_MAX || bins > (ulong)INT_MAX || raw * bins > (ulong)INT_MAX || (ulong)iStateStackSize * raw > (ulong)INT_MAX
|
| || (ulong)iQuantStackSize * raw * bins > (ulong)INT_MAX || cStateStack.Neurons() != (int)((ulong)iStateStackSize * raw)
|
| || cQuantStack.Neurons() != (int)((ulong)iQuantStackSize * raw * bins)
|
| || cPrevQuantStack.Neurons() != cQuantStack.Neurons())
|
| return(false);
|
| return(CNeuronSpikeConvBlock::InferenceRuntimeSidecar(handle, restore) && NNInferenceHeader(handle, restore, iWindow)
|
| && NNInferenceHeader(handle, restore, iVariables) && NNInferenceHeader(handle, restore, iStateStackSize)
|
| && NNInferenceHeader(handle, restore, iQuantStackSize) && NNInferenceHeader(handle, restore, iQuantiles)
|
| && NNInferenceHeader(handle, restore, 301) && cNorm.InferenceRuntimeSidecar(handle, restore)
|
| && NNInferenceHeader(handle, restore, 302) && cStateStack.InferenceRuntimeSidecar(handle, restore)
|
| && NNInferenceHeader(handle, restore, 303) && cMSD.InferenceRuntimeSidecar(handle, restore)
|
| && NNInferenceHeader(handle, restore, 304) && cAffine.InferenceRuntimeSidecar(handle, restore)
|
| && NNInferenceHeader(handle, restore, 305) && cQuantStack.InferenceRuntimeSidecar(handle, restore)
|
| && NNInferenceHeader(handle, restore, 306) && cPrevQuantStack.InferenceRuntimeSidecar(handle, restore));
|
| }
|
| //+------------------------------------------------------------------+
|
| //| InferenceRuntimeSidecar |
|
| //+------------------------------------------------------------------+
|
| bool CNeuronCogDriverRankTCM::InferenceRuntimeSidecar(const int handle, const bool restore)
|
| {
|
| if(iInputDim == 0 || iQueryDim == 0 || iVariables == 0 || iHeads == 0 || iMemoryLen == 0 || iQueryDim % iHeads != 0
|
| || iHeadDim != iQueryDim / iHeads || (ulong)iVariables * iQueryDim != iTotalQueryDim
|
| || (ulong)iVariables * iHeads != iTotalHeads || iMemoryCount > iMemoryLen
|
| || (ulong)iMemoryLen * iTotalQueryDim > (ulong)INT_MAX
|
| || cMemoryQuery.Total() != (int)((ulong)iMemoryLen * iTotalQueryDim) || (ulong)iMemoryLen * iVariables > (ulong)INT_MAX
|
| || cMemoryAge.Total() != (int)((ulong)iMemoryLen * iVariables) || cMemoryScore.Total() != cMemoryAge.Total()
|
| || cMemoryValid.Total() != cMemoryAge.Total())
|
| return(false);
|
| return(CNeuronBaseOCL::InferenceRuntimeSidecar(handle, restore) && NNInferenceHeader(handle, restore, iInputDim)
|
| && NNInferenceHeader(handle, restore, iQueryDim) && NNInferenceHeader(handle, restore, iVariables)
|
| && NNInferenceHeader(handle, restore, iHeads) && NNInferenceHeader(handle, restore, iMemoryLen)
|
| && NNInferenceHeader(handle, restore, iMemoryCount) && NNInferenceHeader(handle, restore, (uint)bLastQueryValid)
|
| && NNInferenceHeader(handle, restore, 401) && cQueryProjection.InferenceRuntimeSidecar(handle, restore)
|
| && NNInferenceHeader(handle, restore, 402) && cGateInput.InferenceRuntimeSidecar(handle, restore)
|
| && NNInferenceHeader(handle, restore, 403) && cGateProjection.InferenceRuntimeSidecar(handle, restore)
|
| && NNInferenceHeader(handle, restore, 404) && cMemoryContext.InferenceRuntimeSidecar(handle, restore)
|
| && NNInferenceHeader(handle, restore, 405) && cSelfContext.InferenceRuntimeSidecar(handle, restore)
|
| && NNInferenceFinite(GetPointer(cMemoryQuery)) && NNInferenceFinite(GetPointer(cMemoryAge))
|
| && NNInferenceFinite(GetPointer(cMemoryScore)) && NNInferenceFinite(GetPointer(cMemoryValid)));
|
| }
|
| //+------------------------------------------------------------------+
|
| //| InferenceRuntimeSidecar |
|
| //+------------------------------------------------------------------+
|
| bool CNeuronOMPBOCL::InferenceRuntimeSidecar(const int handle, const bool restore)
|
| {
|
| if(bCurrentTransactionPending || cReference == NULL || cCurrent == NULL || iReferenceCount > iReferenceCapacity
|
| || iCurrentCount > iCurrentCapacity)
|
| return(false);
|
| if(!CNeuronBaseOCL::InferenceRuntimeSidecar(handle, restore) || !NNInferenceHeader(handle, restore, iDimension)
|
| || !NNInferenceHeader(handle, restore, iVariables) || !NNInferenceHeader(handle, restore, iSamples)
|
| || !NNInferenceHeader(handle, restore, iReferenceCapacity)
|
| || !NNInferenceHeader(handle, restore, iCurrentCapacity) || !NNInferenceHeader(handle, restore, iReferenceCount)
|
| || !NNInferenceHeader(handle, restore, iCurrentCount))
|
| return(false);
|
| uint mode = (uint)eMode, anchor = (uint)bSourceAnchor;
|
| if(restore)
|
| {
|
| if(!NNInferenceRemaining(handle, 8))
|
| return(false);
|
| mode = (uint)FileReadInteger(handle);
|
| anchor = (uint)FileReadInteger(handle);
|
| if(mode != (uint)OMPB_INFERENCE || anchor > 1)
|
| return(false);
|
| }
|
| else
|
| if(mode != (uint)OMPB_INFERENCE || FileWriteInteger(handle, (int)mode) != 4
|
| || FileWriteInteger(handle, (int)anchor) != 4)
|
| return(false);
|
| if(!NNInferenceHeader(handle, restore, 501) || !cResidual.InferenceRuntimeSidecar(handle, restore)
|
| || !NNInferenceHeader(handle, restore, 502) || !cGate.InferenceRuntimeSidecar(handle, restore)
|
| || !NNInferenceHeader(handle, restore, 503) || !cReference.InferenceRuntimeSidecar(handle, restore)
|
| || !NNInferenceHeader(handle, restore, 504) || !cCurrent.InferenceRuntimeSidecar(handle, restore))
|
| return(false);
|
| if(!NNInferenceHeader(handle, restore, 505) || !cAlpha.InferenceRuntimeSidecar(handle, restore))
|
| return(false);
|
| if(restore)
|
| {
|
| eMode = (ENUM_OMPB_MODE)mode;
|
| bSourceAnchor = (anchor == 1);
|
| }
|
| return(true);
|
| }
|
| //+------------------------------------------------------------------+
|
| //| InferenceRuntimeSidecar |
|
| //+------------------------------------------------------------------+
|
| bool CNeuronScenarioForecast::InferenceRuntimeSidecar(const int handle, const bool restore)
|
| {
|
| if(!restore && bCodebookUpdate)
|
| return(false);
|
| const ulong vh = (ulong)iVariables * iHorizon;
|
| if(iVariables == 0 || iHorizon == 0 || iDimension == 0 || iScenarios == 0 || iTopK == 0 || iTopK > iScenarios
|
| || vh > (ulong)INT_MAX)
|
| return(false);
|
| const ulong vhd = vh * iDimension;
|
| if(vhd > (ulong)INT_MAX || (ulong)iScenarios * vhd > (ulong)INT_MAX / 2)
|
| return(false);
|
| const int conf = (int)((ulong)iScenarios * vh), latent = (int)((ulong)iScenarios * vhd), target = (int)vhd;
|
| if(!NNInferenceRequired(Output, OpenCL, latent) || !NNInferenceRequired(GetPointer(cConfidence), OpenCL, conf)
|
| || !NNInferenceRequired(GetPointer(cLogConfidence), OpenCL, conf)
|
| || !NNInferenceRequired(GetPointer(cLogProbabilities), OpenCL, (int)iScenarios)
|
| || !NNInferenceRequired(GetPointer(cResponsibilities), OpenCL, (int)iScenarios)
|
| || !NNInferenceRequired(GetPointer(cTarget), OpenCL, target) || cGeneratorInput.Neurons() != 2 * latent
|
| || cConfidenceInput.Neurons() != 2 * latent
|
| || cRouterInput.Neurons() != (int)(2 * (ulong)iScenarios * iVariables * iDimension) || cGenerator.Neurons() != latent
|
| || cConfidenceHead.Neurons() != conf || cRouter.Neurons() != (int)iScenarios
|
| || cRouterSoftmax.Neurons() != (int)iScenarios || cResponsibilityScores.Neurons() != (int)iScenarios
|
| || cTopKSelector.Neurons() != (int)iTopK)
|
| return(false);
|
| if(!CNeuronBaseOCL::InferenceRuntimeSidecar(handle, restore) || !NNInferenceHeader(handle, restore, iVariables)
|
| || !NNInferenceHeader(handle, restore, iScenarios) || !NNInferenceHeader(handle, restore, iTopK)
|
| || !NNInferenceHeader(handle, restore, iHorizon) || !NNInferenceHeader(handle, restore, iDimension)
|
| || !NNInferenceHeader(handle, restore, 600) || !cGeneratorInput.InferenceRuntimeSidecar(handle, restore)
|
| || !NNInferenceHeader(handle, restore, 601) || !cRouterInput.InferenceRuntimeSidecar(handle, restore)
|
| || !NNInferenceHeader(handle, restore, 602) || !cConfidenceInput.InferenceRuntimeSidecar(handle, restore)
|
| || !NNInferenceHeader(handle, restore, 603) || !cGenerator.InferenceRuntimeSidecar(handle, restore)
|
| || !NNInferenceHeader(handle, restore, 604) || !cRouter.InferenceRuntimeSidecar(handle, restore)
|
| || !NNInferenceHeader(handle, restore, 605) || !cConfidenceHead.InferenceRuntimeSidecar(handle, restore)
|
| || !NNInferenceHeader(handle, restore, 606) || !cRouterSoftmax.InferenceRuntimeSidecar(handle, restore)
|
| || !NNInferenceHeader(handle, restore, 607) || !cResponsibilityScores.InferenceRuntimeSidecar(handle, restore)
|
| || !NNInferenceHeader(handle, restore, 608) || !cTopKSelector.InferenceRuntimeSidecar(handle, restore)
|
| || !NNInferenceFinite(cCodebook.GetPrototypes()) || !NNInferenceFinite(cCodebook.GetEMASums())
|
| || !NNInferenceFinite(cCodebook.GetEMACounts()) || !NNInferenceFinite(cCodebook.GetUsage())
|
| || !NNInferenceFinite(cCodebook.GetInactivityAge()) || !NNInferenceFinite(GetPointer(cConfidence))
|
| || !NNInferenceFinite(GetPointer(cLogConfidence)) || !NNInferenceFinite(GetPointer(cLogProbabilities))
|
| || !NNInferenceFinite(GetPointer(cResponsibilities)) || !NNInferenceFinite(GetPointer(cTarget)))
|
| return(false);
|
| if(restore)
|
| bCodebookUpdate = false;
|
| return(true);
|
| }
|
| //+------------------------------------------------------------------+
|
| //| InferenceSnapshotGraph |
|
| //+------------------------------------------------------------------+
|
| bool CNet::InferenceSnapshotGraph(void) const
|
| {
|
| if(!layers || (layers.Total() != 5 && layers.Total() != 7) || !opencl || !bOwnOpenCL || pendingOpenCL != NULL)
|
| return(false);
|
| const int n = layers.Total();
|
| const int tail[] =
|
| {
|
| defNeuronCogDriverData, defNeuronCogDriverRankTCM, defNeuronOMPBOCL, defNeuronScenarioForecast
|
| }
|
| ;
|
| for(int i = 0; i < n; i++)
|
| {
|
| CLayer *layer = layers.At(i);
|
| if(!layer || layer.Total() != 1)
|
| return(false);
|
| CNeuronBaseOCL *node = layer.At(0);
|
| if(!node || node.TrainMode())
|
| return(false);
|
| const int type = node.Type();
|
| if(i >= n - 4)
|
| {
|
| const int expected = tail[i - (n - 4)];
|
| if(type != expected &&
|
| !(expected == defNeuronScenarioForecast && type == defNeuronScenarioForecastPriceOCL))
|
| return(false);
|
| }
|
| else
|
| if(type != (i == 0 ? defNeuronBaseOCL : (i == 1 ? defNeuronBatchNormOCL : defNeuronDropoutOCL)))
|
| return(false);
|
| }
|
| return(true);
|
| }
|
| //+------------------------------------------------------------------+
|
| //| SaveInferenceRuntimeSidecar |
|
| //+------------------------------------------------------------------+
|
| bool CNet::SaveInferenceRuntimeSidecar(const int handle)
|
| {
|
| if(m_inference_load_active || bWeightsUpdate || !InferenceSnapshotGraph()
|
| || !NNInferenceHeader(handle, false, 0x49534631) || !NNInferenceHeader(handle, false, (uint)layers.Total()))
|
| return(false);
|
| for(int i = 0; i < layers.Total(); i++)
|
| {
|
| CLayer *layer = layers.At(i);
|
| CNeuronBaseOCL *node = layer.At(0);
|
| if(!NNInferenceHeader(handle, false, (uint)i) || !node.InferenceRuntimeSidecar(handle, false))
|
| return(false);
|
| }
|
| return(NNInferenceHeader(handle, false, 0x454e4431));
|
| }
|
| //+------------------------------------------------------------------+
|
| //| InferenceSnapshotLoadFile |
|
| //+------------------------------------------------------------------+
|
| bool CNet::InferenceSnapshotLoadFile(const string file_name, const bool common)
|
| {
|
| const int handle = FileOpen(file_name, FILE_READ | FILE_BIN | (common ? FILE_COMMON : 0));
|
| if(handle == INVALID_HANDLE)
|
| return(false);
|
| bool accepted = false;
|
| do
|
| {
|
| if(FileSize(handle) < 48)
|
| break;
|
| const double error = FileReadDouble(handle), undefined = FileReadDouble(handle), forecast = FileReadDouble(handle);
|
| const long stamp = FileReadLong(handle);
|
| if(!MathIsValidNumber(error) || !MathIsValidNumber(undefined) || !MathIsValidNumber(forecast) || stamp <= 0
|
| || FileReadLong(handle) != -1 || FileReadInteger(handle) != layers.Type())
|
| break;
|
| const int count = FileReadInteger(handle);
|
| if((count != 5 && count != 7))
|
| break;
|
| int loaded = 0;
|
| for(int i = 0; i < count; i++)
|
| {
|
| CLayer *layer = new CLayer(0, handle, opencl);
|
| if(layer == NULL)
|
| break;
|
| const ulong position = FileTell(handle);
|
| const int tail[] =
|
| {
|
| defNeuronCogDriverData, defNeuronCogDriverRankTCM, defNeuronOMPBOCL, defNeuronScenarioForecast
|
| }
|
| ;
|
| const int expected = (i >= count - 4 ? tail[i - (count - 4)] : (i == 0 ? defNeuronBaseOCL : (i == 1 ? defNeuronBatchNormOCL : defNeuronDropoutOCL)));
|
| bool framed = (NNInferenceRemaining(handle, 20) && FileReadLong(handle) == -1
|
| && FileReadInteger(handle) == layer.Type() && FileReadInteger(handle) == 1);
|
| if(framed)
|
| {
|
| const int actual = FileReadInteger(handle);
|
| framed = (actual == expected ||
|
| (expected == defNeuronScenarioForecast && actual == defNeuronScenarioForecastPriceOCL));
|
| }
|
| if(!FileSeek(handle, (long)position, SEEK_SET) || !framed || !layer.Load(handle) || layer.Total() != 1
|
| || !layers.Add(layer))
|
| {
|
| delete layer;
|
| break;
|
| }
|
| loaded++;
|
| }
|
| if(loaded != count || FileTell(handle) != FileSize(handle) || !InferenceSnapshotGraph())
|
| break;
|
| recentAverageError = (float)error;
|
| accepted = true;
|
| }
|
| while(false);
|
| FileClose(handle);
|
| return(accepted);
|
| }
|
| //+------------------------------------------------------------------+
|
| //| LoadInferenceRuntimeSnapshot |
|
| //+------------------------------------------------------------------+
|
| bool CNet::LoadInferenceRuntimeSnapshot(const string file_name, const int sidecar_handle, const bool common)
|
| {
|
| if(m_inference_load_active || pendingOpenCL != NULL || (layers && layers.Total() != 0) || (opencl && !bOwnOpenCL)
|
| || sidecar_handle == INVALID_HANDLE)
|
| return(false);
|
| if(!layers)
|
| layers = new CArrayLayer();
|
| if(!layers)
|
| return(false);
|
| if(!opencl && !OpenCLInit())
|
| return(false);
|
| m_inference_load_active = true;
|
| bool accepted = InferenceSnapshotLoadFile(file_name, common);
|
| if(accepted)
|
| accepted = TrainMode(false) && SetWeightsUpdate(false) && NNInferenceHeader(sidecar_handle, true, 0x49534631)
|
| && NNInferenceHeader(sidecar_handle, true, (uint)layers.Total());
|
| if(accepted)
|
| {
|
| for(int i = 0; i < layers.Total(); i++)
|
| {
|
| CLayer *layer = layers.At(i);
|
| CNeuronBaseOCL *node = layer.At(0);
|
| if(!NNInferenceHeader(sidecar_handle, true, (uint)i) || !node.InferenceRuntimeSidecar(sidecar_handle, true))
|
| {
|
| accepted = false;
|
| break;
|
| }
|
| }
|
| }
|
| if(accepted)
|
| accepted = NNInferenceHeader(sidecar_handle, true, 0x454e4431)
|
| && FileTell(sidecar_handle) == FileSize(sidecar_handle);
|
| m_inference_load_active = false;
|
| if(!accepted)
|
| layers.Clear();
|
| return(accepted);
|
| }
|
| //+------------------------------------------------------------------+
|
| //| LoadInferenceFinite |
|
| //+------------------------------------------------------------------+
|
| bool CBufferFloat::LoadInferenceFinite(const int handle, COpenCLMy *receiver)
|
| {
|
| if(!receiver || !receiver.InferenceRuntimeLoadActive() || handle == INVALID_HANDLE)
|
| return(false);
|
| if(!NNInferenceRemaining(handle, 16))
|
| return(false);
|
| const ulong position = FileTell(handle), remaining = FileSize(handle) - position;
|
| const long marker = FileReadLong(handle);
|
| const int type = FileReadInteger(handle), count = FileReadInteger(handle);
|
| if(!FileSeek(handle, (long)position, SEEK_SET) || marker != -1 || type != Type() || count < 0 || (ulong)count > 268435456
|
| || (ulong)count * 4 > remaining - 16)
|
| return(false);
|
| ResetLastError();
|
| if(!CArrayFloat::Load(handle) || GetLastError() != 0 || m_data_total != count)
|
| return(false);
|
| for(int i = 0; i < count; i++)
|
| if(!MathIsValidNumber((double)m_data[i]))
|
| return(false);
|
| BufferFree();
|
| if(count > 0 && !BufferCreate(receiver))
|
| return(false);
|
| return(true);
|
| }
|
| //+------------------------------------------------------------------+
|
| //| NNInferenceRequired |
|
| //+------------------------------------------------------------------+
|
| bool NNInferenceRequired(CBufferFloat *buffer, COpenCLMy *receiver, const int count)
|
| {
|
| return(buffer != NULL && CheckPointer(buffer) != POINTER_INVALID && CheckPointer(receiver) != POINTER_INVALID
|
| && count > 0 && buffer.Total() == count && buffer.GetOpenCL() == receiver
|
| && buffer.GetIndex() >= 0 && receiver.GetBufferSize(buffer.GetIndex()) == (ulong)count * 4
|
| && NNInferenceFinite(buffer));
|
| }
|
| //+------------------------------------------------------------------+
|
| //| InferenceRuntimeSidecar |
|
| //+------------------------------------------------------------------+
|
| bool CNeuronDropoutOCL::InferenceRuntimeSidecar(const int handle, const bool restore)
|
| {
|
| return(!bTrain && MathIsValidNumber((double)OutProbability) && OutProbability >= 0 && OutProbability < 1
|
| && CNeuronBaseOCL::InferenceRuntimeSidecar(handle, restore));
|
| }
|
| //+------------------------------------------------------------------+
|
| //| InferenceRuntimeSidecar |
|
| //+------------------------------------------------------------------+
|
| bool CNeuronConvOCL::InferenceRuntimeSidecar(const int handle, const bool restore)
|
| {
|
| return(CNeuronBaseOCL::InferenceRuntimeSidecar(handle, restore)
|
| && CheckPointer(WeightsConv) != POINTER_INVALID && NNInferenceRequired(WeightsConv, OpenCL, WeightsConv.Total())
|
| && NNInferenceFinite(DeltaWeightsConv)
|
| && NNInferenceFinite(FirstMomentumConv) && NNInferenceFinite(SecondMomentumConv));
|
| }
|
| //+------------------------------------------------------------------+
|
| //| InferenceRuntimeSidecar |
|
| //+------------------------------------------------------------------+
|
| bool CNeuronBatchNormOCL::InferenceRuntimeSidecar(const int handle, const bool restore)
|
| {
|
| return(CNeuronBaseOCL::InferenceRuntimeSidecar(handle, restore)
|
| && CheckPointer(BatchOptions) != POINTER_INVALID
|
| && NNInferenceRequired(BatchOptions, OpenCL, BatchOptions.Total()));
|
| }
|
| //+------------------------------------------------------------------+
|
| //| InferenceRuntimeSidecar |
|
| //+------------------------------------------------------------------+
|
| bool CParams::InferenceRuntimeSidecar(const int handle, const bool restore)
|
| {
|
| return(CNeuronBaseOCL::InferenceRuntimeSidecar(handle, restore) && NNInferenceHeader(handle, restore, 701)
|
| && cOne.InferenceRuntimeSidecar(handle, restore));
|
| }
|
| //+------------------------------------------------------------------+
|
| //| InferenceRuntimeSidecar |
|
| //+------------------------------------------------------------------+
|
| bool CNeuronBayesianLinearOCL::InferenceRuntimeSidecar(const int handle, const bool restore)
|
| {
|
| return(CNeuronBaseOCL::InferenceRuntimeSidecar(handle, restore) && NNInferenceHeader(handle, restore, iVariables)
|
| && NNInferenceHeader(handle, restore, iInputs) && NNInferenceHeader(handle, restore, iOutputs)
|
| && NNInferenceHeader(handle, restore, iSamples) && NNInferenceHeader(handle, restore, 801)
|
| && cWeights.InferenceRuntimeSidecar(handle, restore) && NNInferenceHeader(handle, restore, 802)
|
| && cBias.InferenceRuntimeSidecar(handle, restore));
|
| }
|
| #endif
|
| //+------------------------------------------------------------------+
|
| //+------------------------------------------------------------------+
|
